@angular-wave/angular.ts 0.0.34 → 0.0.35

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/core/root-scope.js

@@ -21,6 +21,13 @@ export const ScopePhase = {
   DIGEST: 2,
 };
 
+/**
+ * @typedef {Object} AsyncQueueTask
+ * @property {Scope} scope
+ * @property {Function} fn
+ * @property {Object} locals
+ */
+
 /**
  *
  * The default number of `$digest` iterations the scope should attempt to execute before giving up and
@@ -34,6 +41,8 @@ export const ScopePhase = {
 export const TTL = 10;
 
 const $rootScopeMinErr = minErr("$rootScope");
+
+/** @type {AsyncQueueTask[]} */
 const $$asyncQueue = [];
 const $$postDigestQueue = [];
 const $$applyAsyncQueue = [];
@@ -122,9 +131,9 @@ export function getQueues() {
   };
 }
 
-/**
- * @type {angular.IScope}
- */
+// /**
+//  * @type {angular.Scope}
+//  */
 class Scope {
   constructor() {
     /**
@@ -136,35 +145,68 @@ class Scope {
     this.$$phase = ScopePhase.NONE;
 
     /**
-     * @type {?angular.IScope} Reference to the parent scope.
+     * @type {?Scope} Reference to the parent scope.
      */
     this.$parent = null;
 
     /**
-     * @type {?angular.IScope}
+     * @type {?Scope}
      */
     this.$root = this;
 
-    this.$$watchers = null;
+    /** @type {Array} */
+    this.$$watchers = [];
+
+    /**
+     * @type {number}
+     */
+    this.$$digestWatchIndex = -1;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$nextSibling = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$prevSibling = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$childHead = null;
+
+    /**
+     * @type {?Scope}
+     */
     this.$$childTail = null;
+
+    /** @type {boolean} */
     this.$$destroyed = false;
+
+    // TODO use maps
+    /** @type {boolean} */
     this.$$suspended = false;
+
+    // TODO use maps
+    /** @type {object} */
     this.$$listeners = {};
+
+    /** @type {object} */
     this.$$listenerCount = {};
+
+    /** @type {number} */
     this.$$watchersCount = 0;
     this.$$isolateBindings = null;
 
     /**
-     * @type {Scope}
+     * @type {?Scope}
      */
     this.$$ChildScope = null;
   }
 
   /**
-   * @description
    * Creates a new child {@link Scope}.
    *
    * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} event.
@@ -179,24 +221,25 @@ class Scope {
    *         When creating widgets, it is useful for the widget to not accidentally read parent
    *         state.
    *
-   * @param {?angular.IScope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+   * @param {?Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
    *                              of the newly created scope. Defaults to `this` scope if not provided.
    *                              This is used when creating a transclude scope to correctly place it
    *                              in the scope hierarchy while maintaining the correct prototypical
    *                              inheritance.
    *
-   * @returns {angular.IScope} The newly created child scope.
+   * @returns {Scope} The newly created child scope.
    *
    */
   $new(isolate, parent) {
+    /** @type {Scope} */
     let child;
     if (isolate) {
       child = new Scope();
-      child.$root = this.$root;
+      child.$root = rootScope;
     } else {
       child = Object.create(this);
       child.$id = nextUid();
-      child.$$watchers = null;
+      child.$$watchers = [];
       child.$$nextSibling = null;
       child.$$childHead = null;
       child.$$childTail = null;
@@ -206,6 +249,7 @@ class Scope {
       child.$$ChildScope = null;
       child.$$suspended = false;
     }
+
     child.$parent = parent || this;
     child.$$prevSibling = child.$parent.$$childTail;
     if (child.$parent.$$childHead) {
@@ -222,9 +266,13 @@ class Scope {
     // when the parent scope is destroyed.
     // The listener needs to be added after the parent is set
     if (isolate || parent !== this) {
-      child.$on("$destroy", ($event) => {
-        $event.currentScope.$$destroyed = true;
-      });
+      child.$on(
+        "$destroy",
+        /** @param {angular.IAngularEvent} $event */
+        ($event) => {
+          $event.currentScope.$$destroyed = true;
+        },
+      );
     }
     return child;
   }
@@ -352,8 +400,7 @@ class Scope {
     if (get.$$watchDelegate) {
       return get.$$watchDelegate(this, fn, objectEquality, get, watchExp);
     }
-    const scope = this;
-    let array = scope.$$watchers;
+
     const watcher = {
       fn,
       last: initWatchVal,
@@ -364,23 +411,21 @@ class Scope {
 
     lastDirtyWatch = null;
 
-    if (!array) {
-      array = scope.$$watchers = [];
-      array.$$digestWatchIndex = -1;
+    if (this.$$watchers.length == 0) {
+      this.$$digestWatchIndex = -1;
     }
     // we use unshift since we use a while loop in $digest for speed.
     // the while loop reads in reverse order.
-    array.unshift(watcher);
-    array.$$digestWatchIndex++;
+    this.$$watchers.unshift(watcher);
+    this.$$digestWatchIndex++;
     this.incrementWatchersCount(1);
-    const self = this;
 
-    return function deregisterWatch() {
-      const index = arrayRemove(array, watcher);
+    return () => {
+      const index = arrayRemove(this.$$watchers, watcher);
       if (index >= 0) {
-        self.incrementWatchersCount(-1);
-        if (index < array.$$digestWatchIndex) {
-          array.$$digestWatchIndex--;
+        this.incrementWatchersCount(-1);
+        if (index < this.$$digestWatchIndex) {
+          this.$$digestWatchIndex--;
         }
       }
       lastDirtyWatch = null;
@@ -715,7 +760,7 @@ class Scope {
     let ttl = TTL;
     let next;
     /**
-     * @type {angular.IScope}
+     * @type {Scope}
      */
     let current;
     const target = $$asyncQueue.length ? this.$root : this;
@@ -731,7 +776,7 @@ class Scope {
     if (this === this.$root && applyAsyncId !== null) {
       // If this is the root scope, and $applyAsync has scheduled a deferred $apply(), then
       // cancel the scheduled $apply and flush the queue of expressions to be evaluated.
-      $browser.defer.cancel(applyAsyncId);
+      $browser.cancel(applyAsyncId);
       flushApplyAsync();
       applyAsyncId = null;
     }
@@ -765,10 +810,10 @@ class Scope {
         // "traverse the scopes" loop
         if ((watchers = !current.$$suspended && current.$$watchers)) {
           // process our watches
-          watchers.$$digestWatchIndex = watchers.length;
-          while (watchers.$$digestWatchIndex--) {
+          current.$$digestWatchIndex = watchers.length;
+          while (current.$$digestWatchIndex--) {
             try {
-              watch = watchers[watchers.$$digestWatchIndex];
+              watch = watchers[current.$$digestWatchIndex];
               // Most common watches are on primitives, in which case we can short
               // circuit it with === operator, only when === fails do we use .equals
               if (watch) {
@@ -1072,7 +1117,7 @@ class Scope {
      expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
  * ```
  *
- * @param {(string|function())=} expr An AngularJS expression to be executed.
+ * @param {string|function(Scope): any} [expr] An AngularJS expression to be executed.
  *
  *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
  *    - `function(scope)`: execute the function with the current `scope` parameter.
@@ -1180,7 +1225,7 @@ class Scope {
  *    expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
  *
  *
- * @param {(string|function())=} expr An AngularJS expression to be executed.
+ * @param {string|function(Scope): any} [expr] An AngularJS expression to be executed.
  *
  *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
  *    - `function(scope)`: execute the function with current `scope` parameter.
@@ -1261,7 +1306,7 @@ class Scope {
    *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
    *
    * @param {string} name Event name to listen on.
-   * @param {function(event, ...args)} listener Function to call when the event is emitted.
+   * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
    * @returns {function()} Returns a deregistration function for this listener.
    */
   $on(name, listener) {

package/src/core/timeout.js

@@ -103,7 +103,7 @@ export function $timeout($rootScope, $browser, $q, $$q, $exceptionHandler) {
     deferred.reject("canceled");
     delete deferreds[id];
 
-    return $browser.defer.cancel(id);
+    return $browser.cancel(id);
   };
 
   return timeout;

package/src/directive/input.js

@@ -727,7 +727,7 @@ function baseInputType(scope, element, attr, ctrl, $browser) {
 
   let listener = function (ev) {
     if (timeout) {
-      $browser.defer.cancel(timeout);
+      $browser.cancel(timeout);
       timeout = null;
     }
     if (composing) return;

package/src/router/services.js

@@ -6,7 +6,6 @@
  *
  * The optional [[$resolve]] service is also documented here.
  *
- * @preferred @publicapi @module ng1
  */
 import { services } from "./common/coreservices";
 import { unnestR } from "../shared/common";

package/src/services/browser.js

@@ -243,7 +243,7 @@ export function Browser($log, $$taskTrackerFactory) {
    * @param {function()} fn A function, who's execution should be deferred.
    * @param {number=} [delay=0] Number of milliseconds to defer the function execution.
    * @param {string=} [taskType=DEFAULT_TASK_TYPE] The type of task that is deferred.
-   * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
+   * @returns {*} DeferId that can be used to cancel the task via `$browser.cancel()`.
    *
    * @description
    * Executes a fn asynchronously via `setTimeout(fn, delay)`.
@@ -270,7 +270,7 @@ export function Browser($log, $$taskTrackerFactory) {
   };
 
   /**
-   * @name $browser#defer.cancel
+   * @name $browser#cancel
    *
    * @description
    * Cancels a deferred task identified with `deferId`.
@@ -279,7 +279,7 @@ export function Browser($log, $$taskTrackerFactory) {
    * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
    *                    canceled.
    */
-  self.defer.cancel = function (deferId) {
+  self.cancel = function (deferId) {
     if (Object.prototype.hasOwnProperty.call(pendingDeferIds, deferId)) {
       const taskType = pendingDeferIds[deferId];
       delete pendingDeferIds[deferId];

package/test/core/parse.spec.js

@@ -3486,6 +3486,19 @@ describe("parser", () => {
   });
 
   describe("with primitive input", () => {
+    beforeEach(() => {
+      createInjector([
+        "ng",
+        function ($filterProvider) {
+          filterProvider = $filterProvider;
+        },
+      ]).invoke((_$rootScope_, _$parse_) => {
+        scope = _$rootScope_;
+        $parse = _$parse_;
+      });
+      logs = [];
+    });
+
     it("should not be reevaluated when passed literals", () => {
       let filterCalls = 0;
       filterProvider.register(

package/test/core/scope.spec.js

@@ -2630,7 +2630,7 @@ describe("Scope", function () {
       const scope = $rootScope.$new();
       let id = scope.$applyAsync('x = "CODE ORANGE"');
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       setTimeout(() => {
         expect(scope.x).toBe("CODE ORANGE");
         expect($rootScope.x).toBeUndefined();
@@ -2644,8 +2644,8 @@ describe("Scope", function () {
       let id1 = $rootScope.$applyAsync('x.push("expr1")');
       let id2 = $rootScope.$applyAsync('x.push("expr2")');
 
-      $browser.defer.cancel(id1);
-      $browser.defer.cancel(id2);
+      $browser.cancel(id1);
+      $browser.cancel(id2);
       setTimeout(() => {
         expect($rootScope.x).toEqual(["expr1", "expr2"]);
       });
@@ -2660,7 +2660,7 @@ describe("Scope", function () {
         expect($browser.deferredFns.length).toBe(0);
       });
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       setTimeout(() => {
         expect($rootScope.x).toEqual(["expr1", "expr2"]);
       });
@@ -2672,7 +2672,7 @@ describe("Scope", function () {
         throw "OOPS";
       });
 
-      $browser.defer.cancel(id);
+      $browser.cancel(id);
       expect(logs).toEqual([]);
       setTimeout(() => expect(logs[0]).toEqual("OOPS"));
     });
@@ -2683,14 +2683,14 @@ describe("Scope", function () {
       });
       let id2 = $rootScope.$applyAsync('x = "All good!"');
 
-      $browser.defer.cancel(id);
-      $browser.defer.cancel(id2);
+      $browser.cancel(id);
+      $browser.cancel(id2);
       setTimeout(() => expect($rootScope.x).toBe("All good!"));
       expect($rootScope.x).toBeUndefined();
     });
 
     it("should be cancelled if a $rootScope digest occurs before the next tick", () => {
-      const cancel = spyOn($browser.defer, "cancel").and.callThrough();
+      const cancel = spyOn($browser, "cancel").and.callThrough();
       const expression = jasmine.createSpy("expr");
 
       $rootScope.$applyAsync(expression);

package/test/core/timeout.spec.js

@@ -325,7 +325,7 @@ describe("$timeout", () => {
     });
 
     it("should forget references to relevant deferred", () => {
-      // $browser.defer.cancel is only called on cancel if the deferred object is still referenced
+      // $browser.cancel is only called on cancel if the deferred object is still referenced
       const cancelSpy = spyOn($browser.defer, "cancel").and.callThrough();
 
       const promise = $timeout(() => {}, 0, false);

package/types/index.d.ts

@@ -16,6 +16,7 @@ export as namespace ng;
 export = angular;
 
 import ng = angular;
+import { Obj } from "./router";
 
 ///////////////////////////////////////////////////////////////////////////////
 // ng module (angular.js)
@@ -104,7 +105,7 @@ declare namespace angular {
      * @param directiveFactory An injectable directive factory function.
      */
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -115,7 +116,7 @@ declare namespace angular {
       >,
     ): IModule;
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -380,14 +381,34 @@ declare namespace angular {
    * $rootScope - $rootScopeProvider - service in module ng
    * see https://docs.angularjs.org/api/ng/type/$rootScope.Scope and https://docs.angularjs.org/api/ng/service/$rootScope
    */
-  interface IScope {
+  class Scope {
+    $id: number;
+    $parent: Scope | null;
+    $root: Scope | null;
+    $$destroyed: boolean;
+    $$isolateBindings: any;
+    $$phase: any;
+
+    private $$watches: Array<any>;
+    private $$nextSibling: Scope | null;
+    private $$prevSibling: Scope | null;
+    private $$childHead: Scope | null;
+    private $$childTail: Scope | null;
+    private $$ChildScope: Scope | null;
+    private $$watchersCount: number;
+    private $$digestWatchIndex: number;
+    private $$suspended: boolean;
+
+    private $$listeners: Object;
+    private $$listenerCount: Object;
+
     $apply(): any;
-    $apply(exp: string): any;
-    $apply(exp: (scope: IScope) => any): any;
+    $apply(expr: string): any;
+    $apply(expr: (scope: Scope) => any): any;
 
     $applyAsync(): any;
     $applyAsync(exp: string): any;
-    $applyAsync(exp: (scope: IScope) => any): any;
+    $applyAsync(exp: (scope: Scope) => any): any;
 
     /**
      * Dispatches an event name downwards to all child scopes (and their children) notifying the registered $rootScope.Scope listeners.
@@ -486,14 +507,14 @@ declare namespace angular {
 
     $eval(): any;
     $eval(expression: string, locals?: Object): any;
-    $eval(expression: (scope: IScope) => any, locals?: Object): any;
+    $eval(expression: (scope: Scope) => any, locals?: Object): any;
 
     $evalAsync(): void;
     $evalAsync(expression: string, locals?: Object): void;
-    $evalAsync(expression: (scope: IScope) => void, locals?: Object): void;
+    $evalAsync(expression: (scope: Scope) => void, locals?: Object): void;
 
     // Defaults to false by the implementation checking strategy
-    $new(isolate?: boolean, parent?: IScope): IScope;
+    $new(isolate?: boolean, parent?: Scope): Scope;
 
     /**
      * Listens on events of a given type. See $emit for discussion of event life cycle.
@@ -515,55 +536,46 @@ declare namespace angular {
     ): () => void;
     $watch<T>(
       watchExpression: string,
-      listener?: (newValue: T, oldValue: T, scope: IScope) => any,
+      listener?: (newValue: T, oldValue: T, scope: Scope) => any,
       objectEquality?: boolean,
     ): () => void;
     $watch(
-      watchExpression: (scope: IScope) => any,
+      watchExpression: (scope: Scope) => any,
       listener?: string,
       objectEquality?: boolean,
     ): () => void;
     $watch<T>(
-      watchExpression: (scope: IScope) => T,
-      listener?: (newValue: T, oldValue: T, scope: IScope) => any,
+      watchExpression: (scope: Scope) => T,
+      listener?: (newValue: T, oldValue: T, scope: Scope) => any,
       objectEquality?: boolean,
     ): () => void;
 
     $watchCollection<T>(
       watchExpression: string,
-      listener: (newValue: T, oldValue: T, scope: IScope) => any,
+      listener: (newValue: T, oldValue: T, scope: Scope) => any,
     ): () => void;
     $watchCollection<T>(
-      watchExpression: (scope: IScope) => T,
-      listener: (newValue: T, oldValue: T, scope: IScope) => any,
+      watchExpression: (scope: Scope) => T,
+      listener: (newValue: T, oldValue: T, scope: Scope) => any,
     ): () => void;
 
     $watchGroup(
       watchExpressions: any[],
-      listener: (newValue: any, oldValue: any, scope: IScope) => any,
+      listener: (newValue: any, oldValue: any, scope: Scope) => any,
     ): () => void;
     $watchGroup(
-      watchExpressions: Array<{ (scope: IScope): any }>,
-      listener: (newValue: any, oldValue: any, scope: IScope) => any,
+      watchExpressions: Array<{ (scope: Scope): any }>,
+      listener: (newValue: any, oldValue: any, scope: Scope) => any,
     ): () => void;
-
-    $parent: IScope;
-    $root: IScope;
-    $id: number;
-
-    // Hidden members
-    $$isolateBindings: any;
-    $$phase: any;
-    $$destroyed: boolean;
   }
 
-  interface IRootScopeService extends IScope {}
+  interface IRootScopeService extends Scope {}
 
   /**
    * $scope for ngRepeat directive.
    * see https://docs.angularjs.org/api/ng/directive/ngRepeat
    */
-  interface IRepeatScope extends IScope {
+  interface IRepeatScope extends Scope {
     /**
      * iterator offset of the repeated element (0..length-1).
      */
@@ -599,11 +611,11 @@ declare namespace angular {
     /**
      * the scope on which the event was $emit-ed or $broadcast-ed.
      */
-    targetScope: IScope;
+    targetScope: Scope;
     /**
      * the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null.
      */
-    currentScope: IScope;
+    currentScope: Scope;
     /**
      * name of the event.
      */
@@ -913,8 +925,8 @@ declare namespace angular {
   ///////////////////////////////////////////////////////////////////////////
   interface IParseService {
     (
-      expression: string,
-      interceptorFn?: (value: any, scope: IScope, locals: any) => any,
+      expression: string | ((scope: Scope) => any),
+      interceptorFn?: (value: any, scope: Scope, locals: any) => any,
       expensiveChecks?: boolean,
     ): ICompiledExpression;
   }
@@ -1457,7 +1469,7 @@ declare namespace angular {
 
   interface ICompileProvider extends IServiceProvider {
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -1468,7 +1480,7 @@ declare namespace angular {
       >,
     ): ICompileProvider;
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -1543,13 +1555,13 @@ declare namespace angular {
 
   interface ICloneAttachFunction {
     // Let's hint but not force cloneAttachFn's signature
-    (clonedElement?: JQLite, scope?: IScope): any;
+    (clonedElement?: JQLite, scope?: Scope): any;
   }
 
   // This corresponds to the "publicLinkFn" returned by $compile.
   interface ITemplateLinkingFunction {
     (
-      scope: IScope,
+      scope: Scope,
       cloneAttachFn?: ICloneAttachFunction,
       options?: ITemplateLinkingFunctionOptions,
     ): JQLite;
@@ -1573,7 +1585,7 @@ declare namespace angular {
   interface ITranscludeFunction {
     // If the scope is provided, then the cloneAttachFn must be as well.
     (
-      scope: IScope,
+      scope: Scope,
       cloneAttachFn: ICloneAttachFunction,
       futureParentElement?: JQLite,
       slotName?: string,
@@ -1601,7 +1613,7 @@ declare namespace angular {
    * The minimal local definitions required by $controller(ctrl, locals) calls.
    */
   interface IControllerLocals {
-    $scope: ng.IScope;
+    $scope: ng.Scope;
     $element: JQLite;
   }
 
@@ -2268,7 +2280,7 @@ declare namespace angular {
     | { [key: string]: IController };
 
   interface IDirectiveFactory<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2281,7 +2293,7 @@ declare namespace angular {
   }
 
   interface IDirectiveLinkFn<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2296,7 +2308,7 @@ declare namespace angular {
   }
 
   interface IDirectivePrePost<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2310,7 +2322,7 @@ declare namespace angular {
   }
 
   interface IDirectiveCompileFn<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2332,7 +2344,7 @@ declare namespace angular {
   }
 
   interface IDirective<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,