Otaku-Projects / AngularJS-CRUD-PHP

(function(window, angular, undefined) {'use strict';

/* global ngTouchClickDirectiveFactory: false,

 */

/**

 * @ngdoc module

 * @name ngTouch

 * @description

 *

 * # ngTouch

 *

 * The `ngTouch` module provides touch events and other helpers for touch-enabled devices.

 * The implementation is based on jQuery Mobile touch event handling

 * ([jquerymobile.com](http://jquerymobile.com/)).

 *

 *

 * See {@link ngTouch.$swipe `$swipe`} for usage.

 *

 * <div doc-module-components="ngTouch"></div>

 *

 */

// define ngTouch module

/* global -ngTouch */

var ngTouch = angular.module('ngTouch', []);

ngTouch.provider('$touch', $TouchProvider);

function nodeName_(element) {

  return angular.lowercase(element.nodeName || (element[0] && element[0].nodeName));

}

/**

 * @ngdoc provider

 * @name $touchProvider

 *

 * @description

 * The `$touchProvider` allows enabling / disabling {@link ngTouch.ngClick ngTouch's ngClick directive}.

 */

$TouchProvider.$inject = ['$provide', '$compileProvider'];

function $TouchProvider($provide, $compileProvider) {

  /**

   * @ngdoc method

   * @name  $touchProvider#ngClickOverrideEnabled

   *

   * @param {boolean=} enabled update the ngClickOverrideEnabled state if provided, otherwise just return the

   * current ngClickOverrideEnabled state

   * @returns {*} current value if used as getter or itself (chaining) if used as setter

   *

   * @kind function

   *

   * @description

   * Call this method to enable/disable {@link ngTouch.ngClick ngTouch's ngClick directive}. If enabled,

   * the default ngClick directive will be replaced by a version that eliminates the 300ms delay for

   * click events on browser for touch-devices.

   *

   * The default is `false`.

   *

   */

  var ngClickOverrideEnabled = false;

  var ngClickDirectiveAdded = false;

  this.ngClickOverrideEnabled = function(enabled) {

    if (angular.isDefined(enabled)) {

      if (enabled && !ngClickDirectiveAdded) {

        ngClickDirectiveAdded = true;

        // Use this to identify the correct directive in the delegate

        ngTouchClickDirectiveFactory.$$moduleName = 'ngTouch';

        $compileProvider.directive('ngClick', ngTouchClickDirectiveFactory);

        $provide.decorator('ngClickDirective', ['$delegate', function($delegate) {

          if (ngClickOverrideEnabled) {

            // drop the default ngClick directive

            $delegate.shift();

          } else {

            // drop the ngTouch ngClick directive if the override has been re-disabled (because

            // we cannot de-register added directives)

            var i = $delegate.length - 1;

            while (i >= 0) {

              if ($delegate[i].$$moduleName === 'ngTouch') {

                $delegate.splice(i, 1);

                break;

              }

              i--;

            }

          }

          return $delegate;

        }]);

      }

      ngClickOverrideEnabled = enabled;

      return this;

    }

    return ngClickOverrideEnabled;

  };

  /**

  * @ngdoc service

  * @name $touch

  * @kind object

  *

  * @description

  * Provides the {@link ngTouch.$touch#ngClickOverrideEnabled `ngClickOverrideEnabled`} method.

  *

  */

  this.$get = function() {

    return {

      /**

       * @ngdoc method

       * @name  $touch#ngClickOverrideEnabled

       *

       * @returns {*} current value of `ngClickOverrideEnabled` set in the {@link ngTouch.$touchProvider $touchProvider},

       * i.e. if {@link ngTouch.ngClick ngTouch's ngClick} directive is enabled.

       *

       * @kind function

       */

      ngClickOverrideEnabled: function() {

        return ngClickOverrideEnabled;

      }

    };

  };

}

/* global ngTouch: false */

    /**

     * @ngdoc service

     * @name $swipe

     *

     * @description

     * The `$swipe` service is a service that abstracts the messier details of hold-and-drag swipe

     * behavior, to make implementing swipe-related directives more convenient.

     *

     * Requires the {@link ngTouch `ngTouch`} module to be installed.

     *

     * `$swipe` is used by the `ngSwipeLeft` and `ngSwipeRight` directives in `ngTouch`.

     *

     * # Usage

     * The `$swipe` service is an object with a single method: `bind`. `bind` takes an element

     * which is to be watched for swipes, and an object with four handler functions. See the

     * documentation for `bind` below.

     */

ngTouch.factory('$swipe', [function() {

  // The total distance in any direction before we make the call on swipe vs. scroll.

  var MOVE_BUFFER_RADIUS = 10;

  var POINTER_EVENTS = {

    'mouse': {

      start: 'mousedown',

      move: 'mousemove',

      end: 'mouseup'

    },

    'touch': {

      start: 'touchstart',

      move: 'touchmove',

      end: 'touchend',

      cancel: 'touchcancel'

    }

  };

  function getCoordinates(event) {

    var originalEvent = event.originalEvent || event;

    var touches = originalEvent.touches && originalEvent.touches.length ? originalEvent.touches : [originalEvent];

    var e = (originalEvent.changedTouches && originalEvent.changedTouches[0]) || touches[0];

    return {

      x: e.clientX,

      y: e.clientY

    };

  }

  function getEvents(pointerTypes, eventType) {

    var res = [];

    angular.forEach(pointerTypes, function(pointerType) {

      var eventName = POINTER_EVENTS[pointerType][eventType];

      if (eventName) {

        res.push(eventName);

      }

    });

    return res.join(' ');

  }

  return {

    /**

     * @ngdoc method

     * @name $swipe#bind

     *

     * @description

     * The main method of `$swipe`. It takes an element to be watched for swipe motions, and an

     * object containing event handlers.

     * The pointer types that should be used can be specified via the optional

     * third argument, which is an array of strings `'mouse'` and `'touch'`. By default,

     * `$swipe` will listen for `mouse` and `touch` events.

     *

     * The four events are `start`, `move`, `end`, and `cancel`. `start`, `move`, and `end`

     * receive as a parameter a coordinates object of the form `{ x: 150, y: 310 }` and the raw

     * `event`. `cancel` receives the raw `event` as its single parameter.

     *

     * `start` is called on either `mousedown` or `touchstart`. After this event, `$swipe` is

     * watching for `touchmove` or `mousemove` events. These events are ignored until the total

     * distance moved in either dimension exceeds a small threshold.

     *

     * Once this threshold is exceeded, either the horizontal or vertical delta is greater.

     * - If the horizontal distance is greater, this is a swipe and `move` and `end` events follow.

     * - If the vertical distance is greater, this is a scroll, and we let the browser take over.

     *   A `cancel` event is sent.

     *

     * `move` is called on `mousemove` and `touchmove` after the above logic has determined that

     * a swipe is in progress.

     *

     * `end` is called when a swipe is successfully completed with a `touchend` or `mouseup`.

     *

     * `cancel` is called either on a `touchcancel` from the browser, or when we begin scrolling

     * as described above.

     *

     */

    bind: function(element, eventHandlers, pointerTypes) {

      // Absolute total movement, used to control swipe vs. scroll.

      var totalX, totalY;

      // Coordinates of the start position.

      var startCoords;

      // Last event's position.

      var lastPos;

      // Whether a swipe is active.

      var active = false;

      pointerTypes = pointerTypes || ['mouse', 'touch'];

      element.on(getEvents(pointerTypes, 'start'), function(event) {

        startCoords = getCoordinates(event);

        active = true;

        totalX = 0;

        totalY = 0;

        lastPos = startCoords;

        eventHandlers['start'] && eventHandlers['start'](startCoords, event);

      });

      var events = getEvents(pointerTypes, 'cancel');

      if (events) {

        element.on(events, function(event) {

          active = false;

          eventHandlers['cancel'] && eventHandlers['cancel'](event);

        });

      }

      element.on(getEvents(pointerTypes, 'move'), function(event) {

        if (!active) return;

        // Android will send a touchcancel if it thinks we're starting to scroll.

        // So when the total distance (+ or - or both) exceeds 10px in either direction,

        // we either:

        // - On totalX > totalY, we send preventDefault() and treat this as a swipe.

        // - On totalY > totalX, we let the browser handle it as a scroll.

        if (!startCoords) return;

        var coords = getCoordinates(event);

        totalX += Math.abs(coords.x - lastPos.x);

        totalY += Math.abs(coords.y - lastPos.y);

        lastPos = coords;

        if (totalX < MOVE_BUFFER_RADIUS && totalY < MOVE_BUFFER_RADIUS) {

          return;

        }

        // One of totalX or totalY has exceeded the buffer, so decide on swipe vs. scroll.

        if (totalY > totalX) {

          // Allow native scrolling to take over.

          active = false;

          eventHandlers['cancel'] && eventHandlers['cancel'](event);

          // Prevent the browser from scrolling.

          event.preventDefault();

          eventHandlers['move'] && eventHandlers['move'](coords, event);

        }

      });

      element.on(getEvents(pointerTypes, 'end'), function(event) {

        if (!active) return;

        active = false;

        eventHandlers['end'] && eventHandlers['end'](getCoordinates(event), event);

      });

    }

  };

}]);

/* global ngTouch: false,

  nodeName_: false

*/

/**

 * @ngdoc directive

 * @name ngClick

 * @deprecated

 *

 * @description

 * <div class="alert alert-danger">

 * **DEPRECATION NOTICE**: Beginning with Angular 1.5, this directive is deprecated and by default **disabled**.

 * The directive will receive no further support and might be removed from future releases.

 * If you need the directive, you can enable it with the {@link ngTouch.$touchProvider $touchProvider#ngClickOverrideEnabled}

 * function. We also recommend that you migrate to [FastClick](https://github.com/ftlabs/fastclick).

 * To learn more about the 300ms delay, this [Telerik article](http://developer.telerik.com/featured/300-ms-click-delay-ios-8/)

 * gives a good overview.

 * </div>

 * A more powerful replacement for the default ngClick designed to be used on touchscreen

 * devices. Most mobile browsers wait about 300ms after a tap-and-release before sending

 * the click event. This version handles them immediately, and then prevents the

 * following click event from propagating.

 *

 * Requires the {@link ngTouch `ngTouch`} module to be installed.

 *

 * This directive can fall back to using an ordinary click event, and so works on desktop

 * browsers as well as mobile.

 *

 * This directive also sets the CSS class `ng-click-active` while the element is being held

 * down (by a mouse click or touch) so you can restyle the depressed element if you wish.

 *

 * @element ANY

 * @param {expression} ngClick {@link guide/expression Expression} to evaluate

 * upon tap. (Event object is available as `$event`)

 *

 * @example

    <example module="ngClickExample" deps="angular-touch.js">

      <file name="index.html">

        <button ng-click="count = count + 1" ng-init="count=0">

          Increment

        </button>

        count: {{ count }}

      </file>

      <file name="script.js">

        angular.module('ngClickExample', ['ngTouch']);

      </file>

    </example>

 */

var ngTouchClickDirectiveFactory = ['$parse', '$timeout', '$rootElement',

    function($parse, $timeout, $rootElement) {

  var TAP_DURATION = 750; // Shorter than 750ms is a tap, longer is a taphold or drag.

  var MOVE_TOLERANCE = 12; // 12px seems to work in most mobile browsers.

  var PREVENT_DURATION = 2500; // 2.5 seconds maximum from preventGhostClick call to click

  var CLICKBUSTER_THRESHOLD = 25; // 25 pixels in any dimension is the limit for busting clicks.

  var ACTIVE_CLASS_NAME = 'ng-click-active';

  var lastPreventedTime;

  var touchCoordinates;

  var lastLabelClickCoordinates;

  // TAP EVENTS AND GHOST CLICKS

  //

  // Why tap events?

  // Mobile browsers detect a tap, then wait a moment (usually ~300ms) to see if you're

  // double-tapping, and then fire a click event.

  //

  // This delay sucks and makes mobile apps feel unresponsive.

  // So we detect touchstart, touchcancel and touchend ourselves and determine when

  // the user has tapped on something.

  //

  // What happens when the browser then generates a click event?

  // The browser, of course, also detects the tap and fires a click after a delay. This results in

  // tapping/clicking twice. We do "clickbusting" to prevent it.

  //

  // How does it work?

  // We attach global touchstart and click handlers, that run during the capture (early) phase.

  // So the sequence for a tap is:

  // - global touchstart: Sets an "allowable region" at the point touched.

  // - element's touchstart: Starts a touch

  // (- touchcancel ends the touch, no click follows)

  // - element's touchend: Determines if the tap is valid (didn't move too far away, didn't hold

  //   too long) and fires the user's tap handler. The touchend also calls preventGhostClick().

  // - preventGhostClick() removes the allowable region the global touchstart created.

  // - The browser generates a click event.

  // - The global click handler catches the click, and checks whether it was in an allowable region.

  //     - If preventGhostClick was called, the region will have been removed, the click is busted.

  //     - If the region is still there, the click proceeds normally. Therefore clicks on links and

  //       other elements without ngTap on them work normally.

  //

  // This is an ugly, terrible hack!

  // Yeah, tell me about it. The alternatives are using the slow click events, or making our users

  // deal with the ghost clicks, so I consider this the least of evils. Fortunately Angular

  // encapsulates this ugly logic away from the user.

  //

  // Why not just put click handlers on the element?

  // We do that too, just to be sure. If the tap event caused the DOM to change,

  // it is possible another element is now in that position. To take account for these possibly

  // distinct elements, the handlers are global and care only about coordinates.

  // Checks if the coordinates are close enough to be within the region.

  function hit(x1, y1, x2, y2) {

    return Math.abs(x1 - x2) < CLICKBUSTER_THRESHOLD && Math.abs(y1 - y2) < CLICKBUSTER_THRESHOLD;

  }

  // Checks a list of allowable regions against a click location.

  // Returns true if the click should be allowed.

  // Splices out the allowable region from the list after it has been used.

  function checkAllowableRegions(touchCoordinates, x, y) {

    for (var i = 0; i < touchCoordinates.length; i += 2) {

      if (hit(touchCoordinates[i], touchCoordinates[i + 1], x, y)) {

        touchCoordinates.splice(i, i + 2);

        return true; // allowable region

      }

    }

    return false; // No allowable region; bust it.

  }

  // Global click handler that prevents the click if it's in a bustable zone and preventGhostClick

  // was called recently.

  function onClick(event) {

    if (Date.now() - lastPreventedTime > PREVENT_DURATION) {

      return; // Too old.

    }

    var touches = event.touches && event.touches.length ? event.touches : [event];

    var x = touches[0].clientX;

    var y = touches[0].clientY;

    // Work around desktop Webkit quirk where clicking a label will fire two clicks (on the label

    // and on the input element). Depending on the exact browser, this second click we don't want

    // to bust has either (0,0), negative coordinates, or coordinates equal to triggering label

    // click event

    if (x < 1 && y < 1) {

      return; // offscreen

    }

    if (lastLabelClickCoordinates &&

        lastLabelClickCoordinates[0] === x && lastLabelClickCoordinates[1] === y) {

      return; // input click triggered by label click

    }

    // reset label click coordinates on first subsequent click

    if (lastLabelClickCoordinates) {

      lastLabelClickCoordinates = null;

    }

    // remember label click coordinates to prevent click busting of trigger click event on input

    if (nodeName_(event.target) === 'label') {

      lastLabelClickCoordinates = [x, y];

    }

    // Look for an allowable region containing this click.

    // If we find one, that means it was created by touchstart and not removed by

    // preventGhostClick, so we don't bust it.

    if (checkAllowableRegions(touchCoordinates, x, y)) {

      return;

    }

    // If we didn't find an allowable region, bust the click.

    event.stopPropagation();

    event.preventDefault();

    // Blur focused form elements

    event.target && event.target.blur && event.target.blur();

  }

  // Global touchstart handler that creates an allowable region for a click event.

  // This allowable region can be removed by preventGhostClick if we want to bust it.

  function onTouchStart(event) {

    var touches = event.touches && event.touches.length ? event.touches : [event];

    var x = touches[0].clientX;

    var y = touches[0].clientY;

    touchCoordinates.push(x, y);

    $timeout(function() {

      // Remove the allowable region.

      for (var i = 0; i < touchCoordinates.length; i += 2) {

        if (touchCoordinates[i] == x && touchCoordinates[i + 1] == y) {

          touchCoordinates.splice(i, i + 2);

          return;

        }

      }

    }, PREVENT_DURATION, false);

  }

  // On the first call, attaches some event handlers. Then whenever it gets called, it creates a

  // zone around the touchstart where clicks will get busted.

  function preventGhostClick(x, y) {

    if (!touchCoordinates) {

      $rootElement[0].addEventListener('click', onClick, true);

      $rootElement[0].addEventListener('touchstart', onTouchStart, true);

      touchCoordinates = [];

    }

    lastPreventedTime = Date.now();

    checkAllowableRegions(touchCoordinates, x, y);

  }

  // Actual linking function.

  return function(scope, element, attr) {

    var clickHandler = $parse(attr.ngClick),

        tapping = false,

        tapElement,  // Used to blur the element after a tap.

        startTime,   // Used to check if the tap was held too long.

        touchStartX,

        touchStartY;

    function resetState() {

      tapping = false;

      element.removeClass(ACTIVE_CLASS_NAME);

    }

    element.on('touchstart', function(event) {

      tapping = true;

      tapElement = event.target ? event.target : event.srcElement; // IE uses srcElement.

      // Hack for Safari, which can target text nodes instead of containers.

      if (tapElement.nodeType == 3) {

        tapElement = tapElement.parentNode;

      }

      element.addClass(ACTIVE_CLASS_NAME);

      startTime = Date.now();

      // Use jQuery originalEvent

      var originalEvent = event.originalEvent || event;

      var touches = originalEvent.touches && originalEvent.touches.length ? originalEvent.touches : [originalEvent];

      var e = touches[0];

      touchStartX = e.clientX;

      touchStartY = e.clientY;

    });

    element.on('touchcancel', function(event) {

      resetState();

    });

    element.on('touchend', function(event) {

      var diff = Date.now() - startTime;

      // Use jQuery originalEvent

      var originalEvent = event.originalEvent || event;

      var touches = (originalEvent.changedTouches && originalEvent.changedTouches.length) ?

          originalEvent.changedTouches :

          ((originalEvent.touches && originalEvent.touches.length) ? originalEvent.touches : [originalEvent]);

      var e = touches[0];

      var x = e.clientX;

      var y = e.clientY;

      var dist = Math.sqrt(Math.pow(x - touchStartX, 2) + Math.pow(y - touchStartY, 2));

      if (tapping && diff < TAP_DURATION && dist < MOVE_TOLERANCE) {

        // Call preventGhostClick so the clickbuster will catch the corresponding click.

        preventGhostClick(x, y);

        // Blur the focused element (the button, probably) before firing the callback.

        // This doesn't work perfectly on Android Chrome, but seems to work elsewhere.

        // I couldn't get anything to work reliably on Android Chrome.

        if (tapElement) {

          tapElement.blur();

        }

        if (!angular.isDefined(attr.disabled) || attr.disabled === false) {

          element.triggerHandler('click', [event]);

        }

      }

      resetState();

    });

    // Hack for iOS Safari's benefit. It goes searching for onclick handlers and is liable to click

    // something else nearby.

    element.onclick = function(event) { };

    // Actual click handler.

    // There are three different kinds of clicks, only two of which reach this point.

    // - On desktop browsers without touch events, their clicks will always come here.

    // - On mobile browsers, the simulated "fast" click will call this.

    // - But the browser's follow-up slow click will be "busted" before it reaches this handler.

    // Therefore it's safe to use this directive on both mobile and desktop.

    element.on('click', function(event, touchend) {

      scope.$apply(function() {

        clickHandler(scope, {$event: (touchend || event)});

      });

    });

    element.on('mousedown', function(event) {

      element.addClass(ACTIVE_CLASS_NAME);

    });

    element.on('mousemove mouseup', function(event) {

      element.removeClass(ACTIVE_CLASS_NAME);

    });

  };

}];

/* global ngTouch: false */

/**

 * @ngdoc directive

 * @name ngSwipeLeft

 *

 * @description

 * Specify custom behavior when an element is swiped to the left on a touchscreen device.

 * A leftward swipe is a quick, right-to-left slide of the finger.

 * Though ngSwipeLeft is designed for touch-based devices, it will work with a mouse click and drag

 * too.

 *

 * To disable the mouse click and drag functionality, add `ng-swipe-disable-mouse` to

 * the `ng-swipe-left` or `ng-swipe-right` DOM Element.

 *

 * Requires the {@link ngTouch `ngTouch`} module to be installed.

 *

 * @element ANY

 * @param {expression} ngSwipeLeft {@link guide/expression Expression} to evaluate

 * upon left swipe. (Event object is available as `$event`)

 *

 * @example

    <example module="ngSwipeLeftExample" deps="angular-touch.js">

      <file name="index.html">

        <div ng-show="!showActions" ng-swipe-left="showActions = true">

          Some list content, like an email in the inbox

        </div>

        <div ng-show="showActions" ng-swipe-right="showActions = false">

          <button ng-click="reply()">Reply</button>

          <button ng-click="delete()">Delete</button>

        </div>

      </file>

      <file name="script.js">

        angular.module('ngSwipeLeftExample', ['ngTouch']);

      </file>

    </example>

 */

/**

 * @ngdoc directive

 * @name ngSwipeRight

 *

 * @description

 * Specify custom behavior when an element is swiped to the right on a touchscreen device.

 * A rightward swipe is a quick, left-to-right slide of the finger.

 * Though ngSwipeRight is designed for touch-based devices, it will work with a mouse click and drag

 * too.

 *

 * Requires the {@link ngTouch `ngTouch`} module to be installed.

 *

 * @element ANY

 * @param {expression} ngSwipeRight {@link guide/expression Expression} to evaluate

 * upon right swipe. (Event object is available as `$event`)

 *

 * @example

    <example module="ngSwipeRightExample" deps="angular-touch.js">

      <file name="index.html">

        <div ng-show="!showActions" ng-swipe-left="showActions = true">

          Some list content, like an email in the inbox

        </div>

        <div ng-show="showActions" ng-swipe-right="showActions = false">

          <button ng-click="reply()">Reply</button>

          <button ng-click="delete()">Delete</button>

        </div>

      </file>

      <file name="script.js">

        angular.module('ngSwipeRightExample', ['ngTouch']);

      </file>

    </example>

 */

function makeSwipeDirective(directiveName, direction, eventName) {

  ngTouch.directive(directiveName, ['$parse', '$swipe', function($parse, $swipe) {

    // The maximum vertical delta for a swipe should be less than 75px.

    var MAX_VERTICAL_DISTANCE = 75;

    // Vertical distance should not be more than a fraction of the horizontal distance.

    var MAX_VERTICAL_RATIO = 0.3;

    // At least a 30px lateral motion is necessary for a swipe.

    var MIN_HORIZONTAL_DISTANCE = 30;

    return function(scope, element, attr) {

      var swipeHandler = $parse(attr[directiveName]);

      var startCoords, valid;

      function validSwipe(coords) {

        // Check that it's within the coordinates.

        // Absolute vertical distance must be within tolerances.

        // Horizontal distance, we take the current X - the starting X.

        // This is negative for leftward swipes and positive for rightward swipes.

        // After multiplying by the direction (-1 for left, +1 for right), legal swipes

        // (ie. same direction as the directive wants) will have a positive delta and

        // illegal ones a negative delta.

        // Therefore this delta must be positive, and larger than the minimum.

        if (!startCoords) return false;

        var deltaY = Math.abs(coords.y - startCoords.y);

        var deltaX = (coords.x - startCoords.x) * direction;

        return valid && // Short circuit for already-invalidated swipes.

            deltaY < MAX_VERTICAL_DISTANCE &&

            deltaX > 0 &&

            deltaX > MIN_HORIZONTAL_DISTANCE &&

            deltaY / deltaX < MAX_VERTICAL_RATIO;

      }

      var pointerTypes = ['touch'];

      if (!angular.isDefined(attr['ngSwipeDisableMouse'])) {

        pointerTypes.push('mouse');

      }

      $swipe.bind(element, {

        'start': function(coords, event) {

          startCoords = coords;

          valid = true;

        },

        'cancel': function(event) {

          valid = false;

        },

        'end': function(coords, event) {

          if (validSwipe(coords)) {

            scope.$apply(function() {

              element.triggerHandler(eventName);

              swipeHandler(scope, {$event: event});

            });

          }

        }

      }, pointerTypes);

    };

  }]);

}

// Left is negative X-coordinate, right is positive.

makeSwipeDirective('ngSwipeLeft', -1, 'swipeleft');

makeSwipeDirective('ngSwipeRight', 1, 'swiperight');

})(window, window.angular);