@angular-wave/angular.ts 0.0.1

package/src/core/interpolate.js

@@ -0,0 +1,442 @@
+import {
+  minErr,
+  isDefined,
+  isUndefined,
+  stringify,
+  valueFn,
+  extend,
+} from "./utils";
+
+const $interpolateMinErr = minErr("$interpolate");
+$interpolateMinErr.throwNoconcat = function (text) {
+  throw $interpolateMinErr(
+    "noconcat",
+    "Error while interpolating: {0}\nStrict Contextual Escaping disallows " +
+      "interpolations that concatenate multiple expressions when a trusted value is " +
+      "required.  See http://docs.angularjs.org/api/ng.$sce",
+    text,
+  );
+};
+
+$interpolateMinErr.interr = function (text, err) {
+  throw $interpolateMinErr(
+    "interr",
+    "Can't interpolate: {0}\n{1}",
+    text,
+    err.toString(),
+  );
+};
+
+/**
+ * @ngdoc provider
+ * @name $interpolateProvider
+ *
+ *
+ * @description
+ *
+ * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
+ *
+ * <div class="alert alert-danger">
+ * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularJS
+ * template within a Python Jinja template (or any other template language). Mixing templating
+ * languages is **very dangerous**. The embedding template language will not safely escape AngularJS
+ * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
+ * security bugs!
+ * </div>
+ */
+export function $InterpolateProvider() {
+  let startSymbol = "{{";
+  let endSymbol = "}}";
+
+  /**
+   * @ngdoc method
+   * @name $interpolateProvider#startSymbol
+   * @description
+   * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
+   *
+   * @param {string=} value new value to set the starting symbol to.
+   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   */
+  this.startSymbol = function (value) {
+    if (value) {
+      startSymbol = value;
+      return this;
+    }
+    return startSymbol;
+  };
+
+  /**
+   * @ngdoc method
+   * @name $interpolateProvider#endSymbol
+   * @description
+   * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+   *
+   * @param {string=} value new value to set the ending symbol to.
+   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   */
+  this.endSymbol = function (value) {
+    if (value) {
+      endSymbol = value;
+      return this;
+    }
+    return endSymbol;
+  };
+
+  this.$get = [
+    "$parse",
+    "$exceptionHandler",
+    "$sce",
+    function ($parse, $exceptionHandler, $sce) {
+      const startSymbolLength = startSymbol.length;
+      const endSymbolLength = endSymbol.length;
+      const escapedStartRegexp = new RegExp(
+        startSymbol.replace(/./g, escape),
+        "g",
+      );
+      const escapedEndRegexp = new RegExp(endSymbol.replace(/./g, escape), "g");
+
+      function escape(ch) {
+        return `\\\\\\${ch}`;
+      }
+
+      function unescapeText(text) {
+        return text
+          .replace(escapedStartRegexp, startSymbol)
+          .replace(escapedEndRegexp, endSymbol);
+      }
+
+      // TODO: this is the same as the constantWatchDelegate in parse.js
+      function constantWatchDelegate(
+        scope,
+        listener,
+        objectEquality,
+        constantInterp,
+      ) {
+        const unwatch = scope.$watch(
+          (scope) => {
+            unwatch();
+            return constantInterp(scope);
+          },
+          listener,
+          objectEquality,
+        );
+        return unwatch;
+      }
+
+      /**
+       * @ngdoc service
+       * @name $interpolate
+       * @kind function
+       *
+       * @requires $parse
+       * @requires $sce
+       *
+       * @description
+       *
+       * Compiles a string with markup into an interpolation function. This service is used by the
+       * HTML {@link ng.$compile $compile} service for data binding. See
+       * {@link ng.$interpolateProvider $interpolateProvider} for configuring the
+       * interpolation markup.
+       *
+       *
+       * ```js
+       *   let $interpolate = ...; // injected
+       *   let exp = $interpolate('Hello {{name | uppercase}}!');
+       *   expect(exp({name:'AngularJS'})).toEqual('Hello ANGULARJS!');
+       * ```
+       *
+       * `$interpolate` takes an optional fourth argument, `allOrNothing`. If `allOrNothing` is
+       * `true`, the interpolation function will return `undefined` unless all embedded expressions
+       * evaluate to a value other than `undefined`.
+       *
+       * ```js
+       *   let $interpolate = ...; // injected
+       *   let context = {greeting: 'Hello', name: undefined };
+       *
+       *   // default "forgiving" mode
+       *   let exp = $interpolate('{{greeting}} {{name}}!');
+       *   expect(exp(context)).toEqual('Hello !');
+       *
+       *   // "allOrNothing" mode
+       *   exp = $interpolate('{{greeting}} {{name}}!', false, null, true);
+       *   expect(exp(context)).toBeUndefined();
+       *   context.name = 'AngularJS';
+       *   expect(exp(context)).toEqual('Hello AngularJS!');
+       * ```
+       *
+       * `allOrNothing` is useful for interpolating URLs. `ngSrc` and `ngSrcset` use this behavior.
+       *
+       * #### Escaped Interpolation
+       * $interpolate provides a mechanism for escaping interpolation markers. Start and end markers
+       * can be escaped by preceding each of their characters with a REVERSE SOLIDUS U+005C (backslash).
+       * It will be rendered as a regular start/end marker, and will not be interpreted as an expression
+       * or binding.
+       *
+       * This enables web-servers to prevent script injection attacks and defacing attacks, to some
+       * degree, while also enabling code examples to work without relying on the
+       * {@link ng.directive:ngNonBindable ngNonBindable} directive.
+       *
+       * **For security purposes, it is strongly encouraged that web servers escape user-supplied data,
+       * replacing angle brackets (&lt;, &gt;) with &amp;lt; and &amp;gt; respectively, and replacing all
+       * interpolation start/end markers with their escaped counterparts.**
+       *
+       * Escaped interpolation markers are only replaced with the actual interpolation markers in rendered
+       * output when the $interpolate service processes the text. So, for HTML elements interpolated
+       * by {@link ng.$compile $compile}, or otherwise interpolated with the `mustHaveExpression` parameter
+       * set to `true`, the interpolated text must contain an unescaped interpolation expression. As such,
+       * this is typically useful only when user-data is used in rendering a template from the server, or
+       * when otherwise untrusted data is used by a directive.
+       *
+       * <example name="interpolation">
+       *  <file name="index.html">
+       *    <div ng-init="username='A user'">
+       *      <p ng-init="apptitle='Escaping demo'">{{apptitle}}: \{\{ username = "defaced value"; \}\}
+       *        </p>
+       *      <p><strong>{{username}}</strong> attempts to inject code which will deface the
+       *        application, but fails to accomplish their task, because the server has correctly
+       *        escaped the interpolation start/end markers with REVERSE SOLIDUS U+005C (backslash)
+       *        characters.</p>
+       *      <p>Instead, the result of the attempted script injection is visible, and can be removed
+       *        from the database by an administrator.</p>
+       *    </div>
+       *  </file>
+       * </example>
+       *
+       * @knownIssue
+       * It is currently not possible for an interpolated expression to contain the interpolation end
+       * symbol. For example, `{{ '}}' }}` will be incorrectly interpreted as `{{ ' }}` + `' }}`, i.e.
+       * an interpolated expression consisting of a single-quote (`'`) and the `' }}` string.
+       *
+       * @knownIssue
+       * All directives and components must use the standard `{{` `}}` interpolation symbols
+       * in their templates. If you change the application interpolation symbols the {@link $compile}
+       * service will attempt to denormalize the standard symbols to the custom symbols.
+       * The denormalization process is not clever enough to know not to replace instances of the standard
+       * symbols where they would not normally be treated as interpolation symbols. For example in the following
+       * code snippet the closing braces of the literal object will get incorrectly denormalized:
+       *
+       * ```
+       * <div data-context='{"context":{"id":3,"type":"page"}}">
+       * ```
+       *
+       * The workaround is to ensure that such instances are separated by whitespace:
+       * ```
+       * <div data-context='{"context":{"id":3,"type":"page"} }">
+       * ```
+       *
+       * See https://github.com/angular/angular.js/pull/14610#issuecomment-219401099 for more information.
+       *
+       * @param {string} text The text with markup to interpolate.
+       * @param {boolean=} mustHaveExpression if set to true then the interpolation string must have
+       *    embedded expression in order to return an interpolation function. Strings with no
+       *    embedded expression will return null for the interpolation function.
+       * @param {string=} trustedContext when provided, the returned function passes the interpolated
+       *    result through {@link ng.$sce#getTrusted $sce.getTrusted(interpolatedResult,
+       *    trustedContext)} before returning it.  Refer to the {@link ng.$sce $sce} service that
+       *    provides Strict Contextual Escaping for details.
+       * @param {boolean=} allOrNothing if `true`, then the returned function returns undefined
+       *    unless all embedded expressions evaluate to a value other than `undefined`.
+       * @returns {function(context)} an interpolation function which is used to compute the
+       *    interpolated string. The function has these parameters:
+       *
+       * - `context`: evaluation context for all expressions embedded in the interpolated text
+       */
+      function $interpolate(
+        text,
+        mustHaveExpression,
+        trustedContext,
+        allOrNothing,
+      ) {
+        const contextAllowsConcatenation =
+          trustedContext === $sce.URL || trustedContext === $sce.MEDIA_URL;
+
+        // Provide a quick exit and simplified result function for text with no interpolation
+        if (!text.length || text.indexOf(startSymbol) === -1) {
+          if (mustHaveExpression) return;
+
+          let unescapedText = unescapeText(text);
+          if (contextAllowsConcatenation) {
+            unescapedText = $sce.getTrusted(trustedContext, unescapedText);
+          }
+          const constantInterp = valueFn(unescapedText);
+          constantInterp.exp = text;
+          constantInterp.expressions = [];
+          constantInterp.$$watchDelegate = constantWatchDelegate;
+
+          return constantInterp;
+        }
+
+        allOrNothing = !!allOrNothing;
+        let startIndex;
+        let endIndex;
+        let index = 0;
+        const expressions = [];
+        let parseFns;
+        const textLength = text.length;
+        let exp;
+        const concat = [];
+        const expressionPositions = [];
+        let singleExpression;
+
+        while (index < textLength) {
+          if (
+            (startIndex = text.indexOf(startSymbol, index)) !== -1 &&
+            (endIndex = text.indexOf(
+              endSymbol,
+              startIndex + startSymbolLength,
+            )) !== -1
+          ) {
+            if (index !== startIndex) {
+              concat.push(unescapeText(text.substring(index, startIndex)));
+            }
+            exp = text.substring(startIndex + startSymbolLength, endIndex);
+            expressions.push(exp);
+            index = endIndex + endSymbolLength;
+            expressionPositions.push(concat.length);
+            concat.push(""); // Placeholder that will get replaced with the evaluated expression.
+          } else {
+            // we did not find an interpolation, so we have to add the remainder to the separators array
+            if (index !== textLength) {
+              concat.push(unescapeText(text.substring(index)));
+            }
+            break;
+          }
+        }
+
+        singleExpression =
+          concat.length === 1 && expressionPositions.length === 1;
+        // Intercept expression if we need to stringify concatenated inputs, which may be SCE trusted
+        // objects rather than simple strings
+        // (we don't modify the expression if the input consists of only a single trusted input)
+        const interceptor =
+          contextAllowsConcatenation && singleExpression
+            ? undefined
+            : parseStringifyInterceptor;
+        parseFns = expressions.map((exp) => $parse(exp, interceptor));
+
+        // Concatenating expressions makes it hard to reason about whether some combination of
+        // concatenated values are unsafe to use and could easily lead to XSS.  By requiring that a
+        // single expression be used for some $sce-managed secure contexts (RESOURCE_URLs mostly),
+        // we ensure that the value that's used is assigned or constructed by some JS code somewhere
+        // that is more testable or make it obvious that you bound the value to some user controlled
+        // value.  This helps reduce the load when auditing for XSS issues.
+
+        // Note that URL and MEDIA_URL $sce contexts do not need this, since `$sce` can sanitize the values
+        // passed to it. In that case, `$sce.getTrusted` will be called on either the single expression
+        // or on the overall concatenated string (losing trusted types used in the mix, by design).
+        // Both these methods will sanitize plain strings. Also, HTML could be included, but since it's
+        // only used in srcdoc attributes, this would not be very useful.
+
+        if (!mustHaveExpression || expressions.length) {
+          const compute = function (values) {
+            for (let i = 0, ii = expressions.length; i < ii; i++) {
+              if (allOrNothing && isUndefined(values[i])) return;
+              concat[expressionPositions[i]] = values[i];
+            }
+
+            if (contextAllowsConcatenation) {
+              // If `singleExpression` then `concat[0]` might be a "trusted" value or `null`, rather than a string
+              return $sce.getTrusted(
+                trustedContext,
+                singleExpression ? concat[0] : concat.join(""),
+              );
+            }
+            if (trustedContext && concat.length > 1) {
+              // This context does not allow more than one part, e.g. expr + string or exp + exp.
+              $interpolateMinErr.throwNoconcat(text);
+            }
+            // In an unprivileged context or only one part: just concatenate and return.
+            return concat.join("");
+          };
+
+          return extend(
+            (context) => {
+              let i = 0;
+              const ii = expressions.length;
+              const values = new Array(ii);
+
+              try {
+                for (; i < ii; i++) {
+                  values[i] = parseFns[i](context);
+                }
+
+                return compute(values);
+              } catch (err) {
+                $exceptionHandler($interpolateMinErr.interr(text, err));
+              }
+            },
+            {
+              // all of these properties are undocumented for now
+              exp: text, // just for compatibility with regular watchers created via $watch
+              expressions,
+              $$watchDelegate(scope, listener) {
+                let lastValue;
+                return scope.$watchGroup(
+                  parseFns,
+                  function interpolateFnWatcher(values, oldValues) {
+                    const currValue = compute(values);
+                    listener.call(
+                      this,
+                      currValue,
+                      values !== oldValues ? lastValue : currValue,
+                      scope,
+                    );
+                    lastValue = currValue;
+                  },
+                );
+              },
+            },
+          );
+        }
+
+        function parseStringifyInterceptor(value) {
+          try {
+            // In concatenable contexts, getTrusted comes at the end, to avoid sanitizing individual
+            // parts of a full URL. We don't care about losing the trustedness here.
+            // In non-concatenable contexts, where there is only one expression, this interceptor is
+            // not applied to the expression.
+            value =
+              trustedContext && !contextAllowsConcatenation
+                ? $sce.getTrusted(trustedContext, value)
+                : $sce.valueOf(value);
+            return allOrNothing && !isDefined(value) ? value : stringify(value);
+          } catch (err) {
+            $exceptionHandler($interpolateMinErr.interr(text, err));
+          }
+        }
+      }
+
+      /**
+       * @ngdoc method
+       * @name $interpolate#startSymbol
+       * @description
+       * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
+       *
+       * Use {@link ng.$interpolateProvider#startSymbol `$interpolateProvider.startSymbol`} to change
+       * the symbol.
+       *
+       * @returns {string} start symbol.
+       */
+      $interpolate.startSymbol = function () {
+        return startSymbol;
+      };
+
+      /**
+       * @ngdoc method
+       * @name $interpolate#endSymbol
+       * @description
+       * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+       *
+       * Use {@link ng.$interpolateProvider#endSymbol `$interpolateProvider.endSymbol`} to change
+       * the symbol.
+       *
+       * @returns {string} end symbol.
+       */
+      $interpolate.endSymbol = function () {
+        return endSymbol;
+      };
+
+      return $interpolate;
+    },
+  ];
+}

