@angular-wave/angular.ts 0.7.7 → 0.8.0

package/src/angular.spec.js

@@ -1,29 +1,29 @@
 import {
-  lowercase,
-  uppercase,
+  encodeUriQuery,
+  encodeUriSegment,
+  equals,
   extend,
-  isDefined,
+  fromJson,
+  getNodeName,
+  hashKey,
+  isArrayLike,
   isDate,
-  isRegExp,
+  isDefined,
   isElement,
-  shallowCopy,
-  equals,
-  isWindow,
-  hashKey,
-  toKeyValue,
-  parseKeyValue,
   isError,
-  isArrayLike,
-  encodeUriSegment,
-  encodeUriQuery,
-  toJson,
-  fromJson,
+  isRegExp,
+  isWindow,
+  lowercase,
   nextUid,
-  getNodeName,
+  parseKeyValue,
+  shallowCopy,
   snakeCase,
+  toJson,
+  toKeyValue,
+  uppercase,
 } from "./shared/utils.js";
 import { createElementFromHTML, dealoc, startingTag } from "./shared/dom.js";
-import { Angular } from "./loader.js";
+import { Angular } from "./angular.js";
 import { createInjector } from "./core/di/injector.js";
 import { wait } from "./shared/test-utils.js";
 
@@ -594,15 +594,16 @@ describe("angular", () => {
 
     it("should look for ngApp directive using querySelectorAll", () => {
       window.angular.module("ABC", []);
-      const appElement = createElementFromHTML('<div ng-app="ABC"></div>');
-      element.querySelector["[ng-app]"] = appElement;
+      element.querySelector["[ng-app]"] = createElementFromHTML(
+        '<div ng-app="ABC"></div>',
+      );
       window.angular.init(element);
       expect(bootstrapSpy).toHaveBeenCalled();
     });
 
     it("should bootstrap anonymously", () => {
-      const appElement = createElementFromHTML("<div ng-app></div>");
-      element.querySelector["[ng-app]"] = appElement;
+      element.querySelector["[ng-app]"] =
+        createElementFromHTML("<div ng-app></div>");
       window.angular.init(element);
       expect(bootstrapSpy).toHaveBeenCalled();
     });
@@ -1021,3 +1022,170 @@ describe("angular", () => {
     });
   });
 });
