@angular-wave/angular.ts 0.3.1 → 0.4.1

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.1",
   "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/interpolate/interpolate.js

@@ -40,9 +40,13 @@ function interr(text, err) {
  * security bugs!
  * </div>
  */
-export function InterpolateProvider() {
-  let startSymbol = "{{";
-  let endSymbol = "}}";
+export class InterpolateProvider {
+  constructor() {
+    /** @type {string} */
+    this.start = "{{";
+    /** @type {string} */
+    this.end = "}}";
+  }
 
   /**
    * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
@@ -50,13 +54,13 @@ export function InterpolateProvider() {
    * @param {string=} value new value to set the starting symbol to.
    * @returns {string|InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
    */
-  this.startSymbol = function (value) {
+  startSymbol(value) {
     if (value) {
-      startSymbol = value;
+      this.start = value;
       return this;
     }
-    return startSymbol;
-  };
+    return this.start;
+  }
 
   /**
    * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
@@ -64,33 +68,36 @@ export function InterpolateProvider() {
    * @param {string=} value new value to set the ending symbol to.
    * @returns {string|InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
    */
-  this.endSymbol = function (value) {
+  endSymbol(value) {
     if (value) {
-      endSymbol = value;
+      this.end = value;
       return this;
     }
-    return endSymbol;
-  };
+    return this.end;
+  }
 
-  this.$get = [
+  $get = [
     "$parse",
-    "$exceptionHandler",
     "$sce",
     /**
      *
      * @param {import("../parser/parse").ParseService} $parse
-     * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
      * @param {*} $sce
      * @returns
      */
-    function ($parse, $exceptionHandler, $sce) {
-      const startSymbolLength = startSymbol.length;
-      const endSymbolLength = endSymbol.length;
+    function ($parse, $sce) {
+      /** @type {InterpolateProvider} */
+      const provider = this;
+      const startSymbolLength = provider.start.length;
+      const endSymbolLength = provider.end.length;
       const escapedStartRegexp = new RegExp(
-        startSymbol.replace(/./g, escape),
+        this.start.replace(/./g, escape),
+        "g",
+      );
+      const escapedEndRegexp = new RegExp(
+        provider.end.replace(/./g, escape),
         "g",
       );
-      const escapedEndRegexp = new RegExp(endSymbol.replace(/./g, escape), "g");
 
       function escape(ch) {
         return `\\\\\\${ch}`;
@@ -98,8 +105,8 @@ export function InterpolateProvider() {
 
       function unescapeText(text) {
         return text
-          .replace(escapedStartRegexp, startSymbol)
-          .replace(escapedEndRegexp, endSymbol);
+          .replace(escapedStartRegexp, provider.start)
+          .replace(escapedEndRegexp, provider.end);
       }
 
       /**
@@ -222,7 +229,7 @@ export function InterpolateProvider() {
           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 (!text.length || text.indexOf(provider.start) === -1) {
           if (mustHaveExpression) return;
 
           let unescapedText = unescapeText(text);
@@ -255,9 +262,9 @@ export function InterpolateProvider() {
 
         while (index < textLength) {
           if (
-            (startIndex = text.indexOf(startSymbol, index)) !== -1 &&
+            (startIndex = text.indexOf(provider.start, index)) !== -1 &&
             (endIndex = text.indexOf(
-              endSymbol,
+              provider.end,
               startIndex + startSymbolLength,
             )) !== -1
           ) {
@@ -390,7 +397,7 @@ export function InterpolateProvider() {
        * @returns {string} start symbol.
        */
       $interpolate.startSymbol = function () {
-        return startSymbol;
+        return provider.start;
       };
 
       /**
@@ -402,7 +409,7 @@ export function InterpolateProvider() {
        * @returns {string} end symbol.
        */
       $interpolate.endSymbol = function () {
-        return endSymbol;
+        return provider.end;
       };
 
       return $interpolate;

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 = [
@@ -107,11 +102,11 @@ export class RootScopeProvider {
      * @param {import('../../services/browser').Browser} browser
      * @returns {Scope} root scope
      */
-    function (exceptionHandler, parse, browser) {
+    (exceptionHandler, parse, browser) => {
       $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,11 @@ 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 +241,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.$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 +261,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 +270,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 +726,6 @@ export class Scope {
  *
  */
   $digest() {
-    let watch;
     let value;
     let last;
     let fn;
@@ -741,10 +734,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 +747,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 +787,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 +1030,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 +1243,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 +1335,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 +1407,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]) {