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

package/src/core/compile/compile.md

@@ -119,7 +119,7 @@
 
 -
 - ### Life-cycle hooks
-- Directive controllers can provide the following methods that are called by AngularJS at points in the life-cycle of the
+- Directive controllers can provide the following methods that are called by AngularTS at points in the life-cycle of the
 - directive.The following hooks can be defined on the controller prototype or added to the controller inside its constructor:
 - - `$onInit()` - Called on each controller after all the controllers on an element have been constructed and
 - had their bindings initialized (and before the pre & post linking functions for the directives on
@@ -383,7 +383,7 @@
 -
 - #### `templateNamespace`
 - String representing the document type used by the markup in the template.
-- AngularJS needs this information as those elements need to be created and cloned
+- AngularTS needs this information as those elements need to be created and cloned
 - in a special way when they are defined outside their usual containers like `<svg>` and `<math>`.
 -
 - - `html` - All root nodes in the template are HTML. Root nodes may also be
@@ -427,7 +427,7 @@
 -
 - #### `replace`
 - <div class="alert alert-danger">
-- **Note:** `replace` is deprecated in AngularJS and has been removed in the new Angular (v2+).
+- **Note:** `replace` is deprecated in AngularTS and has been removed in the new Angular (v2+).
 - </div>
 -
 - Specifies what the template should replace. Defaults to `false`.
@@ -570,7 +570,7 @@
 - ### Transclusion
 -
 - Transclusion is the process of extracting a collection of DOM elements from one part of the DOM and
-- copying them to another part of the DOM, while maintaining their connection to the original AngularJS
+- copying them to another part of the DOM, while maintaining their connection to the original AngularTS
 - scope from where they were taken.
 -
 - Transclusion is used (often with {@link ngTransclude}) to insert the
@@ -816,7 +816,7 @@
 - element passed in, or the clone of the element if the `cloneAttachFn` is provided.
 -
 - After linking the view is not updated until after a call to `$digest`, which typically is done by
-- AngularJS automatically.
+- AngularTS automatically.
 -
 - If you need access to the bound view, there are two ways to do it:
 -
@@ -856,7 +856,7 @@
 -
 -
 - For information on how the compiler works, see the
-- {@link guide/compiler AngularJS HTML Compiler} section of the Developer Guide.
+- {@link guide/compiler AngularTS HTML Compiler} section of the Developer Guide.
 -
 - @knownIssue
 -
@@ -893,7 +893,7 @@
   ```
 
 -
-- That means attributes that contain AngularJS expressions will not be merged correctly, e.g.
+- That means attributes that contain AngularTS expressions will not be merged correctly, e.g.
 - {@link ngShow} or {@link ngClass} will cause a {@link $parse} error:
 -
 - ```html
@@ -974,7 +974,7 @@
 - the property name in the attribute, e.g. `ng-prop-value="'my value'"` binds 'my value' to
 - the `value` property.
 -
-- Usually, it's not necessary to write to properties in AngularJS, as the built-in directives
+- Usually, it's not necessary to write to properties in AngularTS, as the built-in directives
 - handle the most common use cases (instead of the above example, you would use {@link ngValue}).
 -
 - However, [custom elements](https://developer.mozilla.org/docs/Web/Web_Components/Using_custom_elements)
@@ -984,7 +984,7 @@
 - ## Binding to camelCase properties
 -
 - Since HTML attributes are case-insensitive, camelCase properties like `innerHTML` must be escaped.
-- AngularJS uses the underscore (\_) in front of a character to indicate that it is uppercase, so
+- AngularTS uses the underscore (\_) in front of a character to indicate that it is uppercase, so
 - `innerHTML` must be written as `ng-prop-inner_h_t_m_l="expression"` (Note that this is just an
 - example, and for binding HTML {@link ngBindHtml} should be used.
 -
@@ -1063,8 +1063,8 @@
 - the event name in the attribute, e.g. `ng-on-drop="onDrop()"` executes the 'onDrop()' expression
 - when the `drop` event is fired.
 -
-- AngularJS provides specific directives for many events, such as {@link ngClick}, so in most
-- cases it is not necessary to use `ngOn`. However, AngularJS does not support all events
+- AngularTS provides specific directives for many events, such as {@link ngClick}, so in most
+- cases it is not necessary to use `ngOn`. However, AngularTS does not support all events
 - (e.g. the `drop` event in the example above), and new events might be introduced in later DOM
 - standards.
 -
@@ -1076,7 +1076,7 @@
 - ## Binding to camelCase properties
 -
 - Since HTML attributes are case-insensitive, camelCase properties like `myEvent` must be escaped.
-- AngularJS uses the underscore (\_) in front of a character to indicate that it is uppercase, so
+- AngularTS uses the underscore (\_) in front of a character to indicate that it is uppercase, so
 - `myEvent` must be written as `ng-on-my_event="expression"`.
 -
 - \*/
@@ -1089,7 +1089,7 @@
 - @description
 - A shared object between directive compile / linking functions which contains normalized DOM
 - element attributes. The values reflect current binding state `{{ }}`. The normalization is
-- needed since all of these are treated as equivalent in AngularJS:
+- needed since all of these are treated as equivalent in AngularTS:
 -
 - ```
 

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

@@ -8546,80 +8546,6 @@ describe("$compile", () => {
           ]);
         });
 
-        // LEAK
-        xit("should throw an error if `$onChanges()` hooks are not stable", async () => {
-          function TestController() {}
-          TestController.prototype.$onChanges = function (change) {
-            this.onChange();
-          };
-
-          module
-            .decorator("$exceptionHandler", () => {
-              return (exception) => {
-                throw new Error(exception.message);
-              };
-            })
-            .component("c1", {
-              controller: TestController,
-              bindings: { prop: "<", onChange: "&" },
-            });
-
-          createInjector(["test1"]).invoke((_$compile_, _$rootScope_) => {
-            $compile = _$compile_;
-            $rootScope = _$rootScope_;
-          });
-          // Setup the directive with bindings that will keep updating the bound value forever
-          element = $compile('<c1 prop="a" on-change="a = -a"></c1>')(
-            $rootScope,
-          );
-          await wait();
-          // Update val to trigger the unstable onChanges, which will result in an error
-          expect(async () => {
-            $rootScope.$apply("a = 42");
-            await wait();
-          }).toThrowError(/infchng/);
-
-          dealoc(element);
-          element = $compile('<c1 prop="b" on-change=""></c1>')($rootScope);
-          await wait();
-          $rootScope.$apply("b = 24");
-          $rootScope.$apply("b = 48");
-        });
-
-        // LEAK
-        xit("should log an error if `$onChanges()` hooks are not stable", async () => {
-          function TestController() {}
-          TestController.prototype.$onChanges = function (change) {
-            this.onChange();
-          };
-
-          module
-            .decorator("$exceptionHandler", () => {
-              return (exception) => {
-                log.push(exception.message);
-              };
-            })
-            .component("c1", {
-              controller: TestController,
-              bindings: { prop: "<", onChange: "&" },
-            });
-
-          createInjector(["test1"]).invoke((_$compile_, _$rootScope_) => {
-            $compile = _$compile_;
-            $rootScope = _$rootScope_;
-          });
-          // Setup the directive with bindings that will keep updating the bound value forever
-          element = $compile('<c1 prop="a" on-change="a = -a"></c1>')(
-            $rootScope,
-          );
-          await wait();
-          // Update val to trigger the unstable onChanges, which will result in an error
-          $rootScope.$apply("a = 42");
-          await wait();
-          expect(log.length).toEqual(1);
-          expect(log[0].match(/infchng/)).toBeTruthy();
-        });
-
         it("should continue to trigger other `$onChanges` hooks if one throws an error", async () => {
           function ThrowingController() {
             this.$onChanges = function (change) {
@@ -9463,35 +9389,26 @@ describe("$compile", () => {
             ]);
           });
 
-          xit("should update isolate again after $onInit if outer object reference changes even if equal", () => {
+          it("should update isolate again after $onInit if outer object reference changes even if equal", async () => {
             $rootScope.name = ["outer"];
             $compile('<ow-component input="name"></ow-component>')($rootScope);
-
+            await wait();
             expect($rootScope.name).toEqual(["outer"]);
             expect(component.input).toEqual("$onInit");
 
             $rootScope.name = ["outer"];
+            await wait();
             expect($rootScope.name).toEqual(["outer"]);
             expect(component.input).toEqual(["outer"]);
-
             expect(log).toEqual([
               "constructor",
-              [
-                "$onChanges",
-                jasmine.objectContaining({ currentValue: ["outer"] }),
-              ],
+              ["$onChanges", "outer"],
               "$onInit",
-              [
-                "$onChanges",
-                jasmine.objectContaining({
-                  previousValue: ["outer"],
-                  currentValue: ["outer"],
-                }),
-              ],
+              ["$onChanges", "outer"],
             ]);
           });
 
-          xit("should not update isolate again after $onInit if outer is a literal", () => {
+          it("should not update isolate again after $onInit if outer is a literal", async () => {
             $rootScope.name = "outer";
             $compile('<ow-component input="[name]"></ow-component>')(
               $rootScope,
@@ -9499,28 +9416,11 @@ describe("$compile", () => {
 
             expect(component.input).toEqual("$onInit");
 
-            // No outer change
-            $rootScope.$apply('name = "outer"');
-            expect(component.input).toEqual("$onInit");
-
             // Outer change
             $rootScope.$apply('name = "re-outer"');
+            await wait();
             expect(component.input).toEqual(["re-outer"]);
-
-            expect(log).toEqual([
-              "constructor",
-              [
-                "$onChanges",
-                jasmine.objectContaining({ currentValue: ["outer"] }),
-              ],
-              "$onInit",
-              [
-                "$onChanges",
-                jasmine.objectContaining({
-                  currentValue: ["re-outer"],
-                }),
-              ],
-            ]);
+            expect(log).toEqual(["constructor", "$onInit"]);
           });
 
           xit("should update isolate again after $onInit if outer has changed (before initial watchAction call)", () => {

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/di/injector.js

@@ -36,6 +36,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 +78,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 +108,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 +130,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 +144,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 +309,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);
@@ -23,7 +22,7 @@ class AbstractInjector {
     /** @type {boolean} */
     this.strictDi = strictDi;
     this.path = [];
-    /** @type {Object.<string, import("../../types").Module>} */
+    /** @type {Object.<string, import("./ng-module.js").NgModule>} */
     this.modules = {};
   }
 
@@ -34,7 +33,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 +47,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 +77,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 +89,7 @@ class AbstractInjector {
    * @param {*} [self]
    * @param {Object} [locals]
    * @param {string} [serviceName]
-   * @returns
+   * @returns {*}
    */
   invoke(fn, self, locals, serviceName) {
     if (typeof locals === "string") {
@@ -112,7 +106,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;
@@ -153,7 +147,7 @@ class AbstractInjector {
 
 /**
  * Injector for providers
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class ProviderInjector extends AbstractInjector {
   /**
@@ -183,7 +177,7 @@ export class ProviderInjector extends AbstractInjector {
 
 /**
  * Injector for factories and services
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class InjectorService extends AbstractInjector {
   /**
@@ -197,6 +191,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 +207,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 +219,7 @@ export class InjectorService extends AbstractInjector {
 // Helpers
 
 /**
- * @param {string} fn
+ * @param {Function} fn
  * @returns {string}
  */
 function stringifyFn(fn) {
@@ -229,7 +227,7 @@ function stringifyFn(fn) {
 }
 
 /**
- * @param {string} fn
+ * @param {Function} fn
  * @returns {Array<any>}
  */
 function extractArgs(fn) {
@@ -239,7 +237,7 @@ function extractArgs(fn) {
 }
 
 /**
- * @param {string} func
+ * @param {Function} func
  * @returns {boolean}
  */
 function isClass(func) {
@@ -267,8 +265,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

@@ -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;
 

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;

package/src/core/exception-handler.js

@@ -1,5 +1,5 @@
 /**
- * Handles uncaught exceptions thrown in AngularJS expressions.
+ * Handles uncaught exceptions thrown in AngularTS expressions.
  *
  * By default, this service delegates to `$log.error()`, logging the exception to the browser console.
  * You can override this behavior to provide custom exception handling—such as reporting errors
@@ -7,7 +7,7 @@
  *
  * ## Default Behavior
  *
- * Uncaught exceptions within AngularJS expressions are intercepted and passed to this service.
+ * Uncaught exceptions within AngularTS expressions are intercepted and passed to this service.
  * The default implementation logs the error using `$log.error(exception, cause)`.
  *
  * ## Custom Implementation
@@ -39,17 +39,12 @@
  * }
  * ```
  *
- * @see {@link angular.ErrorHandler AngularJS ErrorHandler}
+ * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
 
 /** @typedef {import('../services/log').LogService} LogService */
 
-/**
- * @callback ErrorHandler
- * @param {Error} exception - Exception associated with the error.
- * @param {string} [cause] - Optional information about the context in which the error was thrown.
- * @returns {void}
- */
+/** @typedef {import("./error-handler.ts").ErrorHandler }  ErrorHandler */
 
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.

package/src/core/filter/filter.js

@@ -6,29 +6,38 @@ import { orderByFilter } from "../../filters/order-by.js";
 import {
   $IncludedByStateFilter,
   $IsStateFilter,
-} from "../../router/state-filters";
+} from "../../router/state-filters.js";
 
 FilterProvider.$inject = ["$provide"];
+
+/**
+ * @param {import('../../interface.ts').Provider} $provide
+ */
 export function FilterProvider($provide) {
   const suffix = "Filter";
 
+  /**
+   * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
+   * @param {import('../../interface.ts').FilterFactory} factory
+   * @return {import('../../interface.ts').ServiceProvider}
+   */
   function register(name, factory) {
     if (isObject(name)) {
       const filters = {};
       Object.entries(name).forEach(([key, filter]) => {
         filters[key] = register(key, filter);
       });
-      return filters;
     }
     return $provide.factory(name + suffix, factory);
   }
+
   this.register = register;
 
   this.$get = [
     "$injector",
     /**
      *
-     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
      * @returns
      */
     function ($injector) {