package/src/core/interval.js

@@ -0,0 +1,188 @@
+import { markQExceptionHandled } from "./q";
+import { minErr } from "./utils";
+
+const $intervalMinErr = minErr("$interval");
+
+export function $IntervalProvider() {
+  this.$get = [
+    "$$intervalFactory",
+    function ($$intervalFactory) {
+      const intervals = {};
+      const setIntervalFn = function (tick, delay, deferred) {
+        const id = window.setInterval(tick, delay);
+        intervals[id] = deferred;
+        return id;
+      };
+      const clearIntervalFn = function (id) {
+        window.clearInterval(id);
+        delete intervals[id];
+      };
+
+      /**
+       * @ngdoc service
+       * @name $interval
+       *
+       * @description
+       * AngularJS's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
+       * milliseconds.
+       *
+       * The return value of registering an interval function is a promise. This promise will be
+       * notified upon each tick of the interval, and will be resolved after `count` iterations, or
+       * run indefinitely if `count` is not defined. The value of the notification will be the
+       * number of iterations that have run.
+       * To cancel an interval, call `$interval.cancel(promise)`.
+       *
+       * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to
+       * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
+       * time.
+       *
+       * <div class="alert alert-warning">
+       * **Note**: Intervals created by this service must be explicitly destroyed when you are finished
+       * with them.  In particular they are not automatically destroyed when a controller's scope or a
+       * directive's element are destroyed.
+       * You should take this into consideration and make sure to always cancel the interval at the
+       * appropriate moment.  See the example below for more details on how and when to do this.
+       * </div>
+       *
+       * @param {function()} fn A function that should be called repeatedly. If no additional arguments
+       *   are passed (see below), the function is called with the current iteration count.
+       * @param {number} delay Number of milliseconds between each function call.
+       * @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
+       *   indefinitely.
+       * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
+       *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
+       * @param {...*=} Pass additional parameters to the executed function.
+       * @returns {promise} A promise which will be notified on each iteration. It will resolve once all iterations of the interval complete.
+       *
+       * @example
+       * <example module="intervalExample" name="interval-service">
+       * <file name="index.html">
+       *   <script>
+       *     angular.module('intervalExample', [])
+       *       .controller('ExampleController', ['$scope', '$interval',
+       *         function($scope, $interval) {
+       *           $scope.format = 'M/d/yy h:mm:ss a';
+       *           $scope.blood_1 = 100;
+       *           $scope.blood_2 = 120;
+       *
+       *           let stop;
+       *           $scope.fight = function() {
+       *             // Don't start a new fight if we are already fighting
+       *             if ( angular.isDefined(stop) ) return;
+       *
+       *             stop = $interval(function() {
+       *               if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
+       *                 $scope.blood_1 = $scope.blood_1 - 3;
+       *                 $scope.blood_2 = $scope.blood_2 - 4;
+       *               } else {
+       *                 $scope.stopFight();
+       *               }
+       *             }, 100);
+       *           };
+       *
+       *           $scope.stopFight = function() {
+       *             if (angular.isDefined(stop)) {
+       *               $interval.cancel(stop);
+       *               stop = undefined;
+       *             }
+       *           };
+       *
+       *           $scope.resetFight = function() {
+       *             $scope.blood_1 = 100;
+       *             $scope.blood_2 = 120;
+       *           };
+       *
+       *           $scope.$on('$destroy', function() {
+       *             // Make sure that the interval is destroyed too
+       *             $scope.stopFight();
+       *           });
+       *         }])
+       *       // Register the 'myCurrentTime' directive factory method.
+       *       // We inject $interval and dateFilter service since the factory method is DI.
+       *       .directive('myCurrentTime', ['$interval', 'dateFilter',
+       *         function($interval, dateFilter) {
+       *           // return the directive link function. (compile function not needed)
+       *           return function(scope, element, attrs) {
+       *             let format,  // date format
+       *                 stopTime; // so that we can cancel the time updates
+       *
+       *             // used to update the UI
+       *             function updateTime() {
+       *               element.text(dateFilter(new Date(), format));
+       *             }
+       *
+       *             // watch the expression, and update the UI on change.
+       *             scope.$watch(attrs.myCurrentTime, function(value) {
+       *               format = value;
+       *               updateTime();
+       *             });
+       *
+       *             stopTime = $interval(updateTime, 1000);
+       *
+       *             // listen on DOM destroy (removal) event, and cancel the next UI update
+       *             // to prevent updating time after the DOM element was removed.
+       *             element.on('$destroy', function() {
+       *               $interval.cancel(stopTime);
+       *             });
+       *           }
+       *         }]);
+       *   </script>
+       *
+       *   <div>
+       *     <div ng-controller="ExampleController">
+       *       <label>Date format: <input ng-model="format"></label> <hr/>
+       *       Current time is: <span my-current-time="format"></span>
+       *       <hr/>
+       *       Blood 1 : <font color='red'>{{blood_1}}</font>
+       *       Blood 2 : <font color='red'>{{blood_2}}</font>
+       *       <button type="button" data-ng-click="fight()">Fight</button>
+       *       <button type="button" data-ng-click="stopFight()">StopFight</button>
+       *       <button type="button" data-ng-click="resetFight()">resetFight</button>
+       *     </div>
+       *   </div>
+       *
+       * </file>
+       * </example>
+       */
+      const interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
+
+      /**
+       * @ngdoc method
+       * @name $interval#cancel
+       *
+       * @description
+       * Cancels a task associated with the `promise`.
+       *
+       * @param {Promise=} promise returned by the `$interval` function.
+       * @returns {boolean} Returns `true` if the task was successfully canceled.
+       */
+      interval.cancel = function (promise) {
+        if (!promise) return false;
+
+        if (!Object.prototype.hasOwnProperty.call(promise, "$$intervalId")) {
+          throw $intervalMinErr(
+            "badprom",
+            "`$interval.cancel()` called with a promise that was not generated by `$interval()`.",
+          );
+        }
+
+        if (
+          !Object.prototype.hasOwnProperty.call(intervals, promise.$$intervalId)
+        )
+          return false;
+
+        const id = promise.$$intervalId;
+        const deferred = intervals[id];
+
+        // Interval cancels should not report an unhandled promise.
+        markQExceptionHandled(deferred.promise);
+        deferred.reject("canceled");
+        clearIntervalFn(id);
+
+        return true;
+      };
+
+      return interval;
+    },
+  ];
+}