+
+describe("module loader", () => {
+  let angular;
+  beforeEach(() => {
+    angular = window.angular = new Angular();
+  });
+
+  it("allows registering a module", () => {
+    const myModule = angular.module("myModule", []);
+    expect(myModule).toBeDefined();
+    expect(myModule.name).toEqual("myModule");
+  });
+
+  it("allows getting a module", () => {
+    const myModule = angular.module("myModule", []);
+    const gotModule = angular.module("myModule");
+    expect(gotModule).toBeDefined();
+    expect(gotModule).toBe(myModule);
+  });
+
+  it("throws when trying to get a nonexistent module", () => {
+    expect(() => {
+      angular.module("nonexistent");
+    }).toThrow();
+  });
+
+  it("does not allow a module to be called hasOwnProperty", () => {
+    expect(() => {
+      angular.module("hasOwnProperty", []);
+    }).toThrow();
+  });
+
+  it("attaches the requires array to the registered module", () => {
+    const myModule = angular.module("myModule", ["myOtherModule"]);
+    expect(myModule.requires).toEqual(["myOtherModule"]);
+  });
+
+  it("replaces a module when registered with same name again", () => {
+    const myModule = angular.module("myModule", []);
+    const myNewModule = angular.module("myModule", []);
+    expect(myNewModule).not.toBe(myModule);
+  });
+
+  it("should record calls", () => {
+    const otherModule = angular.module("other", []);
+    otherModule.config("otherInit");
+
+    const myModule = angular.module("my", ["other"], "config");
+
+    expect(
+      myModule
+        .decorator("dk", "dv")
+        .provider("sk", "sv")
+        .factory("fk", "fv")
+        .service("a", "aa")
+        .value("k", "v")
+        .filter("f", "ff")
+        .directive("d", "dd")
+        .component("c", "cc")
+        .controller("ctrl", "ccc")
+        .config("init2")
+        .constant("abc", 123)
+        .run("runBlock"),
+    ).toBe(myModule);
+
+    expect(myModule.requires).toEqual(["other"]);
+    expect(myModule.invokeQueue).toEqual([
+      ["$provide", "constant", jasmine.objectContaining(["abc", 123])],
+      ["$provide", "provider", jasmine.objectContaining(["sk", "sv"])],
+      ["$provide", "factory", jasmine.objectContaining(["fk", "fv"])],
+      ["$provide", "service", jasmine.objectContaining(["a", "aa"])],
+      ["$provide", "value", jasmine.objectContaining(["k", "v"])],
+      ["$filterProvider", "register", jasmine.objectContaining(["f", "ff"])],
+      ["$compileProvider", "directive", jasmine.objectContaining(["d", "dd"])],
+      ["$compileProvider", "component", jasmine.objectContaining(["c", "cc"])],
+      [
+        "$controllerProvider",
+        "register",
+        jasmine.objectContaining(["ctrl", "ccc"]),
+      ],
+    ]);
+    expect(myModule.configBlocks).toEqual([
+      ["$injector", "invoke", jasmine.objectContaining(["config"])],
+      ["$provide", "decorator", jasmine.objectContaining(["dk", "dv"])],
+      ["$injector", "invoke", jasmine.objectContaining(["init2"])],
+    ]);
+    expect(myModule.runBlocks).toEqual(["runBlock"]);
+  });
+
+  it("should not throw error when `module.decorator` is declared before provider that it decorates", () => {
+    angular
+      .module("theModule", [])
+      .decorator("theProvider", ($delegate) => $delegate)
+      .factory("theProvider", () => ({}));
+
+    expect(() => {
+      createInjector(["theModule"]);
+    }).not.toThrow();
+  });
+
+  it("should run decorators in order of declaration, even when mixed with provider.decorator", () => {
+    let log = "";
+
+    angular
+      .module("theModule", [])
+      .factory("theProvider", () => ({ api: "provider" }))
+      .decorator("theProvider", ($delegate) => {
+        $delegate.api += "-first";
+        return $delegate;
+      })
+      .config(($provide) => {
+        $provide.decorator("theProvider", ($delegate) => {
+          $delegate.api += "-second";
+          return $delegate;
+        });
+      })
+      .decorator("theProvider", ($delegate) => {
+        $delegate.api += "-third";
+        return $delegate;
+      })
+      .run((theProvider) => {
+        log = theProvider.api;
+      });
+
+    createInjector(["theModule"]);
+    expect(log).toBe("provider-first-second-third");
+  });
+
+  it("should decorate the last declared provider if multiple have been declared", () => {
+    let log = "";
+
+    angular
+      .module("theModule", [])
+      .factory("theProvider", () => ({
+        api: "firstProvider",
+      }))
+      .decorator("theProvider", ($delegate) => {
+        $delegate.api += "-decorator";
+        return $delegate;
+      })
+      .factory("theProvider", () => ({
+        api: "secondProvider",
+      }))
+      .run((theProvider) => {
+        log = theProvider.api;
+      });
+
+    createInjector(["theModule"]);
+    expect(log).toBe("secondProvider-decorator");
+  });
+
+  it("should allow module redefinition", () => {
+    expect(angular.module("a", [])).not.toBe(angular.module("a", []));
+  });
+
+  it("should complain of no module", () => {
+    expect(() => {
+      angular.module("dontExist");
+    }).toThrow();
+  });
+
+  it('should complain if a module is called "hasOwnProperty', () => {
+    expect(() => {
+      angular.module("hasOwnProperty", []);
+    }).toThrow();
+  });
+});

package/src/animations/animate-children-directive.js

@@ -1,9 +1,9 @@
 import { isString } from "../shared/utils.js";
 import { NG_ANIMATE_CHILDREN_DATA } from "./shared.js";
 import { setCacheData } from "../shared/dom.js";
-import { $injectTokens } from "../injection-tokens.js";
+import { $injectTokens as $t } from "../injection-tokens.js";
 
