@angular-wave/angular.ts 0.3.1 → 0.4.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@angular-wave/angular.ts",
   "description": "A modern, optimized and typesafe version of AngularJS",
   "license": "MIT",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/core/compile/attributes.js

@@ -27,7 +27,7 @@ export class Attributes {
   /**
    * @param {import('../scope/scope').Scope} $rootScope
    * @param {*} $animate
-   * @param {import("../exception-handler").ExceptionHandlerProvider} $exceptionHandler
+   * @param {import("../exception-handler").ErrorHandler} $exceptionHandler
    * @param {*} $sce
    * @param {import('../../shared/jqlite/jqlite').JQLite} [element]
    * @param {*} [attributesToCopy]

package/src/core/compile/compile.js

@@ -526,7 +526,7 @@ export function CompileProvider($provide, $$sanitizeUriProvider) {
     /**
      * @param {import("../../core/di/internal-injector").InjectorService} $injector
      * @param {*} $interpolate
-     * @param {import("../exception-handler").ExceptionHandlerProvider} $exceptionHandler
+     * @param {import("../exception-handler").ErrorHandler} $exceptionHandler
      * @param {*} $templateRequest
      * @param {import("../parser/parse").ParseService} $parse
      * @param {*} $controller

package/src/core/compile/compile.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from "@playwright/test";
 
-const TEST_URL = "src/core/compile/compile.html";
+const TEST_URL = "src/core/compile/compile.html?random=false";
 
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);

package/src/core/exception-handler.js

@@ -31,10 +31,6 @@
  *
  */
 
-/**
- * @typedef {import('../types').ServiceProvider} ExceptionHandlerProvider
- */
-
 /** @type {import('../services/log').LogService} */
 let log;
 
@@ -50,7 +46,7 @@ export const errorHandler = (exception, cause) => {
 
 /**
  * @constructor
- * @this {ExceptionHandlerProvider}
+ * @this {import('../types').ServiceProvider}
  */
 export function ExceptionHandlerProvider() {
   this.$get = [

package/src/core/interval/interval-factory.js

@@ -2,26 +2,20 @@ import { isDefined, sliceArgs } from "../../shared/utils";
 
 export function $IntervalFactoryProvider() {
   this.$get = [
-    "$browser",
     "$q",
-    "$$q",
     "$rootScope",
     /**
-     *
-     * @param {import('../../services/browser').Browser} $browser
      * @param {*} $q
-     * @param {*} $$q
      * @param {import('../scope/scope').Scope} $rootScope
      * @returns
      */
-    function ($browser, $q, $$q, $rootScope) {
+    function ($q, $rootScope) {
       return function intervalFactory(setIntervalFn, clearIntervalFn) {
-        return function intervalFn(fn, delay, count, invokeApply) {
+        return function intervalFn(fn, delay, count) {
           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 deferred = $q.defer();
           const { promise } = deferred;
 
           count = isDefined(count) ? count : 0;
@@ -35,11 +29,7 @@ export function $IntervalFactoryProvider() {
           }
 
           function tick() {
-            if (skipApply) {
-              $browser.defer(callback);
-            } else {
-              $rootScope.$evalAsync(callback);
-            }
+            $rootScope.$evalAsync(callback);
 
             iteration++;
 
@@ -47,16 +37,10 @@ export function $IntervalFactoryProvider() {
               deferred.resolve(iteration);
               clearIntervalFn(promise.$$intervalId);
             }
-
-            if (!skipApply) $rootScope.$apply();
+            $rootScope.$apply();
           }
 
-          promise.$$intervalId = setIntervalFn(
-            tick,
-            delay,
-            deferred,
-            skipApply,
-          );
+          promise.$$intervalId = setIntervalFn(tick, delay, deferred);
 
           return promise;
         };

package/src/core/interval/interval.spec.js

@@ -55,31 +55,6 @@ describe("$interval", () => {
     }, 1);
   });
 
-  it("should NOT call $apply if invokeApply is set to false", (done) => {
-    const applySpy = spyOn($rootScope, "$apply").and.callThrough();
-
-    $interval(() => {}, 1, 0, false);
-    expect(applySpy).not.toHaveBeenCalled();
-
-    setTimeout(() => {
-      expect(applySpy).not.toHaveBeenCalled();
-      done();
-    }, 2);
-  });
-
-  it("should NOT call $evalAsync or $digest if invokeApply is set to false", async () => {
-    const evalAsyncSpy = spyOn($rootScope, "$evalAsync").and.callThrough();
-    const digestSpy = spyOn($rootScope, "$digest").and.callThrough();
-    const notifySpy = jasmine.createSpy("notify");
-
-    $interval(notifySpy, 1, 1, false);
-
-    await wait(100);
-    expect(notifySpy).toHaveBeenCalled();
-    expect(evalAsyncSpy).not.toHaveBeenCalled();
-    expect(digestSpy).not.toHaveBeenCalled();
-  });
-
   it("should allow you to specify a number of iterations", async () => {
     let counter = 0;
     $interval(

package/src/core/q/q.js

@@ -98,33 +98,6 @@ export class $QProvider {
   }
 }
 
-export class $$QProvider {
-  constructor() {
-    this.errorOn = true;
-  }
-
-  $get = [
-    "$exceptionHandler",
-    function ($exceptionHandler) {
-      return qFactory(
-        (callback) => {
-          window.setTimeout(callback);
-        },
-        $exceptionHandler,
-        this.errorOn,
-      );
-    },
-  ];
-
-  errorOnUnhandledRejections(value) {
-    if (isDefined(value)) {
-      this.errorOn = value;
-      return this;
-    }
-    return this.errorOn;
-  }
-}
-
 /**
  * Constructs a promise manager.
  *

package/src/core/q/q.spec.js

@@ -626,50 +626,6 @@ describe("all", function () {
     });
   });
 
-  describe("$qq", function () {
-    let $q, $$q, $rootScope, $injector;
-
-    beforeEach(() => {
-      window.angular = new Angular();
-      $injector = createInjector(["ng"]);
-      $q = $injector.get("$q");
-      $$q = $injector.get("$$q");
-      $rootScope = $injector.get("$rootScope");
-    });
-
-    afterEach(function () {});
-
-    it("uses deferreds that do not resolve at digest", function () {
-      var d = $$q.defer();
-      var fulfilledSpy = jasmine.createSpy();
-      d.promise.then(fulfilledSpy);
-      d.resolve("ok");
-      $rootScope.$apply();
-      expect(fulfilledSpy).not.toHaveBeenCalled();
-    });
-
-    it("uses deferreds that resolve later", (done) => {
-      var d = $$q.defer();
-      d.promise.then((val) => {
-        expect(val).toBe("ok");
-        done();
-      });
-      d.resolve("ok");
-    });
-
-    it("does not invoke digest", (done) => {
-      var d = $$q.defer();
-      var watchSpy = jasmine.createSpy();
-      d.promise.then(() => {
-        watchSpy();
-        done();
-      });
-      d.resolve("ok");
-      $rootScope.$watch(watchSpy);
-      expect(watchSpy).not.toHaveBeenCalled();
-    });
-  });
-
   describe("$Q", () => {
     let resolve;
     let reject;

package/src/core/scope/scope.js

@@ -76,11 +76,6 @@ let $browser;
 /**@type {import('../exception-handler').ErrorHandler} */
 let $exceptionHandler;
 
-/**
- * @type {Scope}
- */
-let rootScope;
-
 /**
  * Provider responsible for instantiating the initial scope, aka - root scope.
  * Every application has a single root {@link ng.$rootScope.Scope scope}.
@@ -94,7 +89,7 @@ let rootScope;
  */
 export class RootScopeProvider {
   constructor() {
-    rootScope = new Scope();
+    this.rootScope = new Scope(true);
   }
 
   $get = [
@@ -111,7 +106,7 @@ export class RootScopeProvider {
       $exceptionHandler = exceptionHandler;
       $parse = parse;
       $browser = browser;
-      return rootScope;
+      return this.rootScope;
     },
   ];
 }
@@ -142,7 +137,15 @@ export class RootScopeProvider {
  */
 
 export class Scope {
-  constructor() {
+  /**
+   * @param {boolean} [root=false] - Indicates if this scope is the root scope.
+   */
+  constructor(root = false) {
+    /**
+     * @type {boolean}
+     */
+    this.isRoot = root;
+
     /**
      * @type {number} Unique scope ID (monotonically increasing) useful for debugging.
      */
@@ -194,13 +197,12 @@ export class Scope {
     /** @type {boolean} */
     this.$$destroyed = false;
 
-    // TODO use maps
     /** @type {boolean} */
     this.$$suspended = false;
 
     // TODO use maps
-    /** @type {object} */
-    this.$$listeners = {};
+    /** @type {Map<String, Function[]>} */
+    this.$$listeners = new Map();
 
     /** @type {object} */
     this.$$listenerCount = {};
@@ -240,19 +242,18 @@ export class Scope {
    *
    */
   $new(isolate, parent) {
-    /** @type {Scope} */
-    let child;
+    let child = isolate ? new Scope() : Object.create(this);
+
     if (isolate) {
-      child = new Scope();
-      child.$root = rootScope;
+      child.$root = this.isRoot ? this : this.$root;
     } else {
-      child = Object.create(this);
+      // Initialize properties for a non-isolated child scope
       child.$id = nextUid();
       child.$$watchers = [];
       child.$$nextSibling = null;
       child.$$childHead = null;
       child.$$childTail = null;
-      child.$$listeners = {};
+      child.$$listeners = new Map();
       child.$$listenerCount = {};
       child.$$watchersCount = 0;
       child.$$ChildScope = null;
@@ -261,6 +262,7 @@ export class Scope {
 
     child.$parent = parent || this;
     child.$$prevSibling = child.$parent.$$childTail;
+
     if (child.$parent.$$childHead) {
       child.$parent.$$childTail.$$nextSibling = child;
       child.$parent.$$childTail = child;
@@ -269,20 +271,13 @@ export class Scope {
       child.$parent.$$childTail = child;
     }
 
-    // When the new scope is not isolated or we inherit from `this`, and
-    // the parent scope is destroyed, the property `$$destroyed` is inherited
-    // prototypically. In all other cases, this property needs to be set
-    // when the parent scope is destroyed.
-    // The listener needs to be added after the parent is set
+    // Add a destroy listener if isolated or the parent differs from `this`
     if (isolate || parent !== this) {
-      child.$on(
-        "$destroy",
-        /** @param {any} $event */ //angular.IAngularEvent
-        ($event) => {
-          $event.currentScope.$$destroyed = true;
-        },
-      );
+      child.$on("$destroy", ($event) => {
+        $event.currentScope.$$destroyed = true;
+      });
     }
+
     return child;
   }
 
@@ -732,7 +727,6 @@ export class Scope {
  *
  */
   $digest() {
-    let watch;
     let value;
     let last;
     let fn;
@@ -741,10 +735,9 @@ export class Scope {
     let dirty;
     let ttl = TTL;
     let next;
-    /**
-     * @type {Scope}
-     */
+    /** @type {Scope} */
     let current;
+    /** @type {Scope} */
     const target = $$asyncQueue.length ? this.$root : this;
     const watchLog = [];
     let logIdx;
@@ -755,7 +748,7 @@ export class Scope {
     // TODO Implement browser
     $browser.$$checkUrlChange();
 
-    if (this === this.$root && applyAsyncId !== null) {
+    if (this.isRoot && 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.cancel(applyAsyncId);
@@ -795,7 +788,7 @@ export class Scope {
           current.$$digestWatchIndex = watchers.length;
           while (current.$$digestWatchIndex--) {
             try {
-              watch = watchers[current.$$digestWatchIndex];
+              const 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) {
@@ -1038,7 +1031,7 @@ export class Scope {
         function () {
           return () => {};
         };
-    this.$$listeners = {};
+    this.$$listeners.clear();
 
     // Disconnect the next sibling to prevent `cleanUpScope` destroying those too
     this.$$nextSibling = null;
@@ -1251,9 +1244,10 @@ export class Scope {
    * @returns {function()} Returns a deregistration function for this listener.
    */
   $on(name, listener) {
-    let namedListeners = this.$$listeners[name];
+    let namedListeners = this.$$listeners.get(name);
     if (!namedListeners) {
-      this.$$listeners[name] = namedListeners = [];
+      namedListeners = [];
+      this.$$listeners.set(name, namedListeners);
     }
     namedListeners.push(listener);
 
@@ -1342,7 +1336,7 @@ export class Scope {
     let length;
 
     do {
-      namedListeners = scope.$$listeners[name] || empty;
+      namedListeners = scope.$$listeners.get(name) || empty;
       event.currentScope = scope;
       for (i = 0, length = namedListeners.length; i < length; i++) {
         // if listeners were deregistered, defragment the array
@@ -1414,7 +1408,7 @@ export class Scope {
     // down while you can, then up and next sibling or up and next sibling until back at root
     while ((current = next)) {
       event.currentScope = current;
-      listeners = current.$$listeners[name] || [];
+      listeners = current.$$listeners.get(name) || [];
       for (i = 0, length = listeners.length; i < length; i++) {
         // if listeners were deregistered, defragment the array
         if (!listeners[i]) {

package/src/core/scope/scope.spec.js

@@ -1,4 +1,4 @@
-import { $$asyncQueue } from "./scope";
+import { $$asyncQueue, Scope } from "./scope";
 import { extend, sliceArgs } from "../../shared/utils";
 import { Angular } from "../../loader";
 import { createInjector } from "../di/injector";
@@ -8,6 +8,7 @@ describe("Scope", function () {
   let $parse;
   let $browser;
   let logs;
+  let scope;
 
   beforeEach(() => {
     logs = [];
@@ -27,6 +28,21 @@ describe("Scope", function () {
     $browser = injector.get("$browser");
 
     $rootScope = injector.get("$rootScope");
+    scope = $rootScope;
+  });
+
+  describe("class", () => {
+    it("can be constructed as a class", () => {
+      const scope = new Scope();
+      expect(scope).toBeDefined();
+      expect(scope.isRoot).toBeFalse();
+    });
+
+    it("can be constructed as a root scope", () => {
+      const scope = new Scope(true);
+      expect(scope).toBeDefined();
+      expect(scope.isRoot).toBeTrue();
+    });
   });
 
   describe("inheritance", () => {
@@ -49,7 +65,7 @@ describe("Scope", function () {
       const child = $rootScope.$new();
       child.aValue = [1, 2, 3];
 
-      expect(parent.aValue).toBeUndefined();
+      expect($rootScope.aValue).toBeUndefined();
     });
 
     it("inherits the parents properties whenever they are defined", () => {
@@ -91,6 +107,7 @@ describe("Scope", function () {
 
       expect(child.aValue).toEqual([1, 2, 3, 4]);
       expect($rootScope.aValue).toEqual([1, 2, 3, 4]);
+      expect(child.aValue).toEqual($rootScope.aValue);
     });
   });
 
@@ -122,6 +139,7 @@ describe("Scope", function () {
       $rootScope.a = 123;
       expect(isolated.a).toBeUndefined();
       expect(trans.a).toEqual(123);
+      expect(trans.$root).toBe($rootScope);
       expect(trans.$parent).toBe(isolated);
     });
   });
@@ -171,13 +189,53 @@ describe("Scope", function () {
       expect($rootScope.$eval("this")).toEqual($rootScope);
     });
 
-    it("should be able to access a constiable named 'this'", () => {
+    it("should be able to access a constant variable named 'this'", () => {
       $rootScope.this = 42;
       expect($rootScope.$eval("this['this']")).toBe(42);
     });
   });
 
   describe("$watch/$digest", () => {
+    it("calls the listener function of a watch on first $digest", function () {
+      var watchFn = function () {
+        return "wat";
+      };
+      var listenerFn = jasmine.createSpy();
+      $rootScope.$watch(watchFn, listenerFn);
+      $rootScope.$digest();
+      expect(listenerFn).toHaveBeenCalled();
+    });
+
+    it("calls the watch function with the scope as the argument", function () {
+      var watchFn = jasmine.createSpy();
+      var listenerFn = function () {};
+      $rootScope.$watch(watchFn, listenerFn);
+      $rootScope.$digest();
+      expect(watchFn).toHaveBeenCalledWith($rootScope);
+    });
+
+    it("calls the listener function when the watched value changes", function () {
+      scope.someValue = "a";
+      scope.counter = 0;
+      scope.$watch(
+        function (scope) {
+          return scope.someValue;
+        },
+        function (newValue, oldValue, scope) {
+          scope.counter++;
+        },
+      );
+      expect(scope.counter).toBe(0);
+      scope.$digest();
+      expect(scope.counter).toBe(1);
+      scope.$digest();
+      expect(scope.counter).toBe(1);
+      scope.someValue = "b";
+      expect(scope.counter).toBe(1);
+      scope.$digest();
+      expect(scope.counter).toBe(2);
+    });
+
     it("should watch and fire on simple property change", () => {
       const spy = jasmine.createSpy();
       $rootScope.$watch("name", spy);
@@ -2870,13 +2928,13 @@ describe("Scope", function () {
           const remove1 = $rootScope.$on("abc", () => {});
           $rootScope.$on("abc", () => {});
 
-          expect($rootScope.$$listeners.abc.length).toBe(2);
-          expect(0 in $rootScope.$$listeners.abc).toBe(true);
+          expect($rootScope.$$listeners.get("abc").length).toBe(2);
+          expect(0 in $rootScope.$$listeners.get("abc")).toBe(true);
 
           remove1();
 
-          expect($rootScope.$$listeners.abc.length).toBe(2);
-          expect(0 in $rootScope.$$listeners.abc).toBe(false);
+          expect($rootScope.$$listeners.get("abc").length).toBe(2);
+          expect(0 in $rootScope.$$listeners.get("abc")).toBe(false);
         });
 
         it("should call next listener after removing the current listener via its own handler", () => {
@@ -3097,14 +3155,14 @@ describe("Scope", function () {
 
         spy1.and.callFake(remove1);
 
-        expect(child.$$listeners.evt.length).toBe(3);
+        expect(child.$$listeners.get("evt").length).toBe(3);
 
         // should call all listeners and remove 1st
         child.$emit("evt");
         expect(spy1).toHaveBeenCalled();
         expect(spy2).toHaveBeenCalled();
         expect(spy3).toHaveBeenCalled();
-        expect(child.$$listeners.evt.length).toBe(3); // cleanup will happen on next $emit
+        expect(child.$$listeners.get("evt").length).toBe(3); // cleanup will happen on next $emit
 
         spy1.calls.reset();
         spy2.calls.reset();
@@ -3116,7 +3174,7 @@ describe("Scope", function () {
         expect(spy1).not.toHaveBeenCalled();
         expect(spy2).toHaveBeenCalled();
         expect(spy3).not.toHaveBeenCalled();
-        expect(child.$$listeners.evt.length).toBe(1);
+        expect(child.$$listeners.get("evt").length).toBe(1);
       });
 
       it("should allow removing event listener inside a listener on $broadcast", () => {
@@ -3130,14 +3188,14 @@ describe("Scope", function () {
 
         spy1.and.callFake(remove1);
 
-        expect(child.$$listeners.evt.length).toBe(3);
+        expect(child.$$listeners.get("evt").length).toBe(3);
 
         // should call all listeners and remove 1st
         child.$broadcast("evt");
         expect(spy1).toHaveBeenCalled();
         expect(spy2).toHaveBeenCalled();
         expect(spy3).toHaveBeenCalled();
-        expect(child.$$listeners.evt.length).toBe(3); // cleanup will happen on next $broadcast
+        expect(child.$$listeners.get("evt").length).toBe(3); // cleanup will happen on next $broadcast
 
         spy1.calls.reset();
         spy2.calls.reset();
@@ -3149,7 +3207,7 @@ describe("Scope", function () {
         expect(spy1).not.toHaveBeenCalled();
         expect(spy2).toHaveBeenCalled();
         expect(spy3).not.toHaveBeenCalled();
-        expect(child.$$listeners.evt.length).toBe(1);
+        expect(child.$$listeners.get("evt").length).toBe(1);
       });
 
       describe("event object", () => {

package/src/core/timeout/timeout.js

@@ -8,18 +8,16 @@ export class TimeoutProvider {
     "$rootScope",
     "$browser",
     "$q",
-    "$$q",
     "$exceptionHandler",
     /**
      *
      * @param {import('../scope/scope').Scope} $rootScope
      * @param {import('../../services/browser').Browser} $browser
      * @param {*} $q
-     * @param {*} $$q
      * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
      * @returns
      */
-    ($rootScope, $browser, $q, $$q, $exceptionHandler) => {
+    ($rootScope, $browser, $q, $exceptionHandler) => {
       const deferreds = {};
 
       /**
@@ -38,8 +36,6 @@ export class TimeoutProvider {
        *
        * @param {function()=} fn A function, whose execution should be delayed.
        * @param {number=} [delay=0] Delay in milliseconds.
-       * @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.
        * @returns {import("../q/q").QPromise<any>} Promise that will be resolved when the timeout is reached. The promise
        *   will be resolved with the return value of the `fn` function.
        *
@@ -47,7 +43,7 @@ export class TimeoutProvider {
       function timeout(fn, delay, invokeApply = true) {
         const args = sliceArgs(arguments, 3);
         const skipApply = isDefined(invokeApply) && !invokeApply;
-        const deferred = (skipApply ? $$q : $q).defer();
+        const deferred = $q.defer();
         const { promise } = deferred;
         let timeoutId;
 

package/src/directive/attrs/attrs.js

@@ -11,7 +11,7 @@ Object.entries(BOOLEAN_ATTR).forEach(([attrName, propName]) => {
   // binding to multiple is not supported
   if (propName === "multiple") return;
 
-  function defaultLinkFn(scope, element, attr) {
+  function defaultLinkFn(scope, _element, attr) {
     scope.$watch(attr[normalized], (value) => {
       attr.$set(attrName, !!value);
     });

package/src/directive/input/input.spec.js

@@ -1,5 +1,4 @@
 import { Angular } from "../../loader";
-import { createInjector } from "../../core/di/injector";
 import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
 import { EMAIL_REGEXP, ISO_DATE_REGEXP, URL_REGEXP } from "./input";
 import { forEach } from "../../shared/utils";