package/src/core/intervalFactory.js

@@ -0,0 +1,57 @@
+import { isDefined, sliceArgs } from "./utils";
+
+export function $$IntervalFactoryProvider() {
+  this.$get = [
+    "$browser",
+    "$q",
+    "$$q",
+    "$rootScope",
+    function ($browser, $q, $$q, $rootScope) {
+      return function intervalFactory(setIntervalFn, clearIntervalFn) {
+        return function intervalFn(fn, delay, count, invokeApply) {
+          const hasParams = arguments.length > 4;
+          const args = hasParams ? sliceArgs(arguments, 4) : [];
+          let iteration = 0;
+          const skipApply = isDefined(invokeApply) && !invokeApply;
+          const deferred = (skipApply ? $$q : $q).defer();
+          const { promise } = deferred;
+
+          count = isDefined(count) ? count : 0;
+
+          function callback() {
+            if (!hasParams) {
+              fn(iteration);
+            } else {
+              fn.apply(null, args);
+            }
+          }
+
+          function tick() {
+            if (skipApply) {
+              $browser.defer(callback);
+            } else {
+              $rootScope.$evalAsync(callback);
+            }
+            deferred.notify(iteration++);
+
+            if (count > 0 && iteration >= count) {
+              deferred.resolve(iteration);
+              clearIntervalFn(promise.$$intervalId);
+            }
+
+            if (!skipApply) $rootScope.$apply();
+          }
+
+          promise.$$intervalId = setIntervalFn(
+            tick,
+            delay,
+            deferred,
+            skipApply,
+          );
+
+          return promise;
+        };
+      };
+    },
+  ];
+}