@angular-wave/angular.ts 0.0.73 → 0.1.0

package/src/core/interpolate/interpolate.js

@@ -9,7 +9,7 @@ import {
 import { constantWatchDelegate } from "../parser/parse";
 
 const $interpolateMinErr = minErr("$interpolate");
-$interpolateMinErr.throwNoconcat = function (text) {
+function throwNoconcat(text) {
   throw $interpolateMinErr(
     "noconcat",
     "Error while interpolating: {0}\nStrict Contextual Escaping disallows " +
@@ -17,16 +17,16 @@ $interpolateMinErr.throwNoconcat = function (text) {
       "required.  See http://docs.angularjs.org/api/ng.$sce",
     text,
   );
-};
+}
 
-$interpolateMinErr.interr = function (text, err) {
+function interr(text, err) {
   throw $interpolateMinErr(
     "interr",
     "Can't interpolate: {0}\n{1}",
     text,
     err.toString(),
   );
-};
+}
 
 /**
  *
@@ -48,7 +48,7 @@ export function $InterpolateProvider() {
    * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
    *
    * @param {string=} value new value to set the starting symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   * @returns {string|$InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
    */
   this.startSymbol = function (value) {
     if (value) {
@@ -62,7 +62,7 @@ export function $InterpolateProvider() {
    * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
    *
    * @param {string=} value new value to set the ending symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   * @returns {string|$InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
    */
   this.endSymbol = function (value) {
     if (value) {
@@ -215,7 +215,7 @@ export function $InterpolateProvider() {
        *    provides Strict Contextual Escaping for details.
        * @param {boolean=} allOrNothing if `true`, then the returned function returns undefined
        *    unless all embedded expressions evaluate to a value other than `undefined`.
-       * @returns {function(context)} an interpolation function which is used to compute the
+       * @returns {Function} an interpolation function which is used to compute the
        *    interpolated string. The function has these parameters:
        *
        * - `context`: evaluation context for all expressions embedded in the interpolated text
@@ -237,6 +237,10 @@ export function $InterpolateProvider() {
           if (contextAllowsConcatenation) {
             unescapedText = $sce.getTrusted(trustedContext, unescapedText);
           }
+
+          /**
+           * @type {any}
+           */
           const constantInterp = valueFn(unescapedText);
           constantInterp.exp = text;
           constantInterp.expressions = [];
@@ -322,7 +326,7 @@ export function $InterpolateProvider() {
             }
             if (trustedContext && concat.length > 1) {
               // This context does not allow more than one part, e.g. expr + string or exp + exp.
-              $interpolateMinErr.throwNoconcat(text);
+              throwNoconcat(text);
             }
             // In an unprivileged context or only one part: just concatenate and return.
             return concat.join("");
@@ -341,7 +345,7 @@ export function $InterpolateProvider() {
 
                 return compute(values);
               } catch (err) {
-                $exceptionHandler($interpolateMinErr.interr(text, err));
+                interr(text, err);
               }
             },
             {
@@ -380,7 +384,7 @@ export function $InterpolateProvider() {
                 : $sce.valueOf(value);
             return allOrNothing && !isDefined(value) ? value : stringify(value);
           } catch (err) {
-            $exceptionHandler($interpolateMinErr.interr(text, err));
+            interr(text, err);
           }
         }
       }

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

@@ -107,6 +107,7 @@ export class ResolveContext {
    * @param state Used to find the node to put the resolvable on
    */
   addResolvables(newResolvables, state) {
+    /** @type {import('../path/path-node').PathNode} */
     const node = find(this._path, propEq("state", state));
     const keys = newResolvables.map((r) => r.token);
     node.resolvables = node.resolvables

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

@@ -172,7 +172,7 @@ export function resolvablesBuilder(state) {
     );
   /** extracts the token from a Provider or provide literal */
   const getToken = (p) => p.provide || p.token;
-  // prettier-ignore: Given a literal resolve or provider object, returns a Resolvable
+  // Given a literal resolve or provider object, returns a Resolvable
   const literal2Resolvable = pattern([
     [
       prop("resolveFn"),
@@ -202,20 +202,45 @@ export function resolvablesBuilder(state) {
       (p) => new Resolvable(getToken(p), (x) => x, [p.useExisting], p.policy),
     ],
   ]);
-  // prettier-ignore
   const tuple2Resolvable = pattern([
-        [pipe(prop('val'), isString), (tuple) => new Resolvable(tuple.token, ((x) => x), [tuple.val], tuple.policy)],
-        [pipe(prop('val'), Array.isArray), (tuple) => new Resolvable(tuple.token, tail(tuple.val), tuple.val.slice(0, -1), tuple.policy)],
-        [pipe(prop('val'), isFunction), (tuple) => new Resolvable(tuple.token, tuple.val, annotateFn(tuple.val), tuple.policy)],
-    ]);
-  // prettier-ignore
+    [
+      pipe(prop("val"), isString),
+      (tuple) =>
+        new Resolvable(tuple.token, (x) => x, [tuple.val], tuple.policy),
+    ],
+    [
+      pipe(prop("val"), Array.isArray),
+      (tuple) =>
+        new Resolvable(
+          tuple.token,
+          tail(tuple.val),
+          tuple.val.slice(0, -1),
+          tuple.policy,
+        ),
+    ],
+    [
+      pipe(prop("val"), isFunction),
+      (tuple) =>
+        new Resolvable(
+          tuple.token,
+          tuple.val,
+          annotateFn(tuple.val),
+          tuple.policy,
+        ),
+    ],
+  ]);
   const item2Resolvable = pattern([
-        [is(Resolvable), (r) => r],
-        [isResolveLiteral, literal2Resolvable],
-        [isLikeNg2Provider, literal2Resolvable],
-        [isTupleFromObj, tuple2Resolvable],
-        [val(true), (obj) => { throw new Error('Invalid resolve value: ' + stringify(obj)); },],
-    ]);
+    [is(Resolvable), (r) => r],
+    [isResolveLiteral, literal2Resolvable],
+    [isLikeNg2Provider, literal2Resolvable],
+    [isTupleFromObj, tuple2Resolvable],
+    [
+      val(true),
+      (obj) => {
+        throw new Error("Invalid resolve value: " + stringify(obj));
+      },
+    ],
+  ]);
   // If resolveBlock is already an array, use it as-is.
   // Otherwise, assume it's an object and convert to an Array of tuples
   const decl = state.resolve;

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

@@ -13,29 +13,19 @@ import { isFunction, isObject } from "../../shared/utils";
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
  */
 export class StateObject {
-  /**
-   * Create a state object to put the private/internal implementation details onto.
-   * The object's prototype chain looks like:
-   * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
-   *
-   * @param stateDecl the user-supplied State Declaration
-   * @returns {StateObject} an internal State object
-   */
-  static create(stateDecl) {
-    const state = Object.setPrototypeOf(
-      Object.assign({}, stateDecl),
-      StateObject.prototype,
-    );
-    stateDecl.$$state = () => state;
-    state.self = stateDecl;
-    state.__stateObjectCache = {
-      nameGlob: Glob.fromString(state.name), // might return null
-    };
-    return state;
-  }
-  // /** @deprecated use State.create() */
+  name = undefined;
+  navigable = undefined;
+  /** @type {?StateObject} */
+  parent = undefined;
+  params = undefined;
+  url = undefined;
+
   constructor(config) {
-    return StateObject.create(config || {});
+    Object.assign(this, config);
+    this.$$state = () => this;
+    this.self = config;
+    const nameGlob = this.name ? Glob.fromString(this.name) : null;
+    this.__stateObjectCache = { nameGlob };
   }
   /**
    * Returns true if the provided parameter is the same state.

package/src/router/state/state-queue-manager.js

@@ -13,7 +13,7 @@ export class StateQueueManager {
   }
   register(stateDecl) {
     const queue = this.queue;
-    const state = StateObject.create(stateDecl);
+    const state = new StateObject(stateDecl);
     const name = state.name;
     if (!isString(name)) throw new Error("State must have a valid name");
     if (

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

@@ -6,6 +6,7 @@ import { propEq } from "../../shared/hof";
 import { ResolveContext } from "../resolve/resolve-context";
 import { ng1ViewsBuilder } from "./views";
 import { isString } from "../../shared/utils";
+
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
@@ -196,7 +197,7 @@ export class StateRegistry {
    * If the state has children, they are are also removed from the registry.
    *
    * @param stateOrName the state's name or object representation
-   * @returns {StateObject[]} a list of removed states
+   * @returns {import('./state-object').StateObject[]} a list of removed states
    */
   deregister(stateOrName) {
     const _state = this.get(stateOrName);

package/src/router/transition/transition.js

@@ -323,12 +323,14 @@ export class Transition {
    * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
    * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)
    */
-  addResolvable(resolvable, state = "") {
+  addResolvable(resolvable, state) {
     resolvable = is(Resolvable)(resolvable)
       ? resolvable
       : new Resolvable(resolvable);
+
     const stateName = typeof state === "string" ? state : state.name;
     const topath = this._treeChanges.to;
+    /** @type {import('../path/path-node').PathNode} */
     const targetNode = find(topath, (node) => {
       return node.state.name === stateName;
     });

package/src/router/url/url-rule.js

@@ -1,5 +1,11 @@
 import { UrlMatcher } from "./url-matcher";
-import { isString, isFunction, isDefined } from "../../shared/utils";
+import {
+  isString,
+  isFunction,
+  isDefined,
+  isUndefined,
+  assert,
+} from "../../shared/utils";
 import { is, or, pattern } from "../../shared/hof";
 import { StateObject } from "../state/state-object";
 /**
@@ -207,7 +213,13 @@ export class BaseUrlRule {
     this.handler = handler || ((x) => x);
   }
 
-  matchPriority() {
+  /**
+   * This function should be overridden
+   * @param {*} [params]
+   * @returns {number}
+   */
+  matchPriority(params) {
+    assert(isUndefined(params));
     return 0 - this.$id;
   }
 }

package/src/router/view/view.spec.js

@@ -61,7 +61,7 @@ describe("view", () => {
 
   let register;
   const registerState = curry(function (_states, stateBuilder, config) {
-    const state = StateObject.create(config);
+    const state = new StateObject(config);
     const built = stateBuilder.build(state);
     return (_states[built.name] = built);
   });

package/src/shared/predicates.js

@@ -15,11 +15,14 @@ export const isNullOrUndefined = or(isNull, isUndefined);
  *
  * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
  * where all the elements in the array are Strings, except the last one, which is a Function
+ * @param {*} val
+ * @returns {boolean}
  */
 export function isInjectable(val) {
   if (Array.isArray(val) && val.length) {
     const head = val.slice(0, -1),
       tail = val.slice(-1);
+
     return !(
       head.filter((x) => !isString(x)).length ||
       tail.filter((x) => !isFunction(x)).length

package/tsconfig.json

@@ -13,5 +13,5 @@
     "typeRoots": ["node_modules/@types"]
   },
   "include": ["./src/*.js", "./**/*.ts"],
-  "exclude": ["./types-back/**",  "./types/**", "**/*.test.js", "**/*.spec.js"]
+  "exclude": ["./node_modules/**",  "./types/**", "**/*.test.js", "**/*.spec.js"]
 }

package/types/core/compile/attributes.d.ts

@@ -1,9 +1,9 @@
 /**
- * @typedef {Object} AnyStringKeyObject
- * @property {Record<string, any>} [key]
+ * @typedef {Object} AttributeLike
+ * @property {Object} $attr
  */
 /**
- * @extends {AnyStringKeyObject}
+ * @extends {AttributeLike}
  */
 export class Attributes {
     /**
@@ -104,7 +104,7 @@ export class Attributes {
     sanitizeSrcset(value: any, invokeType: any): any;
     srcset: any;
 }
-export type AnyStringKeyObject = {
-    key?: Record<string, any>;
+export type AttributeLike = {
+    $attr: any;
 };
 import { directiveNormalize } from "../../shared/utils";

package/types/core/interpolate/interpolate.d.ts

@@ -16,18 +16,18 @@ export class $InterpolateProvider {
      * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
      *
      * @param {string=} value new value to set the starting symbol to.
-     * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+     * @returns {string|$InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
      */
-    startSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
+    startSymbol: (value?: string | undefined) => string | $InterpolateProvider;
     /**
      * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
      *
      * @param {string=} value new value to set the ending symbol to.
-     * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+     * @returns {string|$InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
      */
-    endSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
+    endSymbol: (value?: string | undefined) => string | $InterpolateProvider;
     $get: (string | (($parse: import("../parser/parse").ParseService, $exceptionHandler: import("../exception-handler").ErrorHandler, $sce: any) => {
-        (text: string, mustHaveExpression?: boolean | undefined, trustedContext?: string | undefined, allOrNothing?: boolean | undefined): (arg0: context) => any;
+        (text: string, mustHaveExpression?: boolean | undefined, trustedContext?: string | undefined, allOrNothing?: boolean | undefined): Function;
         /**
          * @ngdoc method
          * @name $interpolate#startSymbol

package/types/router/state/state-object.d.ts

@@ -9,16 +9,18 @@
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
  */
 export class StateObject {
-    /**
-     * Create a state object to put the private/internal implementation details onto.
-     * The object's prototype chain looks like:
-     * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
-     *
-     * @param stateDecl the user-supplied State Declaration
-     * @returns {StateObject} an internal State object
-     */
-    static create(stateDecl: any): StateObject;
     constructor(config: any);
+    name: any;
+    navigable: any;
+    /** @type {?StateObject} */
+    parent: StateObject | null;
+    params: any;
+    url: any;
+    $$state: () => this;
+    self: any;
+    __stateObjectCache: {
+        nameGlob: Glob;
+    };
     /**
      * Returns true if the provided parameter is the same state.
      *
@@ -68,3 +70,4 @@ export namespace StateObject {
     /** Predicate which returns true if the object is an internal [[StateObject]] object */
     function isState(obj: any): boolean;
 }
+import { Glob } from "../common/glob";

package/types/router/state/state-registry.d.ts

@@ -89,9 +89,9 @@ export class StateRegistry {
      * If the state has children, they are are also removed from the registry.
      *
      * @param stateOrName the state's name or object representation
-     * @returns {StateObject[]} a list of removed states
+     * @returns {import('./state-object').StateObject[]} a list of removed states
      */
-    deregister(stateOrName: any): StateObject[];
+    deregister(stateOrName: any): import("./state-object").StateObject[];
     get(stateOrName: any, base: any, ...args: any[]): any;
     /**
      * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).

package/types/router/transition/transition.d.ts

@@ -218,7 +218,7 @@ export class Transition {
      * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
      * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)
      */
-    addResolvable(resolvable: any, state?: string): void;
+    addResolvable(resolvable: any, state: any): void;
     /**
      * Gets the transition from which this transition was redirected.
      *

package/types/router/url/url-rule.d.ts

@@ -132,5 +132,10 @@ export class BaseUrlRule {
     $id: number;
     _group: any;
     handler: any;
-    matchPriority(): number;
+    /**
+     * This function should be overridden
+     * @param {*} [params]
+     * @returns {number}
+     */
+    matchPriority(params?: any): number;
 }

package/types/shared/predicates.d.ts

@@ -3,6 +3,8 @@
  *
  * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
  * where all the elements in the array are Strings, except the last one, which is a Function
+ * @param {*} val
+ * @returns {boolean}
  */
 export function isInjectable(val: any): boolean;
 export function isNull(o: any): boolean;