@angular-wave/angular.ts 0.7.0-beta.0 → 0.7.1

package/src/core/controller/controller.js

@@ -19,7 +19,7 @@ export function identifierForController(controller, ident) {
 }
 
 /**
- * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * The {@link ng.$controller $controller service} is used by AngularTS to create new
  * controllers.
  *
  * This provider allows controller registration via the

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

@@ -27,55 +27,61 @@ describe("$controller", () => {
       });
 
       it("instantiates controller functions", function () {
-        var $controller = injector.get("$controller");
+        const $controller = injector.get("$controller");
+
         function MyController() {
           this.invoked = true;
         }
-        var controller = $controller(MyController);
+
+        const controller = $controller(MyController);
         expect(controller).toBeDefined();
         expect(controller instanceof MyController).toBe(true);
         expect(controller.invoked).toBe(true);
       });
 
       it("instantiates controller classes", function () {
-        var $controller = injector.get("$controller");
+        const $controller = injector.get("$controller");
+
         class MyController {
           constructor() {
             this.invoked = true;
           }
         }
 
-        var controller = $controller(MyController);
+        const controller = $controller(MyController);
         expect(controller).toBeDefined();
         expect(controller instanceof MyController).toBe(true);
         expect(controller.invoked).toBe(true);
       });
 
       it("injects dependencies to controller functions", function () {
-        var injector = createInjector([
+        const injector = createInjector([
           "ng",
           function ($provide) {
             $provide.constant("aDep", 42);
           },
         ]);
-        var $controller = injector.get("$controller");
+        const $controller = injector.get("$controller");
+
         function MyController(aDep) {
           this.theDep = aDep;
         }
-        var controller = $controller(MyController);
+
+        const controller = $controller(MyController);
         expect(controller.theDep).toBe(42);
       });
 
       it("allows registering controllers at config time", function () {
         function MyController() {}
-        var injector = createInjector([
+
+        const injector = createInjector([
           "ng",
           function ($controllerProvider) {
             $controllerProvider.register("MyController", MyController);
           },
         ]);
-        var $controller = injector.get("$controller");
-        var controller = $controller("MyController");
+        const $controller = injector.get("$controller");
+        const controller = $controller("MyController");
         expect(controller).toBeDefined();
         expect(controller instanceof MyController).toBe(true);
       });
@@ -83,7 +89,8 @@ describe("$controller", () => {
       it("allows registering several controllers in an object", function () {
         function MyController() {}
         function MyOtherController() {}
-        var injector = createInjector([
+
+        const injector = createInjector([
           "ng",
           function ($controllerProvider) {
             $controllerProvider.register({
@@ -92,26 +99,26 @@ describe("$controller", () => {
             });
           },
         ]);
-        var $controller = injector.get("$controller");
-        var controller = $controller("MyController");
-        var otherController = $controller("MyOtherController");
+        const $controller = injector.get("$controller");
+        const controller = $controller("MyController");
+        const otherController = $controller("MyOtherController");
         expect(controller instanceof MyController).toBe(true);
         expect(otherController instanceof MyOtherController).toBe(true);
       });
 
       it("allows registering controllers through modules", function () {
-        var module = window.angular.module("myModule", []);
+        const module = window.angular.module("myModule", []);
         module.controller("MyController", function MyController() {});
-        var injector = createInjector(["ng", "myModule"]);
-        var $controller = injector.get("$controller");
-        var controller = $controller("MyController");
+        const injector = createInjector(["ng", "myModule"]);
+        const $controller = injector.get("$controller");
+        const controller = $controller("MyController");
         expect(controller).toBeDefined();
       });
 
       it("does not normally look controllers up from window", function () {
         window.MyController = function MyController() {};
-        var injector = createInjector(["ng"]);
-        var $controller = injector.get("$controller");
+        const injector = createInjector(["ng"]);
+        const $controller = injector.get("$controller");
         expect(function () {
           $controller("MyController");
         }).toThrow();

package/src/core/di/injector.js

@@ -9,8 +9,8 @@ import {
   isObject,
   assert,
 } from "../../shared/utils.js";
-import { INJECTOR_LITERAL } from "./ng-module";
-import { ProviderInjector, InjectorService } from "./internal-injector";
+import { INJECTOR_LITERAL } from "./ng-module.js";
+import { ProviderInjector, InjectorService } from "./internal-injector.js";
 
 const ARROW_ARG = /^([^(]+?)=>/;
 const FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
@@ -18,10 +18,7 @@ const FN_ARG_SPLIT = /,/;
 const FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
 const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
 const $injectorMinErr = minErr(INJECTOR_LITERAL);
-
 const providerSuffix = "Provider";
-/** @type {String[]} Used only for error reporting of circular dependencies*/
-export const path = [];
 
 /**
  *
@@ -36,6 +33,9 @@ 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),
@@ -75,14 +75,14 @@ export function createInjector(modulesToLoad, strictDi = false) {
   return instanceInjector;
 
   ////////////////////////////////////
-  // $provider
+  // $provide methods
   ////////////////////////////////////
 
   /**
-   *
+   * Registers a provider.
    * @param {string} name
-   * @param {import('../../types.js').ServiceProvider} provider
-   * @returns
+   * @param {import('../../interface.ts').ServiceProvider | import('../../interface.ts').InjectableFactory} provider
+   * @returns {import('../../interface.ts').ServiceProvider}
    */
   function provider(name, provider) {
     assertNotHasOwnProperty(name, "service");
@@ -105,6 +105,12 @@ export function createInjector(modulesToLoad, strictDi = false) {
     return newProvider;
   }
 
+  /**
+   * Registers a factory.
+   * @param {string} name
+   * @param {(string|(function(*): *))[]} factoryFn
+   * @returns {import('../../interface.js').ServiceProvider}
+   */
   function factory(name, factoryFn) {
     return provider(name, {
       $get: () => {
@@ -121,6 +127,12 @@ export function createInjector(modulesToLoad, strictDi = false) {
     });
   }
 
+  /**
+   * Registers a service constructor.
+   * @param {string} name
+   * @param {Function} constructor
+   * @returns {import('../../interface.js').ServiceProvider}
+   */
   function service(name, constructor) {
     return factory(name, [
       INJECTOR_LITERAL,
@@ -129,20 +141,33 @@ export function createInjector(modulesToLoad, strictDi = false) {
   }
 
   /**
+   * Register a fixed value as a service.
    * @param {String} name
    * @param {any} val
-   * @returns {import('../../types.js').ServiceProvider}
+   * @returns {import('../../interface.ts').ServiceProvider}
    */
   function value(name, val) {
     return (providerCache[name + providerSuffix] = { $get: () => val });
   }
 
+  /**
+   * Register a constant value (available during config).
+   * @param {string} name
+   * @param {any} value
+   * @returns {void}
+   */
   function constant(name, value) {
     assertNotHasOwnProperty(name, "constant");
     providerInjector.cache[name] = value;
     protoInstanceInjector.cache[name] = value;
   }
 
+  /**
+   * Register a decorator function to modify or replace an existing service.
+   * @param name - The name of the service to decorate.
+   * @param fn - A function that takes `$delegate` and returns a decorated service.
+   * @returns {void}
+   */
   function decorator(serviceName, decorFn) {
     const origProvider = providerInjector.get(serviceName + providerSuffix);
     const origGet = origProvider.$get;
@@ -281,7 +306,7 @@ export function annotate(fn, strictDi, name) {
 
 /**
  * @param {function(string, any):any} delegate
- * @returns
+ * @returns {any}
  */
 function supportObject(delegate) {
   return function (key, value) {

package/src/core/di/injector.md

@@ -35,8 +35,8 @@
   ```
 
 -
-- Sometimes you want to get access to the injector of a currently running AngularJS app
-- from outside AngularJS. Perhaps, you want to inject and compile some markup after the
+- Sometimes you want to get access to the injector of a currently running AngularTS app
+- from outside AngularTS. Perhaps, you want to inject and compile some markup after the
 - application has been bootstrapped. You can do this using the extra `injector()` added
 - to JQuery/jqLite elements. See {@link angular.element}.
 -
@@ -45,7 +45,7 @@
 -
 - In the following example a new block of HTML containing a `ng-controller`
 - directive is added to the end of the document body by JQuery. We then compile and link
-- it into the current AngularJS scope.
+- it into the current AngularTS scope.
 -
 - ```js
 
@@ -381,7 +381,7 @@
 - with the {@link auto.$injector $injector}. Many of these functions are also exposed on
 - {@link angular.Module}.
 -
-- An AngularJS **service** is a singleton object created by a **service factory**. These \*\*service
+- An AngularTS **service** is a singleton object created by a **service factory**. These \*\*service
 - factories** are functions which, in turn, are created by a **service provider\*\*.
 - The **service providers** are constructor functions. When instantiated they must contain a
 - property called `$get`, which holds the **service factory** function.
@@ -644,7 +644,7 @@
 -
 - Value services are similar to constant services, except that they cannot be injected into a
 - module configuration function (see {@link angular.Module#config}) but they can be overridden by
-- an AngularJS {@link auto.$provide#decorator decorator}.
+- an AngularTS {@link auto.$provide#decorator decorator}.
 -
 - @param {string} name The name of the instance.
 - @param {\*} value The value.
@@ -679,7 +679,7 @@
 -
 - But unlike {@link auto.$provide#value value}, a constant can be
 - injected into a module configuration function (see {@link angular.Module#config}) and it cannot
-- be overridden by an AngularJS {@link auto.$provide#decorator decorator}.
+- be overridden by an AngularTS {@link auto.$provide#decorator decorator}.
 -
 - @param {string} name The name of the constant.
 - @param {\*} value The constant value.

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

@@ -1,9 +1,8 @@
-import { assertArgFn, minErr } from "../../shared/utils.js";
+import { assertArgFn, hasOwn, minErr } from "../../shared/utils.js";
 import { INJECTOR_LITERAL } from "./ng-module";
 
 const ARROW_ARG = /^([^(]+?)=>/;
 const FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m;
-const FN_ARG_SPLIT = /,/;
 const FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
 const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
 const $injectorMinErr = minErr(INJECTOR_LITERAL);
@@ -22,8 +21,9 @@ class AbstractInjector {
     this.cache = {};
     /** @type {boolean} */
     this.strictDi = strictDi;
+    /** @type {string[]} */
     this.path = [];
-    /** @type {Object.<string, import("../../types").Module>} */
+    /** @type {Object.<string, import("./ng-module.js").NgModule>} */
     this.modules = {};
   }
 
@@ -34,7 +34,7 @@ class AbstractInjector {
    * @returns {any}
    */
   get(serviceName) {
-    if (Object.prototype.hasOwnProperty.call(this.cache, serviceName)) {
+    if (hasOwn(this.cache, serviceName)) {
       if (this.cache[serviceName] === INSTANTIATING) {
         throw $injectorMinErr(
           "cdep",
@@ -48,7 +48,6 @@ class AbstractInjector {
     this.path.unshift(serviceName);
     this.cache[serviceName] = INSTANTIATING;
     try {
-      // this goes to line 60
       this.cache[serviceName] = this.factory(serviceName);
     } catch (err) {
       // this is for the error handling being thrown by the providerCache multiple times
@@ -79,11 +78,7 @@ class AbstractInjector {
           key,
         );
       }
-      args.push(
-        locals && Object.prototype.hasOwnProperty.call(locals, key)
-          ? locals[key]
-          : this.get(key),
-      );
+      args.push(locals && hasOwn(locals, key) ? locals[key] : this.get(key));
     }
     return args;
   }
@@ -95,7 +90,7 @@ class AbstractInjector {
    * @param {*} [self]
    * @param {Object} [locals]
    * @param {string} [serviceName]
-   * @returns
+   * @returns {*}
    */
   invoke(fn, self, locals, serviceName) {
     if (typeof locals === "string") {
@@ -112,7 +107,7 @@ class AbstractInjector {
       fn = fn[fn.length - 1];
     }
 
-    if (isClass(/** @type {string} */ (fn))) {
+    if (isClass(/** @type {Function} */ (fn))) {
       args.unshift(null);
       const res = new (Function.prototype.bind.apply(fn, args))();
       return res;
@@ -145,6 +140,7 @@ class AbstractInjector {
   /**
    * @abstract
    * @param {string} _serviceName
+   * @returns {any}
    */
   factory(_serviceName) {
     console.error(`Unhandled ${_serviceName}`);
@@ -153,7 +149,7 @@ class AbstractInjector {
 
 /**
  * Injector for providers
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class ProviderInjector extends AbstractInjector {
   /**
@@ -183,7 +179,7 @@ export class ProviderInjector extends AbstractInjector {
 
 /**
  * Injector for factories and services
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class InjectorService extends AbstractInjector {
   /**
@@ -197,6 +193,10 @@ export class InjectorService extends AbstractInjector {
     this.modules = this.providerInjector.modules;
   }
 
+  /**
+   * @param {string} serviceName
+   * @returns {*}
+   */
   factory(serviceName) {
     const provider = this.providerInjector.get(serviceName + providerSuffix);
     const res = this.invoke(provider.$get, provider, undefined, serviceName);
@@ -209,11 +209,11 @@ export class InjectorService extends AbstractInjector {
    * @returns {boolean}
    */
   has(name) {
-    const hasProvider = Object.prototype.hasOwnProperty.call(
+    const hasProvider = hasOwn(
       this.providerInjector.cache,
       name + providerSuffix,
     );
-    const hasCache = Object.prototype.hasOwnProperty.call(this.cache, name);
+    const hasCache = hasOwn(this.cache, name);
     return hasProvider || hasCache;
   }
 }
@@ -221,7 +221,7 @@ export class InjectorService extends AbstractInjector {
 // Helpers
 
 /**
- * @param {string} fn
+ * @param {Function} fn
  * @returns {string}
  */
 function stringifyFn(fn) {
@@ -229,7 +229,7 @@ function stringifyFn(fn) {
 }
 
 /**
- * @param {string} fn
+ * @param {Function} fn
  * @returns {Array<any>}
  */
 function extractArgs(fn) {
@@ -239,7 +239,7 @@ function extractArgs(fn) {
 }
 
 /**
- * @param {string} func
+ * @param {Function} func
  * @returns {boolean}
  */
 function isClass(func) {
@@ -267,8 +267,8 @@ function annotate(fn, strictDi, name) {
             name,
           );
         }
-        argDecl = extractArgs(/** @type {string} */ (fn));
-        argDecl[1].split(FN_ARG_SPLIT).forEach(function (arg) {
+        argDecl = extractArgs(fn);
+        argDecl[1].split(/,/).forEach(function (arg) {
           arg.replace(FN_ARG, function (_all, _underscore, name) {
             $inject.push(name);
           });

package/src/core/di/ng-module.js

@@ -1,3 +1,4 @@
+import { $injectTokens } from "../../injection-tokens.js";
 import {
   isFunction,
   isDefined,
@@ -6,7 +7,6 @@ import {
   assert,
 } from "../../shared/utils.js";
 
-export const PROVIDE_LITERAL = "$provide";
 export const INJECTOR_LITERAL = "$injector";
 export const COMPILE_LITERAL = "$compileProvider";
 export const ANIMATION_LITERAL = "$animateProvider";
@@ -33,13 +33,14 @@ export class NgModule {
     assert(isString(name), "name required");
     assert(Array.isArray(requires), "requires array required");
     /**
+     * Name of the current module.
      * @type {string}
-     * Name of the module.
      */
     this.name = name;
+
     /**
-     * Holds the list of modules which the injector will load before the current module is
-     * loaded.
+     * Array of module names that this module depends on.
+     * @type {string[]}
      */
     this.requires = requires;
 
@@ -82,7 +83,7 @@ export class NgModule {
    * @returns {NgModule}
    */
   value(name, object) {
-    this.invokeQueue.push([PROVIDE_LITERAL, "value", [name, object]]);
+    this.invokeQueue.push([$injectTokens.$provide, "value", [name, object]]);
     return this;
   }
 
@@ -92,7 +93,11 @@ export class NgModule {
    * @returns {NgModule}
    */
   constant(name, object) {
-    this.invokeQueue.unshift([PROVIDE_LITERAL, "constant", [name, object]]);
+    this.invokeQueue.unshift([
+      $injectTokens.$provide,
+      "constant",
+      [name, object],
+    ]);
     return this;
   }
 
@@ -138,7 +143,7 @@ export class NgModule {
       providerFunction.$$moduleName = name;
     }
     this.invokeQueue.push([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "factory",
       [name, providerFunction],
     ]);
@@ -155,7 +160,7 @@ export class NgModule {
       serviceFunction.$$moduleName = name;
     }
     this.invokeQueue.push([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "service",
       [name, serviceFunction],
     ]);
@@ -171,7 +176,11 @@ export class NgModule {
     if (providerType && isFunction(providerType)) {
       providerType.$$moduleName = name;
     }
-    this.invokeQueue.push([PROVIDE_LITERAL, "provider", [name, providerType]]);
+    this.invokeQueue.push([
+      $injectTokens.$provide,
+      "provider",
+      [name, providerType],
+    ]);
     return this;
   }
 
@@ -184,7 +193,11 @@ export class NgModule {
     if (decorFn && isFunction(decorFn)) {
       decorFn.$$moduleName = name;
     }
-    this.configBlocks.push([PROVIDE_LITERAL, "decorator", [name, decorFn]]);
+    this.configBlocks.push([
+      $injectTokens.$provide,
+      "decorator",
+      [name, decorFn],
+    ]);
     return this;
   }
 

package/src/core/di/ng-module.spec.js

@@ -1,12 +1,12 @@
 import {
   INJECTOR_LITERAL,
   NgModule,
-  PROVIDE_LITERAL,
   COMPILE_LITERAL,
   ANIMATION_LITERAL,
   FILTER_LITERAL,
   CONTROLLER_LITERAL,
-} from "./ng-module";
+} from "./ng-module.js";
+import { $injectTokens } from "../../injection-tokens.js";
 
 describe("NgModule", () => {
   /** @type {NgModule} */
@@ -36,7 +36,7 @@ describe("NgModule", () => {
     // when contants are registered
     ngModule.constant("aConstant", 42);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "constant",
       ["aConstant", 42],
     ]);
@@ -44,12 +44,12 @@ describe("NgModule", () => {
     // then they are prepended to invocation queue
     ngModule.constant("bConstant", 24);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "constant",
       ["bConstant", 24],
     ]);
     expect(ngModule.invokeQueue[1]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "constant",
       ["aConstant", 42],
     ]);
@@ -59,7 +59,7 @@ describe("NgModule", () => {
     // when value are registered
     ngModule.value("aValue", 42);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "value",
       ["aValue", 42],
     ]);
@@ -67,12 +67,12 @@ describe("NgModule", () => {
     // then are pushed to invocation queue
     ngModule.value("bValue", 24);
     expect(ngModule.invokeQueue[1]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "value",
       ["bValue", 24],
     ]);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "value",
       ["aValue", 42],
     ]);
@@ -120,13 +120,13 @@ describe("NgModule", () => {
   it("can store factories", () => {
     ngModule.factory("aFactory", a).factory("bFactory", b);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "factory",
       ["aFactory", a],
     ]);
 
     expect(ngModule.invokeQueue[1]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "factory",
       ["bFactory", b],
     ]);
@@ -139,13 +139,13 @@ describe("NgModule", () => {
   it("can store services", () => {
     ngModule.service("aService", a).service("bService", b);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "service",
       ["aService", a],
     ]);
 
     expect(ngModule.invokeQueue[1]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "service",
       ["bService", b],
     ]);
@@ -158,13 +158,13 @@ describe("NgModule", () => {
   it("can store providers", () => {
     ngModule.provider("aProvider", a).provider("bProvider", b);
     expect(ngModule.invokeQueue[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "provider",
       ["aProvider", a],
     ]);
 
     expect(ngModule.invokeQueue[1]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "provider",
       ["bProvider", b],
     ]);
@@ -177,13 +177,13 @@ describe("NgModule", () => {
   it("can store decorators", () => {
     ngModule.decorator("aDecorator", a).decorator("bDecorator", b);
     expect(ngModule.configBlocks[0]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "decorator",
       ["aDecorator", a],
     ]);
 
     expect(ngModule.configBlocks[1]).toEqual([
-      PROVIDE_LITERAL,
+      $injectTokens.$provide,
       "decorator",
       ["bDecorator", b],
     ]);

package/src/core/error-handler.ts

@@ -0,0 +1,7 @@
+/**
+ * A callback type for handling errors.
+ *
+ * @param exception - The exception associated with the error.
+ * @param [cause] - Optional information about the context in which the error was thrown.
+ */
+export type ErrorHandler = (exception: Error, cause?: string) => void;