-$$AnimateChildrenDirective.$inject = [$injectTokens.$interpolate];
+$$AnimateChildrenDirective.$inject = [$t.$interpolate];
 
 /**
  * @param {*} $interpolate

package/src/animations/animate-css.js

@@ -5,33 +5,33 @@ import {
 } from "../shared/dom.js";
 import { isDefined } from "../shared/utils.js";
 import {
-  TRANSITION_DURATION_PROP,
-  TRANSITION_DELAY_PROP,
+  ACTIVE_CLASS_SUFFIX,
+  ADD_CLASS_SUFFIX,
   ANIMATION_DELAY_PROP,
-  TRANSITION_PROP,
-  PROPERTY_KEY,
   ANIMATION_DURATION_PROP,
   ANIMATION_ITERATION_COUNT_KEY,
   ANIMATION_PROP,
-  DURATION_KEY,
+  ANIMATIONEND_EVENT,
   applyAnimationClassesFactory,
-  pendClasses,
-  prepareAnimationOptions,
-  packageStyles,
-  EVENT_CLASS_PREFIX,
-  ADD_CLASS_SUFFIX,
-  REMOVE_CLASS_SUFFIX,
-  applyInlineStyle,
-  SAFE_FAST_FORWARD_DURATION_VALUE,
-  ACTIVE_CLASS_SUFFIX,
   applyAnimationFromStyles,
   applyAnimationStyles,
+  applyAnimationToStyles,
+  applyInlineStyle,
   blockKeyframeAnimations,
+  DURATION_KEY,
+  EVENT_CLASS_PREFIX,
+  packageStyles,
+  pendClasses,
+  prepareAnimationOptions,
+  PROPERTY_KEY,
+  REMOVE_CLASS_SUFFIX,
   removeFromArray,
+  SAFE_FAST_FORWARD_DURATION_VALUE,
   TIMING_KEY,
+  TRANSITION_DELAY_PROP,
+  TRANSITION_DURATION_PROP,
+  TRANSITION_PROP,
   TRANSITIONEND_EVENT,
-  ANIMATIONEND_EVENT,
-  applyAnimationToStyles,
 } from "./shared.js";
 
 const ANIMATE_TIMER_KEY = "$$animateCss";
@@ -771,8 +771,7 @@ export function AnimateCssProvider() {
 
             temporaryStyles.forEach((entry) => {
               const key = entry[0];
-              const value = entry[1];
-              node.style[key] = value;
+              node.style[key] = entry[1];
             });
 
             applyAnimationClasses(element, options);

package/src/animations/animate.spec.js

@@ -1,5 +1,5 @@
 import { dealoc } from "../../shared/dom.js";
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { isObject } from "../../shared/utils.js";
 import { isFunction } from "../../shared/utils.js";
 import { createInjector } from "../di/injector.js";

package/src/animations/raf-scheduler.js

@@ -5,7 +5,7 @@
 
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
- * @implements {ServiceProvider}
+ * @type {ServiceProvider}
  */
 export class RafSchedulerProvider {
   constructor() {

package/src/animations/shared.js

@@ -1,4 +1,4 @@
-import { isString, minErr, extend } from "../shared/utils.js";
+import { extend, isString, minErr } from "../shared/utils.js";
 import { ASTType } from "../core/parse/ast-type.js";
 
 export const ADD_CLASS_SUFFIX = "-add";
@@ -76,15 +76,6 @@ export function assertArg(arg, name, reason) {
   return arg;
 }
 
-export function mergeClasses(a, b) {
-  if (!a && !b) return "";
-  if (!a) return b;
-  if (!b) return a;
-  if (Array.isArray(a)) a = a.join(" ");
-  if (Array.isArray(b)) b = b.join(" ");
-  return `${a} ${b}`;
-}
-
 export function packageStyles(options) {
   const styles = {};
   if (options && (options.to || options.from)) {
@@ -340,8 +331,7 @@ export function blockKeyframeAnimations(node, applyBlock) {
 
 export function applyInlineStyle(node, styleTuple) {
   const prop = styleTuple[0];
-  const value = styleTuple[1];
-  node.style[prop] = value;
+  node.style[prop] = styleTuple[1];
 }
 
 export function concatWithSpace(a, b) {

package/src/binding.spec.js

@@ -1,5 +1,5 @@
 import { createElementFromHTML, dealoc } from "./shared/dom.js";
-import { Angular } from "./loader.js";
+import { Angular } from "./angular.js";
 import { browserTrigger, wait } from "./shared/test-utils.js";
 
 describe("binding", () => {

package/src/core/compile/attributes.js

@@ -26,7 +26,7 @@ export class Attributes {
   /**
    * @param {import('../scope/scope.js').Scope} $rootScope
    * @param {*} $animate
-   * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
+   * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object} [attributesToCopy]

package/src/core/compile/compile.js

@@ -37,7 +37,7 @@ import {
   isProxy,
   hasOwn,
 } from "../../shared/utils.js";
-import { SCE_CONTEXTS } from "../sce/sce.js";
+import { SCE_CONTEXTS } from "../../services/sce/sce.js";
 import { PREFIX_REGEXP } from "../../shared/constants.js";
 import { createEventDirective } from "../../directive/events/events.js";
 import { Attributes } from "./attributes.js";
@@ -139,7 +139,7 @@ const EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
 export const DirectiveSuffix = "Directive";
 
 export class CompileProvider {
-  static $inject = ["$provide", "$$sanitizeUriProvider"];
+  /* @ignore */ static $inject = ["$provide", "$$sanitizeUriProvider"];
 
   /**
    * @param {import('../../interface.js').Provider} $provide
@@ -291,7 +291,7 @@ export class CompileProvider {
             "$exceptionHandler",
             /**
              * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
-             * @param {import('../exception-handler.js').ErrorHandler} $exceptionHandler
+             * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
              */
             function ($injector, $exceptionHandler) {
               const directives = [];
@@ -619,7 +619,7 @@ export class CompileProvider {
       /**
        * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
        * @param {*} $interpolate
-       * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
+       * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
        * @param {*} $templateRequest
        * @param {import("../parse/interface.ts").ParseService} $parse
        * @param {*} $controller
@@ -1216,8 +1216,7 @@ export class CompileProvider {
               // Null out all of these references for garbage collection
               compileNodes = transcludeFn = previousCompileContext = null;
             }
-            const linked = compiled.apply(this, arguments);
-            return linked;
+            return compiled.apply(this, arguments);
           };
         }
 
@@ -1561,14 +1560,13 @@ export class CompileProvider {
                 //  * `undefined` - a slot that was not declared (i.e. invalid)
                 const slotTranscludeFn = boundTranscludeFn.$$slots[slotName];
                 if (slotTranscludeFn) {
-                  const slotTranscludeRes = slotTranscludeFn(
+                  return slotTranscludeFn(
                     scope,
                     cloneAttachFn,
                     transcludeControllers,
                     futureParentElement,
                     scopeToChild,
                   );
-                  return slotTranscludeRes;
                 }
 
                 if (isUndefined(slotTranscludeFn)) {
@@ -1581,14 +1579,13 @@ export class CompileProvider {
                   );
                 }
               } else {
-                const boundTranscludeRes = boundTranscludeFn(
+                return boundTranscludeFn(
                   scope,
                   cloneAttachFn,
                   transcludeControllers,
                   futureParentElement,
                   scopeToChild,
                 );
-                return boundTranscludeRes;
               }
             }
           };

package/src/core/compile/compile.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../di/injector.js";
 import {
   dealoc,

package/src/core/controller/controller.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector } from "../di/injector.js";
 
 describe("$controller", () => {

package/src/core/controller/controller.test.js

@@ -5,6 +5,7 @@ const TEST_URL = "src/core/controller/controller.html";
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/core/di/injector.js

@@ -1,16 +1,16 @@
 import {
+  assert,
+  assertArg,
   assertArgFn,
-  minErr,
+  assertNotHasOwnProperty,
   isFunction,
+  isObject,
   isString,
   isUndefined,
-  assertArg,
-  assertNotHasOwnProperty,
-  isObject,
-  assert,
+  minErr,
 } from "../../shared/utils.js";
 import { INJECTOR_LITERAL } from "./ng-module.js";
-import { ProviderInjector, InjectorService } from "./internal-injector.js";
+import { InjectorService, ProviderInjector } from "./internal-injector.js";
 
 const ARROW_ARG = /^([^(]+?)=>/;
 const FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
@@ -33,9 +33,6 @@ export function createInjector(modulesToLoad, strictDi = false) {
   const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
 
   const providerCache = {
-    /**
-     * @type {import('../../interface.ts').Provider}
-     */
     $provide: {
       provider: supportObject(provider),
       factory: supportObject(factory),
@@ -62,15 +59,10 @@ export function createInjector(modulesToLoad, strictDi = false) {
   const runBlocks = loadModules(modulesToLoad);
   instanceInjector = protoInstanceInjector.get(INJECTOR_LITERAL);
 
-  runBlocks.forEach((fn) => {
-    if (fn) instanceInjector.invoke(fn);
-  });
+  runBlocks.forEach((fn) => fn && instanceInjector.invoke(fn));
 
-  instanceInjector.loadNewModules = function (mods) {
-    loadModules(mods).forEach((fn) => {
-      if (fn) instanceInjector.invoke(fn);
-    });
-  };
+  instanceInjector.loadNewModules = (mods) =>
+    loadModules(mods).forEach((fn) => fn && instanceInjector.invoke(fn));
 
   return instanceInjector;
 
@@ -199,7 +191,7 @@ export function createInjector(modulesToLoad, strictDi = false) {
 
       try {
         if (isString(module)) {
-          /** @type {import('./ng-module').NgModule} */
+          /** @type {import('./ng-module.js').NgModule} */
           const moduleFn = window["angular"].module(module);
           instanceInjector.modules[/** @type {string } */ (module)] = moduleFn;
           runBlocks = runBlocks
@@ -260,12 +252,10 @@ function stringifyFn(fn) {
  */
 function extractArgs(fn) {
   const fnText = stringifyFn(fn).replace(STRIP_COMMENTS, "");
-  const args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
-  return args;
+  return fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
 }
 
 /**
- *
  * @param {any} fn
  * @param {boolean} [strictDi]
  * @param {String} [name]
@@ -304,10 +294,6 @@ export function annotate(fn, strictDi, name) {
   return $inject;
 }
 
-/**
- * @param {function(string, any):any} delegate
- * @returns {any}
- */
 function supportObject(delegate) {
   return function (key, value) {
     if (isObject(key)) {

package/src/core/di/injector.spec.js

@@ -1,4 +1,4 @@
-import { Angular } from "../../loader.js";
+import { Angular } from "../../angular.js";
 import { createInjector, annotate } from "./injector.js";
 import { extend } from "../../shared/utils.js";
 
@@ -296,7 +296,7 @@ describe("injector.modules", () => {
     module.constant("b", 2);
     const injector = createInjector(["myModule"]);
     class Foo {
-      static $inject = ["a", "b"];
+      /* @ignore */ static $inject = ["a", "b"];
       constructor(a, b) {
         this.c = a + b;
       }

package/src/core/di/injector.test.js

@@ -1,11 +1,11 @@
 import { test, expect } from "@playwright/test";
 
-const TEST_URL = "src/core/di/injector.html";
+const TEST_URL = "src/core/di/injector.html?random=false";
 
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);
   await page.content();
-  await page.waitForTimeout(5000);
+  await page.waitForTimeout(1000);
   await expect(page.locator(".jasmine-overall-result")).toHaveText(
     /0 failures/,
   );

package/src/core/di/internal-injector.js

@@ -109,8 +109,7 @@ class AbstractInjector {
 
     if (isClass(/** @type {Function} */ (fn))) {
       args.unshift(null);
-      const res = new (Function.prototype.bind.apply(fn, args))();
-      return res;
+      return new (Function.prototype.bind.apply(fn, args))();
     } else {
       return /** @type {Function} */ (fn).apply(self, args);
     }
@@ -186,8 +185,11 @@ export class InjectorService extends AbstractInjector {
    */
   constructor(providerInjector, strictDi) {
     super(strictDi);
+
+    /** @type {ProviderInjector} */
     this.providerInjector = providerInjector;
-    this.modules = this.providerInjector.modules;
+    /** @type {Object.<string, import("./ng-module.js").NgModule>} */
+    this.modules = providerInjector.modules;
   }
 
   /**
@@ -196,8 +198,7 @@ export class InjectorService extends AbstractInjector {
    */
   factory(serviceName) {
     const provider = this.providerInjector.get(serviceName + providerSuffix);
-    const res = this.invoke(provider.$get, provider, undefined, serviceName);
-    return res;
+    return this.invoke(provider.$get, provider, undefined, serviceName);
   }
 
   /**
@@ -231,8 +232,7 @@ function stringifyFn(fn) {
  */
 function extractArgs(fn) {
   const fnText = stringifyFn(fn).replace(STRIP_COMMENTS, "");
-  const args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
-  return args;
+  return fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
 }
 
 /**