npm - @angular-wave/angular.ts - Versions diffs - 0.1.2 → 0.1.4 - Mend

@angular-wave/angular.ts 0.1.2 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (749) hide show

package/package.json CHANGED Viewed

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

package/src/angular.spec.js CHANGED Viewed

@@ -1893,83 +1893,6 @@ describe("angular", () => {
       expect(element.html()).toBe("{{1+2}}");
       dealoc(element);
     });
-    describe("deferred bootstrap", () => {
-      const originalName = window.name;
-      let element;
-      beforeEach(() => {
-        window.name = "";
-        element = JQLite("<div>{{1+2}}</div>");
-      });
-      afterEach(() => {
-        dealoc(element);
-        window.name = originalName;
-      });
-      it("should provide injector for deferred bootstrap", () => {
-        window.name = "NG_DEFER_BOOTSTRAP!";
-        injector = angular.bootstrap(element);
-        expect(injector).toBeUndefined();
-        injector = angular.resumeBootstrap();
-        expect(injector).toBeDefined();
-      });
-      it("should wait for extra modules", () => {
-        window.name = "NG_DEFER_BOOTSTRAP!";
-        angular.bootstrap(element);
-        expect(element.html()).toBe("{{1+2}}");
-        angular.resumeBootstrap();
-        expect(element.html()).toBe("3");
-        expect(window.name).toEqual("");
-      });
-      it("should load extra modules", () => {
-        element = JQLite("<div>{{1+2}}</div>");
-        window.name = "NG_DEFER_BOOTSTRAP!";
-        const bootstrapping = jasmine.createSpy("bootstrapping");
-        angular.bootstrap(element, [bootstrapping]);
-        expect(bootstrapping).not.toHaveBeenCalled();
-        expect(element.injector()).toBeUndefined();
-        angular.module("addedModule", []).value("foo", "bar");
-        angular.resumeBootstrap(["addedModule"]);
-        expect(bootstrapping).toHaveBeenCalled();
-        expect(element.injector().get("foo")).toEqual("bar");
-      });
-      it("should not defer bootstrap without window.name cue", () => {
-        angular.bootstrap(element, []);
-        angular.module("addedModule", []).value("foo", "bar");
-        expect(() => {
-          element.injector().get("foo");
-        }).toThrowError(/unpr/);
-        expect(element.injector().get("$http")).toBeDefined();
-      });
-      it("should restore the original window.name after bootstrap", () => {
-        window.name = "NG_DEFER_BOOTSTRAP!my custom name";
-        angular.bootstrap(element);
-        expect(element.html()).toBe("{{1+2}}");
-        angular.resumeBootstrap();
-        expect(element.html()).toBe("3");
-        expect(window.name).toEqual("my custom name");
-      });
-    });
   });
   describe("startingElementHtml", () => {

package/src/animations/animate-css.html CHANGED Viewed

@@ -49,13 +49,7 @@
     </style>
   </head>
   <body ng-app="test">
-    <div ng-if="bool" id="data-animate" class="fade" data-animate="true">
-      Fade me in out
-    </div>
-    <div ng-if="bool" id="animate" class="fade" animate="true">
-      Fade me in out
-    </div>
-    <div ng-if="bool" id="no-animate" class="fade">Fade me in out</div>
+    <div class="{{bool}}">{{bool}}</div>
     <button ng-click="bool=true">Fade In!</button>
     <button ng-click="bool=false">Fade Out!</button>
   </body>

package/src/animations/animate-css.js CHANGED Viewed

@@ -392,7 +392,7 @@ export function $AnimateCssProvider() {
         if (!options.$$skipPreparationClasses) {
           element[0].classList.add(
-            preparationClasses.split(" ").filter((x) => x !== ""),
+            ...preparationClasses.split(" ").filter((x) => x !== ""),
           );
         }
@@ -589,15 +589,11 @@ export function $AnimateCssProvider() {
           animationPaused = false;
           if (preparationClasses && !options.$$skipPreparationClasses) {
-            preparationClasses.split(" ").forEach(function (cls) {
-              element[0].classList.remove(cls);
-            });
+            element[0].classList.remove(...preparationClasses.split(" "));
           }
           activeClasses = pendClasses(preparationClasses, ACTIVE_CLASS_SUFFIX);
           if (activeClasses) {
-            activeClasses.split(" ").forEach(function (cls) {
-              element[0].classList.remove(cls);
-            });
+            element[0].classList.remove(...activeClasses.split(" "));
           }
           blockKeyframeAnimations(node, false);
@@ -786,9 +782,8 @@ export function $AnimateCssProvider() {
             });
             applyAnimationClasses(element, options);
             element[0].classList.add(
-              activeClasses.split(" ").filter((x) => x !== ""),
+              ...activeClasses.split(" ").filter((x) => x !== ""),
             );
             if (flags.recalculateTimingStyles) {
               cacheKey = $$animateCache.cacheKey(

package/src/core/compile/compile.js CHANGED Viewed

@@ -2352,7 +2352,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
                 // Copy in CSS classes from original node
                 try {
                   if (oldClasses !== "") {
-                    linkNode.classList.add(oldClasses);
+                    linkNode.classList.add(...oldClasses.trim().split(" "));
                   }
                 } catch (e) {
                   // ignore, since it means that we are trying to set class on

package/src/core/location/location.js CHANGED Viewed

@@ -649,11 +649,11 @@ export function $LocationProvider() {
       const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
-      function setBrowserUrlWithFallback(url, replace, state) {
+      function setBrowserUrlWithFallback(url, state) {
         const oldUrl = $location.url();
         const oldState = $location.$$state;
         try {
-          $browser.url(url, replace, state);
+          $browser.url(url, state);
           // Make sure $location.state() returns referentially identical (not just deeply equal)
           // state object; this makes possible quick checking if the state changed in the digest
@@ -762,7 +762,7 @@ export function $LocationProvider() {
           if (defaultPrevented) {
             $location.$$parse(oldUrl);
             $location.$$state = oldState;
-            setBrowserUrlWithFallback(oldUrl, false, oldState);
+            setBrowserUrlWithFallback(oldUrl, oldState);
           } else {
             initializing = false;
             afterLocationChange(oldUrl, oldState);
@@ -779,7 +779,6 @@ export function $LocationProvider() {
           const oldUrl = /** @type {string} */ ($browser.url());
           const newUrl = $location.absUrl();
           const oldState = $browser.state();
-          const currentReplace = $location.$$replace;
           const urlOrStateChanged =
             !urlsEqual(oldUrl, newUrl) ||
             ($location.$$html5 && oldState !== $location.$$state);
@@ -808,7 +807,6 @@ export function $LocationProvider() {
                 if (urlOrStateChanged) {
                   setBrowserUrlWithFallback(
                     newUrl,
-                    currentReplace,
                     oldState === $location.$$state ? null : $location.$$state,
                   );
                 }

package/src/core/task-tracker-factory.js CHANGED Viewed

@@ -1,122 +1,138 @@
-export function $$TaskTrackerFactoryProvider() {
-  this.$get = [
+export class $$TaskTrackerFactoryProvider {
+  $get = [
     "$log",
-    /** @param {import('../services/log').LogService} log */
+    /**
+     * Creates a new `TaskTracker` instance.
+     *
+     * @param {import('../services/log').LogService} log - The logging service.
+     * @returns {TaskTracker} A new `TaskTracker` instance.
+     */
     (log) => new TaskTracker(log),
   ];
 }
 /**
- * ! This is a private undocumented service !
+ * A factory function to create `TaskTracker` instances.
  *
- * @name $$taskTrackerFactory
- * @description
- * A function to create `TaskTracker` instances.
- *
- * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
+ * A `TaskTracker` tracks pending tasks (grouped by type) and notifies interested
  * parties when all pending tasks (or tasks of a specific type) have been completed.
- * @param {import('../services/log').LogService} log
  */
-export function TaskTracker(log) {
-  const self = this;
-  const taskCounts = {};
-  const taskCallbacks = [];
-  const ALL_TASKS_TYPE = (self.ALL_TASKS_TYPE = "$$all$$");
-  const DEFAULT_TASK_TYPE = (self.DEFAULT_TASK_TYPE = "$$default$$");
+export class TaskTracker {
   /**
-   * Execute the specified function and decrement the appropriate `taskCounts` counter.
-   * If the counter reaches 0, all corresponding `taskCallbacks` are executed.
-   *
-   * @param {Function} fn - The function to execute.
-   * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task that is being completed.
+   * @param {import('../services/log').LogService} log - The logging service.
    */
-  self.completeTask = completeTask;
+  constructor(log) {
+    /** @private */
+    this.log = log;
-  /**
-   * Increase the task count for the specified task type (or the default task type if non is
-   * specified).
-   *
-   * @param {string=} [taskType=DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
-   */
-  self.incTaskCount = incTaskCount;
+    /** @private */
+    this.taskCounts = {};
+    /** @private */
+    this.taskCallbacks = [];
+    /**
+     * Special task types used for tracking all tasks and default tasks.
+     * @type {string}
+     */
+    this.ALL_TASKS_TYPE = "$$all$$";
+    /**
+     * Default task type.
+     * @type {string}
+     */
+    this.DEFAULT_TASK_TYPE = "$$default$$";
+  }
   /**
-   * Execute the specified callback when all pending tasks have been completed.
-   *
-   * If there are no pending tasks, the callback is executed immediately. You can optionally limit
-   * the tasks that will be waited for to a specific type, by passing a `taskType`.
+   * Completes a task and decrements the associated task counter.
+   * If the counter reaches 0, all corresponding callbacks are executed.
    *
-   * @param {function} callback - The function to call when there are no pending tasks.
-   * @param {string=} [taskType=ALL_TASKS_TYPE] - The type of tasks that will be waited for.
+   * @param {Function} fn - The function to execute when completing the task.
+   * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task being completed.
    */
-  self.notifyWhenNoPendingTasks = notifyWhenNoPendingTasks;
-  function completeTask(fn, taskType) {
-    taskType = taskType || DEFAULT_TASK_TYPE;
+  completeTask(fn, taskType = this.DEFAULT_TASK_TYPE) {
     try {
       fn();
     } finally {
-      decTaskCount(taskType);
+      if (this.taskCounts[taskType]) {
+        this.taskCounts[taskType]--;
+        this.taskCounts[this.ALL_TASKS_TYPE]--;
+      }
-      const countForType = taskCounts[taskType];
-      const countForAll = taskCounts[ALL_TASKS_TYPE];
+      const countForType = this.taskCounts[taskType];
+      const countForAll = this.taskCounts[this.ALL_TASKS_TYPE];
-      // If at least one of the queues (`ALL_TASKS_TYPE` or `taskType`) is empty, run callbacks.
+      // If either the overall task queue or the specific task type queue is empty, run callbacks.
       if (!countForAll || !countForType) {
         const getNextCallback = !countForAll
-          ? getLastCallback
-          : getLastCallbackForType;
-        let nextCb;
+          ? this.getLastCallback.bind(this)
+          : () => this.getLastCallbackForType(taskType);
-        while ((nextCb = getNextCallback(taskType))) {
+        let nextCb;
+        while ((nextCb = getNextCallback())) {
           try {
             nextCb();
           } catch (e) {
-            log.error(e);
+            this.log.error(e);
           }
         }
       }
     }
   }
-  function decTaskCount(taskType) {
-    taskType = taskType || DEFAULT_TASK_TYPE;
-    if (taskCounts[taskType]) {
-      taskCounts[taskType]--;
-      taskCounts[ALL_TASKS_TYPE]--;
+  /**
+   * Increments the task count for the specified task type.
+   *
+   * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
+   */
+  incTaskCount(taskType = this.DEFAULT_TASK_TYPE) {
+    this.taskCounts[taskType] = (this.taskCounts[taskType] || 0) + 1;
+    this.taskCounts[this.ALL_TASKS_TYPE] =
+      (this.taskCounts[this.ALL_TASKS_TYPE] || 0) + 1;
+  }
+  /**
+   * Registers a callback to be executed when all pending tasks of the specified type are completed.
+   * If there are no pending tasks of the specified type, the callback is executed immediately.
+   *
+   * @param {Function} callback - The function to execute when no pending tasks remain.
+   * @param {string} [taskType=this.ALL_TASKS_TYPE] - The type of tasks to wait for completion.
+   */
+  notifyWhenNoPendingTasks(callback, taskType = this.ALL_TASKS_TYPE) {
+    if (!this.taskCounts[taskType]) {
+      callback();
+    } else {
+      this.taskCallbacks.push({ type: taskType, cb: callback });
     }
   }
-  function getLastCallback() {
-    const cbInfo = taskCallbacks.pop();
-    return cbInfo && cbInfo.cb;
+  /**
+   * Retrieves and removes the last registered callback from the queue.
+   *
+   * @private
+   * @returns {Function|undefined} The last callback function or undefined if none exist.
+   */
+  getLastCallback() {
+    const cbInfo = this.taskCallbacks.pop();
+    return cbInfo ? cbInfo.cb : undefined;
   }
-  function getLastCallbackForType(taskType) {
-    for (let i = taskCallbacks.length - 1; i >= 0; --i) {
-      const cbInfo = taskCallbacks[i];
+  /**
+   * Retrieves and removes the last registered callback for the specified task type.
+   *
+   * @private
+   * @param {string} taskType - The type of task for which the callback was registered.
+   * @returns {Function|undefined} The last callback function for the task type, or undefined if none exist.
+   */
+  getLastCallbackForType(taskType) {
+    for (let i = this.taskCallbacks.length - 1; i >= 0; --i) {
+      const cbInfo = this.taskCallbacks[i];
       if (cbInfo.type === taskType) {
-        taskCallbacks.splice(i, 1);
+        this.taskCallbacks.splice(i, 1);
         return cbInfo.cb;
       }
     }
-  }
-  function incTaskCount(taskType) {
-    taskType = taskType || DEFAULT_TASK_TYPE;
-    taskCounts[taskType] = (taskCounts[taskType] || 0) + 1;
-    taskCounts[ALL_TASKS_TYPE] = (taskCounts[ALL_TASKS_TYPE] || 0) + 1;
-  }
-  function notifyWhenNoPendingTasks(callback, taskType) {
-    taskType = taskType || ALL_TASKS_TYPE;
-    if (!taskCounts[taskType]) {
-      callback();
-    } else {
-      taskCallbacks.push({ type: taskType, cb: callback });
-    }
+    return undefined;
   }
 }

package/src/loader.js CHANGED Viewed

@@ -113,61 +113,45 @@ export class Angular {
       strictDi: false,
     };
-    this.doBootstrap = function () {
-      const jqLite = JQLite(element);
+    const jqLite = JQLite(element);
-      if (jqLite.injector()) {
-        throw ngMinErr("btstrpd", "App already bootstrapped");
-      }
-      if (Array.isArray(modules)) {
-        this.bootsrappedModules = modules;
-      }
-      this.bootsrappedModules.unshift([
-        "$provide",
-        ($provide) => {
-          $provide.value("$rootElement", jqLite);
-        },
-      ]);
-      this.bootsrappedModules.unshift("ng");
+    if (jqLite.injector()) {
+      throw ngMinErr("btstrpd", "App already bootstrapped");
+    }
-      const injector = createInjector(this.bootsrappedModules, config.strictDi);
-      injector.invoke([
-        "$rootScope",
-        "$rootElement",
-        "$compile",
-        "$injector",
-        /**
-         * @param {import('./core/scope/scope').Scope} scope
-         * @param {JQLite} el
-         * @param {*} compile
-         * @param {import("./core/di/internal-injector").InjectorService} $injector
-         */
-        function (scope, el, compile, $injector) {
-          scope.$apply(() => {
-            el.data("$injector", $injector);
-            compile(el)(scope);
-          });
-        },
-      ]);
-      return injector;
-    };
+    if (Array.isArray(modules)) {
+      this.bootsrappedModules = modules;
+    }
-    const NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
+    this.bootsrappedModules.unshift([
+      "$provide",
+      ($provide) => {
+        $provide.value("$rootElement", jqLite);
+      },
+    ]);
-    if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
-      return this.doBootstrap();
-    }
+    this.bootsrappedModules.unshift("ng");
-    window.name = window.name.replace(NG_DEFER_BOOTSTRAP, "");
-    this.resumeBootstrap = function (extraModules) {
-      if (Array.isArray(extraModules)) {
-        extraModules.forEach((module) => modules.push(module));
-      }
-      return this.doBootstrap();
-    };
+    const injector = createInjector(this.bootsrappedModules, config.strictDi);
+    injector.invoke([
+      "$rootScope",
+      "$rootElement",
+      "$compile",
+      "$injector",
+      /**
+       * @param {import('./core/scope/scope').Scope} scope
+       * @param {JQLite} el
+       * @param {*} compile
+       * @param {import("./core/di/internal-injector").InjectorService} $injector
+       */
+      function (scope, el, compile, $injector) {
+        scope.$apply(() => {
+          el.data("$injector", $injector);
+          compile(el)(scope);
+        });
+      },
+    ]);
+    return injector;
   }
   /**

package/src/public.js CHANGED Viewed

@@ -129,7 +129,6 @@ export const VERSION = "[VI]{version}[/VI]";
  * @returns {import('./types').Module} `ng`module
  */
 export function publishExternalAPI(angular) {
-  console.assert(angular !== undefined, `angular is %s`, angular);
   const ng = angular
     .module(
       "ng",

package/src/router/common/coreservices.js CHANGED Viewed

@@ -1,5 +1,4 @@
-const services = {
+export const services = {
   $q: undefined,
   $injector: undefined,
 };
-export { services };

package/src/router/params/param-type.js CHANGED Viewed

@@ -30,27 +30,22 @@ export class ParamType {
    * @returns a new ParamType object
    */
   constructor(def) {
-    /** @inheritdoc */
     this.pattern = /.*/;
-    /** @inheritdoc */
     this.inherit = true;
     Object.assign(this, def);
     this.name = undefined;
   }
   // consider these four methods to be "abstract methods" that should be overridden
-  /** @inheritdoc */
-  is(_val) {
-    return true;
+  is(val) {
+    return !!val;
   }
-  /** @inheritdoc */
   encode(val) {
     return val;
   }
-  /** @inheritdoc */
   decode(val) {
     return val;
   }
-  /** @inheritdoc */
   equals(a, b) {
     return a == b;
   }

package/src/router/params/param-types.js CHANGED Viewed

@@ -1,11 +1,4 @@
-import {
-  fromJson,
-  toJson,
-  equals,
-  inherit,
-  map,
-  pick,
-} from "../../shared/common";
+import { equals, inherit, map, pick } from "../../shared/common";
 import { isNullOrUndefined } from "../../shared/predicates";
 import { isDefined } from "../../shared/utils";
 import { is } from "../../shared/hof";
@@ -141,8 +134,8 @@ function initDefaultTypes() {
       capture: /([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/,
     }),
     json: makeDefaultType({
-      encode: toJson,
-      decode: fromJson,
+      encode: JSON.stringify,
+      decode: JSON.parse,
       is: is(Object),
       equals: equals,
       pattern: /[^/]*/,

package/src/router/resolve/resolvable.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { isFunction, isObject } from "../../shared/utils";
+import { assert, isFunction, isObject } from "../../shared/utils";
 import { services } from "../common/coreservices";
 import { trace } from "../common/trace";
 import { stringify } from "../../shared/strings";
@@ -27,12 +27,7 @@ export class Resolvable {
     if (arg1 instanceof Resolvable) {
       Object.assign(this, arg1);
     } else if (isFunction(resolveFn)) {
-      if (isNullOrUndefined(arg1))
-        throw new Error("new Resolvable(): token argument is required");
-      if (!isFunction(resolveFn))
-        throw new Error(
-          "new Resolvable(): resolveFn argument must be a function",
-        );
+      assert(!isNullOrUndefined(arg1), "token argument is required");
       this.token = arg1;
       this.policy = policy;
       this.resolveFn = resolveFn;
@@ -46,14 +41,11 @@ export class Resolvable {
       (Object.prototype.hasOwnProperty.call(arg1, "resolveFn") ||
         Object.prototype.hasOwnProperty.call(arg1, "data"))
     ) {
-      const literal = arg1;
-      return new Resolvable(
-        literal.token,
-        literal.resolveFn,
-        literal.deps,
-        literal.policy,
-        literal.data,
-      );
+      this.token = arg1.token;
+      this.resolveFn = arg1.resolveFn;
+      this.deps = arg1.deps;
+      this.policy = arg1.policy;
+      this.data = arg1.data;
     }
   }
   getPolicy(state) {

package/src/router/resolve/resolve-context.js CHANGED Viewed

@@ -7,7 +7,7 @@ import { PathUtils } from "../path/path-utils";
 import { stringify } from "../../shared/strings";
 import { isUndefined } from "../../shared/utils";
-export let resolvePolicies = {
+export const resolvePolicies = {
   when: {
     LAZY: "LAZY",
     EAGER: "EAGER",
@@ -18,10 +18,8 @@ export let resolvePolicies = {
   },
 };
-const whens = resolvePolicies.when;
-const ALL_WHENS = [whens.EAGER, whens.LAZY];
-const EAGER_WHENS = [whens.EAGER];
-export const NATIVE_INJECTOR_TOKEN = "Native Injector";
+const ALL_WHENS = [resolvePolicies.when.EAGER, resolvePolicies.when.LAZY];
+const EAGER_WHENS = [resolvePolicies.when.EAGER];
 /**
  * Encapsulates Dependency Injection for a path of nodes
  *

package/src/router/state/state-service.js CHANGED Viewed

@@ -667,6 +667,7 @@ export class StateService {
   defaultErrorHandler(handler) {
     return (this._defaultErrorHandler = handler || this._defaultErrorHandler);
   }
   get(stateOrName, base) {
     const reg = this.stateRegistry;
     if (arguments.length === 0) return reg.get();