@angular-wave/angular.ts 0.2.0 → 0.2.2

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.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

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/router/resolve/resolvable.js

@@ -48,6 +48,7 @@ export class Resolvable {
       this.data = arg1.data;
     }
   }
+
   getPolicy(state) {
     const thisPolicy = this.policy || {};
     const statePolicy = (state && state.resolvePolicy) || {};
@@ -57,6 +58,7 @@ export class Resolvable {
         thisPolicy.async || statePolicy.async || defaultResolvePolicy.async,
     };
   }
+
   /**
    * Asynchronously resolve this Resolvable's data
    *
@@ -105,9 +107,11 @@ export class Resolvable {
   get(resolveContext, trans) {
     return this.promise || this.resolve(resolveContext, trans);
   }
+
   toString() {
     return `Resolvable(token: ${stringify(this.token)}, requires: [${this.deps.map(stringify)}])`;
   }
+
   clone() {
     return new Resolvable(this);
   }

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

@@ -56,11 +56,13 @@ export class ResolveContext {
       .filter((r) => r.token === token);
     return tail(matching);
   }
+
   /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
   getPolicy(resolvable) {
     const node = this.findNode(resolvable);
     return resolvable.getPolicy(node);
   }
+
   /**
    * Returns a ResolveContext that includes a portion of this one
    *
@@ -101,7 +103,7 @@ export class ResolveContext {
    *
    * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
    *
-   * @param newResolvables the new Resolvables
+   * @param {Resolvable[]} newResolvables the new Resolvables
    * @param state Used to find the node to put the resolvable on
    */
   addResolvables(newResolvables, state) {
@@ -115,9 +117,9 @@ export class ResolveContext {
   /**
    * Returns a promise for an array of resolved path Element promises
    *
-   * @param when
+   * @param {string} when
    * @param trans
-   * @returns {Promise<any>|any}
+   * @returns {import("../../core/q/q").QPromise<any>|any}
    */
   resolvePath(when = "LAZY", trans) {
     // This option determines which 'when' policy Resolvables we are about to fetch.
@@ -153,16 +155,21 @@ export class ResolveContext {
     // Wait for all the "WAIT" resolvables
     return services.$q.all(promises);
   }
+
   injector() {
     return this._injector || (this._injector = new UIInjectorImpl());
   }
+
   findNode(resolvable) {
     return find(this._path, (node) => node.resolvables.includes(resolvable));
   }
+
   /**
    * Gets the async dependencies of a Resolvable
    *
    * Given a Resolvable, returns its dependencies as a Resolvable[]
+   * @param {Resolvable} resolvable
+   * @returns {Resolvable[]}
    */
   getDependencies(resolvable) {
     const node = this.findNode(resolvable);
@@ -173,7 +180,7 @@ export class ResolveContext {
     const availableResolvables = subPath
       .reduce((acc, _node) => acc.concat(_node.resolvables), []) // all of subpath's resolvables
       .filter((res) => res !== resolvable); // filter out the `resolvable` argument
-    const getDependency = (token) => {
+    return resolvable.deps.map((token) => {
       const matching = availableResolvables.filter((r) => r.token === token);
       if (matching.length) return tail(matching);
       const fromInjector = services.$injector.get(token);
@@ -183,8 +190,7 @@ export class ResolveContext {
         );
       }
       return new Resolvable(token, () => fromInjector, [], fromInjector);
-    };
-    return resolvable.deps.map(getDependency);
+    });
   }
 }
 

package/src/router/state/state-builder.js

@@ -1,10 +1,10 @@
 import {
   applyPairs,
   inherit,
-  mapObj,
   omit,
   tail,
   copy,
+  map,
 } from "../../shared/common";
 import { isDefined, isFunction, isString } from "../../shared/utils";
 import { stringify } from "../../shared/strings";
@@ -12,24 +12,27 @@ import { is, pattern, pipe, prop, val } from "../../shared/hof";
 import { Resolvable } from "../resolve/resolvable";
 import { services } from "../common/coreservices";
 import { annotate } from "../../core/di/injector";
-const parseUrl = (url) => {
+
+function parseUrl(url) {
   if (!isString(url)) return false;
   const root = url.charAt(0) === "^";
   return { val: root ? url.substring(1) : url, root };
-};
+}
 
 function selfBuilder(state) {
   state.self.$$state = () => state;
   return state.self;
 }
+
 function dataBuilder(state) {
   if (state.parent && state.parent.data) {
     state.data = state.self.data = inherit(state.parent.data, state.data);
   }
   return state.data;
 }
-const getUrlBuilder = ($urlService, root) =>
-  function urlBuilder(stateObject) {
+
+function getUrlBuilder($urlService, root) {
+  return function (stateObject) {
     let stateDec = stateObject.self;
     // For future states, i.e., states whose name ends with `.**`,
     // match anything that starts with the url prefix
@@ -56,31 +59,34 @@ const getUrlBuilder = ($urlService, root) =>
       ? url
       : ((parent && parent.navigable) || root()).url.append(url);
   };
-const getNavigableBuilder = (isRoot) =>
-  function navigableBuilder(state) {
+}
+
+function getNavigableBuilder(isRoot) {
+  return function (state) {
     return !isRoot(state) && state.url
       ? state
       : state.parent
         ? state.parent.navigable
         : null;
   };
-const getParamsBuilder = (paramFactory) =>
-  function paramsBuilder(state) {
+}
+
+function getParamsBuilder(paramFactory) {
+  return function (state) {
     const makeConfigParam = (config, id) =>
       paramFactory.fromConfig(id, null, state.self);
     const urlParams =
       (state.url && state.url.parameters({ inherit: false })) || [];
     const nonUrlParams = Object.values(
-      mapObj(
-        omit(state.params || {}, urlParams.map(prop("id"))),
-        makeConfigParam,
-      ),
+      map(omit(state.params || {}, urlParams.map(prop("id"))), makeConfigParam),
     );
     return urlParams
       .concat(nonUrlParams)
       .map((p) => [p.id, p])
       .reduce(applyPairs, {});
   };
+}
+
 function pathBuilder(state) {
   if (state.parent && !state.abstract) {
     return state.parent.path.concat(state);
@@ -88,11 +94,13 @@ function pathBuilder(state) {
     return [state];
   }
 }
+
 function includesBuilder(state) {
   const includes = state.parent ? Object.assign({}, state.parent.includes) : {};
   includes[state.name] = true;
   return includes;
 }
+
 /**
  * This is a [[StateBuilder.builder]] function for the `resolve:` block on a [[StateDeclaration]].
  *
@@ -157,12 +165,6 @@ export function resolvablesBuilder(state) {
   };
   /** true if the object has both `token` and `resolveFn`, and is probably a [[ResolveLiteral]] */
   const isResolveLiteral = (obj) => !!(obj.token && obj.resolveFn);
-  /** true if the object looks like a provide literal, or a ng2 Provider */
-  const isLikeNg2Provider = (obj) =>
-    !!(
-      (obj.provide || obj.token) &&
-      (obj.useValue || obj.useFactory || obj.useExisting || obj.useClass)
-    );
   /** true if the object looks like a tuple from obj2Tuples */
   const isTupleFromObj = (obj) =>
     !!(
@@ -170,8 +172,7 @@ export function resolvablesBuilder(state) {
       obj.val &&
       (isString(obj.val) || Array.isArray(obj.val) || isFunction(obj.val))
     );
-  /** extracts the token from a Provider or provide literal */
-  const getToken = (p) => p.provide || p.token;
+
   // Given a literal resolve or provider object, returns a Resolvable
   const literal2Resolvable = pattern([
     [
@@ -232,7 +233,6 @@ export function resolvablesBuilder(state) {
   const item2Resolvable = pattern([
     [is(Resolvable), (r) => r],
     [isResolveLiteral, literal2Resolvable],
-    [isLikeNg2Provider, literal2Resolvable],
     [isTupleFromObj, tuple2Resolvable],
     [
       val(true),
@@ -267,7 +267,6 @@ export class StateBuilder {
     this.$injector = undefined;
     const self = this;
     const root = () => matcher.find("");
-    const isRoot = (state) => state.name === "";
     function parentBuilder(state) {
       if (isRoot(state)) return null;
       return matcher.find(self.parentName(state)) || root();
@@ -358,3 +357,12 @@ export class StateBuilder {
     return parentName ? parentName + "." + name : name;
   }
 }
+
+function isRoot(state) {
+  return state.name === "";
+}
+
+/** extracts the token from a Provider or provide literal */
+function getToken(p) {
+  return p.provide || p.token;
+}

package/src/router/transition/hook-registry.js

@@ -1,4 +1,4 @@
-import { removeFrom, tail, mapObj } from "../../shared/common";
+import { removeFrom, tail, map } from "../../shared/common";
 import { isString, isFunction } from "../../shared/utils";
 import { Glob } from "../common/glob";
 import { TransitionHookScope } from "./interface";
@@ -93,7 +93,7 @@ export class RegisteredHook {
    * }
    */
   _getDefaultMatchCriteria() {
-    return mapObj(this.tranSvc._pluginapi._getPathTypes(), () => true);
+    return map(this.tranSvc._pluginapi._getPathTypes(), () => true);
   }
   /**
    * Gets matching nodes as [[IMatchingNodes]]

package/src/router/transition/transition-hook.js

@@ -2,7 +2,7 @@ import { TransitionHookPhase } from "./interface";
 import { defaults, silentRejection } from "../../shared/common";
 import { fnToString, maxLength } from "../../shared/strings";
 import { isPromise } from "../../shared/predicates";
-import { is, parse } from "../../shared/hof";
+import { parse } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
 import { Rejection } from "./reject-factory";
@@ -134,9 +134,9 @@ export class TransitionHook {
       // Abort this Transition
       return Rejection.aborted("Hook aborted transition").toPromise();
     }
-    const isTargetState = is(TargetState);
+
     // hook returned a TargetState
-    if (isTargetState(result)) {
+    if (result instanceof TargetState) {
       // Halt the current Transition and redirect (a new Transition) to the TargetState.
       return Rejection.redirected(result).toPromise();
     }

package/src/shared/common.js

@@ -1,5 +1,5 @@
 import { isDate, isFunction, isRegExp, isString } from "./utils";
-import { all, any, prop, curry } from "./hof";
+import { all, prop, curry } from "./hof";
 import { services } from "../router/common/coreservices";
 
 export function forEach(obj, cb, thisArg) {
@@ -19,9 +19,9 @@ export function equals(o1, o2) {
   if (all(isDate)(tup)) return o1.getTime() === o2.getTime();
   if (all(isRegExp)(tup)) return o1.toString() === o2.toString();
   if (all(isFunction)(tup)) return true; // meh
-  const predicates = [isFunction, Array.isArray, isDate, isRegExp];
-  if (predicates.map(any).reduce((b, fn) => b || !!fn(tup), false))
+  if ([isFunction, Array.isArray, isDate, isRegExp].some((fn) => !!fn(tup))) {
     return false;
+  }
   const keys = {};
 
   for (const key in o1) {
@@ -230,6 +230,7 @@ export function filter(collection, callback) {
   });
   return result;
 }
+
 /** Finds an object from an array, or a property of an object, that matches a predicate */
 export function find(collection, callback) {
   let result;
@@ -239,8 +240,7 @@ export function find(collection, callback) {
   });
   return result;
 }
-/** Given an object, returns a new object, where each property is transformed by the callback function */
-export let mapObj = map;
+
 /** Maps an array or object properties using a callback function */
 export function map(collection, callback, target) {
   target = target || (Array.isArray(collection) ? [] : {});

package/src/shared/common.spec.js

@@ -1,4 +1,4 @@
-import { defaults, filter, map, mapObj, pick } from "./common";
+import { defaults, filter, map, pick } from "./common";
 import { is, eq, pattern, val } from "./hof";
 import { isInjectable } from "./predicates";
 import { Queue } from "../router/common/queue";
@@ -142,10 +142,10 @@ describe("common", function () {
     });
   });
 
-  describe("mapObj", () => {
+  describe("map", () => {
     it("should map objects", () => {
       const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = mapObj(src, (x) => x * 2);
+      const dest = map(src, (x) => x * 2);
 
       expect(src).toEqual({ foo: 1, bar: 2, baz: 3 });
       expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });
@@ -153,7 +153,7 @@ describe("common", function () {
 
     it("should map objects in place when target === src", () => {
       const src = { foo: 1, bar: 2, baz: 3 };
-      const dest = mapObj(src, (x) => x * 2, src);
+      const dest = map(src, (x) => x * 2, src);
 
       expect(src).toEqual({ foo: 2, bar: 4, baz: 6 });
       expect(dest).toEqual({ foo: 2, bar: 4, baz: 6 });

package/src/shared/hof.js

@@ -112,7 +112,6 @@ export function or(fn1, fn2) {
  * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
  */
 export const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
-export const any = (fn1) => (arr) => arr.reduce((b, x) => b || !!fn1(x), false);
 /** Given a class, returns a Predicate function that returns true if the object is of that class */
 export const is = (ctor) => (obj) =>
   (obj != null && obj.constructor === ctor) || obj instanceof ctor;
@@ -120,9 +119,6 @@ export const is = (ctor) => (obj) =>
 export const eq = (value) => (other) => value === other;
 /** Given a value, returns a function which returns the value */
 export const val = (v) => () => v;
-export function invoke(fnName, args) {
-  return (obj) => obj[fnName].apply(obj, args);
-}
 /**
  * Sorta like Pattern Matching (a functional programming conditional construct)
  *