@angular-wave/angular.ts 0.2.1 → 0.2.3

package/package.json

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

package/src/angular.spec.js

@@ -1970,7 +1970,7 @@ describe("angular", () => {
   describe("isElement", () => {
     it("should return a boolean value", () => {
       const element = $compile("<p>Hello, world!</p>")($rootScope);
-      const body = window.document.body;
+      const body = document.body;
       const expected = [
         false,
         false,

package/src/animations/animate.spec.js

@@ -6,7 +6,7 @@ import { createInjector } from "../di/injector";
 
 describe("$animate", () => {
   describe("without animation", () => {
-    let dummy = window.document.getElementById("dummy");
+    let dummy = document.getElementById("dummy");
     let element;
     let $compile;
     let $rootElement;

package/src/core/compile/attributes.js

@@ -13,7 +13,7 @@ import { ALIASED_ATTR } from "../../shared/constants";
 
 const $compileMinErr = minErr("$compile");
 const SIMPLE_ATTR_NAME = /^\w/;
-const specialAttrHolder = window.document.createElement("div");
+const specialAttrHolder = document.createElement("div");
 
 /**
  * @typedef {Object} AttributeLike

package/src/core/compile/compile.js

@@ -1679,7 +1679,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
               } else {
                 // We have transclusion slots,
                 // collect them up, compile them and store their transclusion functions
-                $template = window.document.createDocumentFragment();
+                $template = document.createDocumentFragment();
 
                 const slotMap = Object.create(null);
                 const filledSlots = Object.create(null);
@@ -1712,8 +1712,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
                   if (slotName) {
                     filledSlots[slotName] = true;
                     slots[slotName] =
-                      slots[slotName] ||
-                      window.document.createDocumentFragment();
+                      slots[slotName] || document.createDocumentFragment();
                     slots[slotName].appendChild(node);
                   } else {
                     $template.appendChild(node);
@@ -2462,12 +2461,17 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         }
       }
 
+      /**
+       * @param {string} type
+       * @param {string} template
+       * @returns
+       */
       function wrapTemplate(type, template) {
-        type = lowercase(type || "html");
+        type = (type || "html").toLowerCase();
         switch (type) {
           case "svg":
           case "math":
-            var wrapper = window.document.createElement("div");
+            var wrapper = document.createElement("div");
             wrapper.innerHTML = `<${type}>${template}</${type}>`;
             return wrapper.childNodes[0].childNodes;
           default:
@@ -2775,7 +2779,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         // - remove them from the DOM
         // - allow them to still be traversed with .nextSibling
         // - allow a single fragment.qSA to fetch all elements being removed
-        const fragment = window.document.createDocumentFragment();
+        const fragment = document.createDocumentFragment();
         for (i = 0; i < removeCount; i++) {
           fragment.appendChild(elementsToRemove[i]);
         }

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

@@ -25,12 +25,6 @@ function isHTMLElement(el) {
   return !!el.toString().match(/HTML/);
 }
 
-function supportsMathML() {
-  const d = document.createElement("div");
-  d.innerHTML = "<math></math>";
-  return !isUnknownElement(d.firstChild);
-}
-
 function getChildScopes(scope) {
   let children = [];
   if (!scope.$$childHead) {

package/src/core/controller/controller.js

@@ -2,10 +2,8 @@ import {
   assertArgFn,
   assertNotHasOwnProperty,
   minErr,
-  extend,
   isObject,
   isString,
-  getter,
   isFunction,
 } from "../../shared/utils";
 
@@ -27,98 +25,72 @@ export function identifierForController(controller, ident) {
  * This provider allows controller registration via the
  * {@link ng.$controllerProvider#register register} method.
  */
-export function $ControllerProvider() {
-  const controllers = {};
+export class $ControllerProvider {
+  constructor() {
+    /**
+     * @type {Map<string, Function|Object>}
+     * @private
+     */
+    this.controllers = new Map();
+  }
 
   /**
+   * Check if a controller with a given name exists.
+   *
    * @param {string} name Controller name to check.
+   * @returns {boolean} True if the controller exists, false otherwise.
    */
-  this.has = function (name) {
-    return Object.prototype.hasOwnProperty.call(controllers, name);
-  };
+  has(name) {
+    return this.controllers.has(name);
+  }
 
   /**
+   * Register a controller.
+   *
    * @param {string|Object} name Controller name, or an object map of controllers where the keys are
    *    the names and the values are the constructors.
-   * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
+   * @param {Function|Array} constructor Controller constructor function (optionally decorated with DI
    *    annotations in the array notation).
    */
-  this.register = function (name, constructor) {
+  register(name, constructor) {
     assertNotHasOwnProperty(name, "controller");
     if (isObject(name)) {
-      extend(controllers, name);
+      Object.entries(name).forEach(([key, value]) => {
+        this.controllers.set(key, value);
+      });
     } else {
-      controllers[name] = constructor;
+      this.controllers.set(name, constructor);
     }
-  };
+  }
 
-  this.$get = [
+  /**
+   * $get method for dependency injection.
+   *
+   * @param {import("../../core/di/internal-injector").InjectorService} $injector
+   * @returns {Function} A service function that creates controllers.
+   */
+  $get = [
     "$injector",
-    /**
-     *
-     * @param {import("../../core/di/internal-injector").InjectorService} $injector
-     * @returns
-     */
-    function ($injector) {
-      /**
-       * @param {Function|string} expression If called with a function then it's considered to be the
-       *    controller constructor function. Otherwise it's considered to be a string which is used
-       *    to retrieve the controller constructor using the following steps:
-       *
-       *    * check if a controller with given name is registered via `$controllerProvider`
-       *    * check if evaluating the string on the current scope returns a constructor
-       *
-       *    The string can use the `controller as property` syntax, where the controller instance is published
-       *    as the specified property on the `scope`; the `scope` must be injected into `locals` param for this
-       *    to work correctly.
-       *
-       * @param {Object} locals Injection locals for Controller.
-       * @return {Object} Instance of given controller.
-       *
-       * @description
-       * `$controller` service is responsible for instantiating controllers.
-       *
-       * It's just a simple call to {@link auto.$injector $injector}, but extracted into
-       * a service, so that one can override this service with [BC version](https://gist.github.com/1649788).
-       */
-      return function $controller(expression, locals, later, ident) {
-        // PRIVATE API:
-        //   param `later` --- indicates that the controller's constructor is invoked at a later time.
-        //                     If true, $controller will allocate the object with the correct
-        //                     prototype chain, but will not invoke the controller until a returned
-        //                     callback is invoked.
-        //   param `ident` --- An optional label which overrides the label parsed from the controller
-        //                     expression, if any.
+    ($injector) => {
+      return (expression, locals, later, ident) => {
         let instance;
-
-        /** @type { RegExpMatchArray | null} */
         let match;
-
         let constructor;
-        let identifier;
+        let identifier = ident && isString(ident) ? ident : null;
         later = later === true;
-        if (ident && isString(ident)) {
-          identifier = ident;
-        }
 
         if (isString(expression)) {
-          match = /** @type {string} */ (expression).match(CNTRL_REG);
+          match = expression.match(CNTRL_REG);
           if (!match) {
             throw $controllerMinErr(
               "ctrlfmt",
-              "Badly formed controller string '{0}'. " +
-                "Must match `__name__ as __id__` or `__name__`.",
+              "Badly formed controller string '{0}'. Must match `__name__ as __id__` or `__name__`.",
               expression,
             );
           }
           constructor = match[1];
           identifier = identifier || match[3];
-          expression = Object.prototype.hasOwnProperty.call(
-            controllers,
-            constructor,
-          )
-            ? controllers[constructor]
-            : getter(locals.$scope, constructor, true);
+          expression = this.controllers.get(constructor);
 
           if (!expression) {
             throw $controllerMinErr(
@@ -132,16 +104,6 @@ export function $ControllerProvider() {
         }
 
         if (later) {
-          // Instantiate controller later:
-          // This machinery is used to create an instance of the object before calling the
-          // controller's constructor itself.
-          //
-          // This allows properties to be added to the controller before the constructor is
-          // invoked. Primarily, this is used for isolate scope bindings in $compile.
-          //
-          // This feature is not intended for use by applications, and is thus not documented
-          // publicly.
-          // Object creation: http://jsperf.com/create-constructor/2
           const controllerPrototype = (
             Array.isArray(expression)
               ? expression[expression.length - 1]
@@ -150,82 +112,74 @@ export function $ControllerProvider() {
           instance = Object.create(controllerPrototype || null);
 
           if (identifier) {
-            addIdentifier(
+            this.addIdentifier(
               locals,
               identifier,
               instance,
-              constructor ||
-                /** @type {import("../../types").Controller} */ (expression)
-                  .name,
+              constructor || expression.name,
             );
           }
 
-          return extend(
-            () => {
-              const result = $injector.invoke(
-                expression,
-                instance,
-                locals,
-                constructor,
-              );
-              if (
-                result !== instance &&
-                (isObject(result) || isFunction(result))
-              ) {
-                instance = result;
-                if (identifier) {
-                  // If result changed, re-assign controllerAs value to scope.
-                  addIdentifier(
-                    locals,
-                    identifier,
-                    instance,
-                    constructor ||
-                      /** @type {import("../../types").Controller} */ (
-                        expression
-                      ).name,
-                  );
-                }
-              }
-              return instance;
-            },
-            {
+          return function () {
+            const result = $injector.invoke(
+              expression,
               instance,
-              identifier,
-            },
-          );
+              locals,
+              constructor,
+            );
+
+            if (
+              result !== instance &&
+              (isObject(result) || isFunction(result))
+            ) {
+              instance = result;
+              if (identifier) {
+                this.addIdentifier(
+                  locals,
+                  identifier,
+                  instance,
+                  constructor || expression.name,
+                );
+              }
+            }
+
+            return instance;
+          }.bind(this, { instance, identifier });
         }
 
-        instance = $injector.instantiate(
-          /** @type {Function} */ (expression),
-          locals,
-          constructor,
-        );
+        instance = $injector.instantiate(expression, locals, constructor);
 
         if (identifier) {
-          addIdentifier(
+          this.addIdentifier(
             locals,
             identifier,
             instance,
-            constructor ||
-              /** @type {import("../../types").Controller} */ (expression).name,
+            constructor || expression.name,
           );
         }
 
         return instance;
       };
-
-      function addIdentifier(locals, identifier, instance, name) {
-        if (!(locals && isObject(locals.$scope))) {
-          throw minErr("$controller")(
-            "noscp",
-            "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.",
-            name,
-            identifier,
-          );
-        }
-
-        locals.$scope[identifier] = instance;
-      }
     },
   ];
+
+  /**
+   * Adds an identifier to the controller instance in the given locals' scope.
+   *
+   * @param {Object} locals The locals object containing the scope.
+   * @param {string} identifier The identifier to assign.
+   * @param {Object} instance The controller instance.
+   * @param {string} name The name of the controller.
+   */
+  addIdentifier(locals, identifier, instance, name) {
+    if (!(locals && isObject(locals.$scope))) {
+      throw minErr("$controller")(
+        "noscp",
+        "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.",
+        name,
+        identifier,
+      );
+    }
+    locals.$scope[identifier] = instance;
+  }
 }

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

@@ -30,7 +30,7 @@ class AbstractInjector {
   /**
    * Get a service by name.
    *
-   * @param {String} serviceName
+   * @param {string} serviceName
    * @returns {any}
    */
   get(serviceName) {
@@ -63,7 +63,7 @@ class AbstractInjector {
    *
    * @param {Function|Array} fn
    * @param {Object} locals
-   * @param {String} serviceName
+   * @param {string} serviceName
    * @returns
    */
   injectionArgs(fn, locals, serviceName) {
@@ -94,7 +94,7 @@ class AbstractInjector {
    * @param {Function|String|Array<any>} fn
    * @param {*} [self]
    * @param {Object} [locals]
-   * @param {String} [serviceName]
+   * @param {string} [serviceName]
    * @returns
    */
   invoke(fn, self, locals, serviceName) {
@@ -112,7 +112,7 @@ class AbstractInjector {
       fn = fn[fn.length - 1];
     }
 
-    if (isClass(/** @type {String} */ (fn))) {
+    if (isClass(/** @type {string} */ (fn))) {
       args.unshift(null);
       return new (Function.prototype.bind.apply(fn, args))();
     } else {
@@ -124,7 +124,7 @@ class AbstractInjector {
    * Instantiate a type constructor with optional locals.
    * @param {Function|Array} type
    * @param {*} [locals]
-   * @param {String} [serviceName]
+   * @param {string} [serviceName]
    */
   instantiate(type, locals, serviceName) {
     // Check if type is annotated and use just the given function at n-1 as parameter
@@ -143,7 +143,7 @@ class AbstractInjector {
 
   /**
    * @abstract
-   * @param {String} _serviceName
+   * @param {string} _serviceName
    */
   factory(_serviceName) {
     console.error(`Unhandled ${_serviceName}`);
@@ -166,7 +166,7 @@ export class ProviderInjector extends AbstractInjector {
 
   /**
    * Factory method for creating services.
-   * @param {String} caller - The name of the caller requesting the service.
+   * @param {string} caller - The name of the caller requesting the service.
    * @throws {Error} If the provider is unknown.
    */
   factory(caller) {
@@ -204,7 +204,7 @@ export class InjectorService extends AbstractInjector {
 
   /**
    *
-   * @param {String} name
+   * @param {string} name
    * @returns {boolean}
    */
   has(name) {
@@ -220,15 +220,15 @@ export class InjectorService extends AbstractInjector {
 // Helpers
 
 /**
- * @param {String} fn
- * @returns {String}
+ * @param {string} fn
+ * @returns {string}
  */
 function stringifyFn(fn) {
   return Function.prototype.toString.call(fn);
 }
 
 /**
- * @param {String} fn
+ * @param {string} fn
  * @returns {Array<any>}
  */
 function extractArgs(fn) {
@@ -238,7 +238,7 @@ function extractArgs(fn) {
 }
 
 /**
- * @param {String} func
+ * @param {string} func
  * @returns {boolean}
  */
 function isClass(func) {
@@ -249,7 +249,7 @@ function isClass(func) {
  *
  * @param {any} fn
  * @param {boolean} strictDi
- * @param {String} name
+ * @param {string} name
  * @returns {Array<string>}
  */
 function annotate(fn, strictDi, name) {
@@ -266,7 +266,7 @@ function annotate(fn, strictDi, name) {
             name,
           );
         }
-        argDecl = extractArgs(/** @type {String} */ (fn));
+        argDecl = extractArgs(/** @type {string} */ (fn));
         argDecl[1].split(FN_ARG_SPLIT).forEach(function (arg) {
           arg.replace(FN_ARG, function (_all, _underscore, name) {
             $inject.push(name);

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

@@ -25,8 +25,8 @@ export const CONTROLLER_LITERAL = "$controllerProvider";
  */
 export class NgModule {
   /**
-   * @param {String} name - Name of the module
-   * @param {Array<String>} requires - List of modules which the injector will load before the current module
+   * @param {string} name - Name of the module
+   * @param {Array<string>} requires - List of modules which the injector will load before the current module
    * @param {Function} [configFn]
    */
   constructor(name, requires, configFn) {

package/src/core/filter/filter.md

@@ -97,7 +97,7 @@
 - @example
   <example name="$filter" module="filterExample">
   <file name="index.html">
-  <div ng-controller="MainCtrl">
+  <div ng-controller="MainCtrl">`
   <h3>{{ originalText }}</h3>
   <h3>{{ filteredText }}</h3>
   </div>

package/src/core/location/location.spec.js

@@ -1796,7 +1796,7 @@ describe("$location", () => {
 
   //   afterEach(() => {
   //     dealoc(root);
-  //     dealoc(window.document.body);
+  //     dealoc(document.body);
   //   });
 
   //   it("should rewrite rel link to new url when history enabled on new browser", () => {
@@ -2303,7 +2303,7 @@ describe("$location", () => {
   //       }),
   //       setupRewriteChecks(),
   //       ($browser) => {
-  //         const rightClick = window.document.createEvent("MouseEvents");
+  //         const rightClick = document.createEvent("MouseEvents");
   //         rightClick.initMouseEvent(
   //           "click",
   //           true,
@@ -2441,12 +2441,12 @@ describe("$location", () => {
   //     });
   //     inject(($location) => {
   //       // make IE happy
-  //       JQLite(window.document.body).html(
+  //       JQLite(document.body).html(
   //         '<a href="http://server/test.html">link</a>',
   //       );
 
   //       const event = {
-  //         target: JQLite(window.document.body).find("a")[0],
+  //         target: JQLite(document.body).find("a")[0],
   //         preventDefault: jasmine.createSpy("preventDefault"),
   //         isDefaultPrevented: jasmine.createSpy().and.returnValue(false),
   //       };
@@ -2481,12 +2481,12 @@ describe("$location", () => {
   //         $location,
   //       ) => {
   //         // make IE happy
-  //         JQLite(window.document.body).html(
+  //         JQLite(document.body).html(
   //           '<a href="http://server/index.html#test">link</a>',
   //         );
 
   //         const event = {
-  //           target: JQLite(window.document.body).find("a")[0],
+  //           target: JQLite(document.body).find("a")[0],
   //           preventDefault: jasmine.createSpy("preventDefault"),
   //           isDefaultPrevented: jasmine.createSpy().and.returnValue(false),
   //         };
@@ -2920,7 +2920,7 @@ describe("$location", () => {
   //         function ($rootElement, $compile, $rootScope) {
   //           $rootElement.html('<a href="http://server/#!/somePath">link</a>');
   //           $compile($rootElement)($rootScope);
-  //           JQLite(window.document.body).append($rootElement);
+  //           JQLite(document.body).append($rootElement);
   //         },
   //     );
 
@@ -2951,7 +2951,7 @@ describe("$location", () => {
   //       return function ($rootElement, $compile, $rootScope) {
   //         $rootElement.html('<a href="http://server/somePath">link</a>');
   //         $compile($rootElement)($rootScope);
-  //         JQLite(window.document.body).append($rootElement);
+  //         JQLite(document.body).append($rootElement);
   //       };
   //     });
 
@@ -3313,7 +3313,7 @@ describe("$location", () => {
   // function mockUpBrowser(options) {
   //   module(($windowProvider, $browserProvider) => {
   //     let browser;
-  //     const parser = window.document.createElement("a");
+  //     const parser = document.createElement("a");
   //     parser.href = options.initialUrl;
 
   //     $windowProvider.$get = function () {

package/src/core/sanitize/sanitize-uri.spec.js

@@ -19,7 +19,7 @@ describe("sanitizeUri", () => {
   });
 
   function isEvilInCurrentBrowser(uri) {
-    const a = window.document.createElement("a");
+    const a = document.createElement("a");
     a.setAttribute("href", uri);
     return a.href.substring(0, 4) !== "http";
   }

package/src/core/sce/sce.spec.js

@@ -522,16 +522,16 @@ describe("SCE", () => {
 
         let baseElem;
         beforeEach(() => {
-          baseElem = window.document.createElement("BASE");
+          baseElem = document.createElement("BASE");
           baseElem.setAttribute(
             "href",
             `${window.location.protocol}//foo.example.com/path/`,
           );
-          window.document.head.appendChild(baseElem);
+          document.head.appendChild(baseElem);
         });
 
         afterEach(() => {
-          window.document.head.removeChild(baseElem);
+          document.head.removeChild(baseElem);
         });
 
         it("should allow relative URLs", () => {

package/src/core/scope/scope.spec.js

@@ -1095,7 +1095,7 @@ describe("Scope", function () {
 
           it("should watch array-like objects like arrays", () => {
             logs = [];
-            $rootScope.obj = window.document.getElementsByTagName("src");
+            $rootScope.obj = document.getElementsByTagName("src");
             $rootScope.$digest();
 
             expect(logs.length).toBeTruthy();

package/src/core/url-utils/url-utils.js

@@ -5,7 +5,7 @@ import { isString } from "../../shared/utils";
  * @typedef {"http"|"https"} HttpProtocol
  */
 
-const urlParsingNode = window.document.createElement("a");
+const urlParsingNode = document.createElement("a");
 const originUrl = urlResolve(window.location.href);
 let baseUrlParsingNode;
 
@@ -126,13 +126,13 @@ export function urlsAreSameOrigin(url1, url2) {
  * @returns {string}
  */
 export function getBaseUrl() {
-  if (window.document.baseURI) {
-    return window.document.baseURI;
+  if (document.baseURI) {
+    return document.baseURI;
   }
 
   // `document.baseURI` is available everywhere except IE
   if (!baseUrlParsingNode) {
-    baseUrlParsingNode = window.document.createElement("a");
+    baseUrlParsingNode = document.createElement("a");
     baseUrlParsingNode.href = ".";
 
     // Work-around for IE bug described in Implementation Notes. The fix in `urlResolve()` is not