@angular-wave/angular.ts 0.0.15 → 0.0.17

package/src/router/{adapter/statebuilders → state}/views.js

@@ -1,13 +1,12 @@
-import { pick, forEach, tail } from "../../core/common/common";
-import { isArray, isDefined, isString } from "../../../core/utils";
-import { isInjectable } from "../../core/common/predicates";
-import { services } from "../../core/common/coreservices";
-import { trace } from "../../core/common/trace";
-import { ViewService } from "../../core/view/view";
-import { ResolveContext } from "../../core/resolve/resolveContext";
-import { Resolvable } from "../../core/resolve/resolvable";
+import { pick, forEach, tail } from "../../shared/common";
+import { isDefined, isString } from "../../shared/utils";
+import { isInjectable } from "../../shared/predicates";
+import { services } from "../common/coreservices";
+import { trace } from "../common/trace";
+import { ViewService } from "../view/view";
+import { ResolveContext } from "../resolve/resolveContext";
+import { Resolvable } from "../resolve/resolvable";
 
-/** @internalapi */
 export function getNg1ViewConfigFactory() {
   let templateFactory = null;
   return (path, view) => {
@@ -16,7 +15,7 @@ export function getNg1ViewConfigFactory() {
     return [new Ng1ViewConfig(path, view, templateFactory)];
   };
 }
-/** @internalapi */
+
 const hasAnyKey = (keys, obj) =>
   keys.reduce((acc, key) => acc || isDefined(obj[key]), false);
 /**
@@ -28,7 +27,6 @@ const hasAnyKey = (keys, obj) =>
  * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object
  * and applies the state-level configuration to a view named `$default`.
  *
- * @internalapi
  */
 export function ng1ViewsBuilder(state) {
   // Do not process root state
@@ -89,15 +87,19 @@ export function ng1ViewsBuilder(state) {
   });
   return views;
 }
-/** @hidden */
+
+/**
+ * @type {Number}
+ */
 let id = 0;
-/** @internalapi */
+
 export class Ng1ViewConfig {
   constructor(path, viewDecl, factory) {
     this.path = path;
     this.viewDecl = viewDecl;
     this.factory = factory;
-    this.$id = id++;
+
+    /** @type {Number} */ this.$id = id++;
     this.loaded = false;
     this.getTemplate = (uiView, context) =>
       this.component
@@ -138,7 +140,7 @@ export class Ng1ViewConfig {
     const provider = this.viewDecl.controllerProvider;
     if (!isInjectable(provider)) return this.viewDecl.controller;
     const deps = services.$injector.annotate(provider);
-    const providerFn = isArray(provider) ? tail(provider) : provider;
+    const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
   }

package/src/router/{adapter/stateProvider.js → stateProvider.js}

@@ -1,8 +1,36 @@
 /** @publicapi @module ng1 */ /** */
 
-import { val } from "../core/common/hof";
-import { createProxyFunctions } from "../core/common/common";
-import { isObject } from "../../core/utils";
+import { val } from "../shared/hof";
+import { createProxyFunctions } from "../shared/common";
+import { minErr } from "../shared/utils";
+
+const err = minErr("$stateProvider");
+const validKeys = [
+  "$$state",
+  "__stateObjectCache",
+  "controller",
+  "controllerProvider",
+  "data",
+  "includes",
+  "name",
+  "navigable",
+  "onEnter",
+  "onExit",
+  "onRetain",
+  "params",
+  "parent",
+  "path",
+  "reloadOnSearch",
+  "resolve",
+  "resolvables",
+  "self",
+  "template",
+  "templateProvider",
+  "templateUrl",
+  "url",
+  "views",
+];
+
 /**
  * The Angular 1 `StateProvider`
  *
@@ -117,13 +145,28 @@ export class StateProvider {
   decorator(name, func) {
     return this.stateRegistry.decorator(name, func) || this;
   }
-  state(name, definition) {
-    if (isObject(name)) {
-      definition = name;
-    } else {
-      definition.name = name;
+
+  /**
+   *
+   * @param {angular.Ng1StateDeclaration} definition
+   * @returns {StateProvider}
+   */
+  state(definition) {
+    if (!definition.name) {
+      throw err("stateinvalid", `'name' required`);
+    }
+
+    const hasInvalidKeys = Object.keys(definition).filter(
+      (key) => !validKeys.includes(key),
+    );
+    if (hasInvalidKeys.length) {
+      throw err("stateinvalid", `Invalid key(s): ${hasInvalidKeys.join(", ")}`);
+    }
+    try {
+      this.stateRegistry.register(definition);
+    } catch (e) {
+      throw err("stateinvalid", e.message);
     }
-    this.stateRegistry.register(definition);
     return this;
   }
   /**

package/src/router/{adapter/templateFactory.js → templateFactory.js}

@@ -1,21 +1,15 @@
 /** @publicapi @module view */ /** */
-import {
-  isArray,
-  isDefined,
-  isFunction,
-  isObject,
-} from "../core/common/predicates";
-import { services } from "../core/common/coreservices";
-import { tail, unnestR } from "../core/common/common";
-import { Resolvable } from "../core/resolve/resolvable";
-import { kebobString } from "../core/common/strings";
+import { isDefined, isFunction, isObject } from "../shared/utils";
+import { services } from "./common/coreservices";
+import { tail, unnestR } from "../shared/common";
+import { Resolvable } from "./resolve/resolvable";
+import { kebobString } from "../shared/strings";
 
 /**
  * Service which manages loading of templates from a ViewConfig.
  */
 export class TemplateFactory {
   constructor() {
-    /** @hidden */ this._useHttp = true; // TODO investigate
     /** @hidden */ this.$get = [
       "$http",
       "$templateCache",
@@ -31,10 +25,7 @@ export class TemplateFactory {
       },
     ];
   }
-  /** @hidden */
-  useHttpService(value) {
-    this._useHttp = value;
-  }
+
   /**
    * Creates a template from a configuration object.
    *
@@ -120,7 +111,7 @@ export class TemplateFactory {
    */
   fromProvider(provider, params, context) {
     const deps = services.$injector.annotate(provider);
-    const providerFn = isArray(provider) ? tail(provider) : provider;
+    const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
   }
@@ -133,7 +124,7 @@ export class TemplateFactory {
    */
   fromComponentProvider(provider, params, context) {
     const deps = services.$injector.annotate(provider);
-    const providerFn = isArray(provider) ? tail(provider) : provider;
+    const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
   }
@@ -181,7 +172,7 @@ export class TemplateFactory {
         const fn = res && res.data;
         const args = (fn && services.$injector.annotate(fn)) || [];
         // account for array style injection, i.e., ['foo', function(foo) {}]
-        const arrayIdxStr = isArray(fn) ? `[${fn.length - 1}]` : "";
+        const arrayIdxStr = Array.isArray(fn) ? `[${fn.length - 1}]` : "";
         return `${attrName}='$resolve.${resolveName}${arrayIdxStr}(${args.join(",")})'`;
       }
       // some-attr="::$resolve.someResolveName"
@@ -213,6 +204,6 @@ const scopeBindings = (bindingsObj) =>
     // [ 'input', [ '=foo', '=', 'foo' ] ]
     .map((key) => [key, /^([=<@&])[?]?(.*)/.exec(bindingsObj[key])])
     // skip malformed values
-    .filter((tuple) => isDefined(tuple) && isArray(tuple[1]))
+    .filter((tuple) => isDefined(tuple) && Array.isArray(tuple[1]))
     // { name: ('foo' || 'input'), type: '=' }
     .map((tuple) => ({ name: tuple[1][2] || tuple[0], type: tuple[1][1] }));

package/src/router/{core/transition → transition}/hookBuilder.js

@@ -1,5 +1,4 @@
-import { assertPredicate, unnestR, identity } from "../common/common";
-import { isArray } from "../common/predicates";
+import { assertPredicate, unnestR, identity } from "../../shared/common";
 import { TransitionHookPhase, TransitionHookScope } from "./interface";
 import { TransitionHook } from "./transitionHook";
 /**
@@ -103,7 +102,9 @@ export class HookBuilder {
       : [this.transition, $transitions];
     return registries
       .map((reg) => reg.getHooks(hookType.name)) // Get named hooks from registries
-      .filter(assertPredicate(isArray, `broken event named: ${hookType.name}`)) // Sanity check
+      .filter(
+        assertPredicate(Array.isArray, `broken event named: ${hookType.name}`),
+      ) // Sanity check
       .reduce(unnestR, []) // Un-nest RegisteredHook[][] to RegisteredHook[] array
       .filter((hook) => hook.matches(treeChanges, transition)); // Only those satisfying matchCriteria
   }

package/src/router/{core/transition → transition}/hookRegistry.js

@@ -1,10 +1,7 @@
-import { removeFrom, tail, identity, mapObj } from "../common/common";
-import { isString, isFunction } from "../common/predicates";
+import { removeFrom, tail, identity, mapObj } from "../../shared/common";
+import { isString, isFunction } from "../../shared/utils";
 import { Glob } from "../common/glob";
-import {
-  // has or is using
-  TransitionHookScope,
-} from "./interface";
+import { TransitionHookScope } from "./interface";
 /**
  * Determines if the given state matches the matchCriteria
  *

package/src/router/{core/transition → transition}/rejectFactory.js

@@ -1,6 +1,6 @@
-import { silentRejection } from "../common/common";
-import { stringify } from "../common/strings";
-import { is } from "../common/hof";
+import { silentRejection } from "../../shared/common";
+import { stringify } from "../../shared/strings";
+import { is } from "../../shared/hof";
 /** An enum for Transition Rejection reasons */
 var RejectType;
 (function (RejectType) {
@@ -42,7 +42,7 @@ var RejectType;
   RejectType[(RejectType["ERROR"] = 6)] = "ERROR";
 })(RejectType || (RejectType = {}));
 export { RejectType };
-/** @internal */
+
 let id = 0;
 export class Rejection {
   /** Returns true if the obj is a rejected promise created from the `asPromise` factory */
@@ -100,7 +100,6 @@ export class Rejection {
     return is(Rejection)(detail) ? detail : Rejection.errored(detail);
   }
   constructor(type, message, detail) {
-    /** @internal */
     this.$id = id++;
     this.type = type;
     this.message = message;

package/src/router/{core/transition → transition}/transition.js

@@ -1,6 +1,6 @@
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
-import { stringify } from "../common/strings";
+import { stringify } from "../../shared/strings";
 import {
   map,
   find,
@@ -13,9 +13,9 @@ import {
   anyTrueR,
   flattenR,
   uniqR,
-} from "../common/common";
-import { isObject, isUndefined } from "../common/predicates";
-import { prop, propEq, val, not, is } from "../common/hof";
+} from "../../shared/common";
+import { isUndefined, isObject } from "../../shared/utils";
+import { prop, propEq, val, not, is } from "../../shared/hof";
 import { TransitionHookPhase } from "./interface"; // has or is using
 import { TransitionHook } from "./transitionHook";
 import { matchState, makeEvent } from "./hookRegistry";
@@ -25,7 +25,7 @@ import { Param } from "../params/param";
 import { Resolvable } from "../resolve/resolvable";
 import { ResolveContext } from "../resolve/resolveContext";
 import { Rejection } from "./rejectFactory";
-/** @internal */
+
 const stateSelf = prop("self");
 /**
  * Represents a transition between two states.
@@ -36,7 +36,6 @@ const stateSelf = prop("self");
  * It has information about all states being entered and exited as a result of the transition.
  */
 export class Transition {
-  /** @internal */
   onBefore(criteria, callback, options) {
     return;
   }
@@ -78,7 +77,7 @@ export class Transition {
       .filter((type) => type.hookPhase !== TransitionHookPhase.CREATE)
       .forEach((type) => makeEvent(this, this.router.transitionService, type));
   }
-  /** @internal */
+
   getHooks(hookName) {
     return this._registeredHooks[hookName];
   }
@@ -92,11 +91,10 @@ export class Transition {
    * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param router The [[UIRouter]] instance
+   * @param {import('../router').UIRouter} router The [[UIRouter]] instance
    * @internal
    */
   constructor(fromPath, targetState, router) {
-    /** @internal */
     this._deferred = services.$q.defer();
     /**
      * This promise is resolved or rejected based on the outcome of the Transition.
@@ -107,7 +105,7 @@ export class Transition {
     this.promise = this._deferred.promise;
     /** @internal Holds the hook registration functions such as those passed to Transition.onStart() */
     this._registeredHooks = {};
-    /** @internal */
+
     this._hookBuilder = new HookBuilder(this);
     /** Checks if this transition is currently active/running. */
     this.isActive = () => this.router.globals.transition === this;
@@ -585,7 +583,7 @@ export class Transition {
   ignored() {
     return !!this._ignoredReason();
   }
-  /** @internal */
+
   _ignoredReason() {
     const pending = this.router.globals.transition;
     const reloadState = this._options.reloadState;
@@ -737,5 +735,5 @@ export class Transition {
     return `Transition#${id}( '${from}'${fromParams} -> ${toValid}'${to}'${toParams} )`;
   }
 }
-/** @internal */
+
 Transition.diToken = Transition;

package/src/router/{core/transition → transition}/transitionHook.js

@@ -1,8 +1,8 @@
 import { TransitionHookPhase } from "./interface";
-import { defaults, noop, silentRejection } from "../common/common";
-import { fnToString, maxLength } from "../common/strings";
-import { isPromise } from "../common/predicates";
-import { is, parse } from "../common/hof";
+import { defaults, noop, silentRejection } from "../../shared/common";
+import { fnToString, maxLength } from "../../shared/strings";
+import { isPromise } from "../../shared/predicates";
+import { is, parse } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
 import { Rejection } from "./rejectFactory";

package/src/router/{core/transition → transition}/transitionService.js

@@ -25,9 +25,9 @@ import { registerUpdateUrl } from "../hooks/url";
 import { registerLazyLoadHook } from "../hooks/lazyLoad";
 import { TransitionEventType } from "./transitionEventType";
 import { TransitionHook } from "./transitionHook";
-import { isDefined } from "../common/predicates";
-import { removeFrom, createProxyFunctions } from "../common/common";
-import { val } from "../common/hof";
+import { isDefined } from "../../shared/utils";
+import { removeFrom, createProxyFunctions } from "../../shared/common";
+import { val } from "../../shared/hof";
 import { registerIgnoredTransitionHook } from "../hooks/ignoredTransition";
 import { registerInvalidTransitionHook } from "../hooks/invalidTransition";
 /**
@@ -60,9 +60,10 @@ export let defaultTransOpts = {
  * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
  */
 export class TransitionService {
-  /** @internal */
+  /**
+   * @param {import('../router').UIRouter} _router
+   */
   constructor(_router) {
-    /** @internal */
     this._transitionCount = 0;
     /** The transition hook types, such as `onEnter`, `onStart`, etc */
     this._eventTypes = [];
@@ -169,7 +170,7 @@ export class TransitionService {
   create(fromPath, targetState) {
     return new Transition(fromPath, targetState, this._router);
   }
-  /** @internal */
+
   _defineCoreEvents() {
     const Phase = TransitionHookPhase;
     const TH = TransitionHook;
@@ -214,7 +215,7 @@ export class TransitionService {
       SYNCHRONOUS,
     );
   }
-  /** @internal */
+
   _defineCorePaths() {
     const { STATE, TRANSITION } = TransitionHookScope;
     this._definePathType("to", TRANSITION);
@@ -223,7 +224,7 @@ export class TransitionService {
     this._definePathType("retained", STATE);
     this._definePathType("entering", STATE);
   }
-  /** @internal */
+
   _defineEvent(
     name,
     hookPhase,
@@ -247,7 +248,7 @@ export class TransitionService {
     this._eventTypes.push(eventType);
     makeEvent(this, this, eventType);
   }
-  /** @internal */
+
   _getEvents(phase) {
     const transitionHookTypes = isDefined(phase)
       ? this._eventTypes.filter((type) => type.hookPhase === phase)
@@ -273,16 +274,15 @@ export class TransitionService {
   _definePathType(name, hookScope) {
     this._criteriaPaths[name] = { name, scope: hookScope };
   }
-  /** @internal */
-  // tslint:disable-next-line
+
   _getPathTypes() {
     return this._criteriaPaths;
   }
-  /** @internal */
+
   getHooks(hookName) {
     return this._registeredHooks[hookName];
   }
-  /** @internal */
+
   _registerCoreTransitionHooks() {
     const fns = this._deregisterHookFns;
     fns.addCoreResolves = registerAddCoreResolvables(this);

package/src/router/{core/url → url}/urlConfig.js

@@ -1,5 +1,5 @@
-import { ParamTypes } from "../../core/params/paramTypes";
-import { isDefined, isString } from "../../../core/utils";
+import { ParamTypes } from "../params/paramTypes";
+import { isDefined, isString } from "../../shared/utils";
 /**
  * An API to customize the URL behavior and retrieve URL configuration
  *
@@ -14,21 +14,30 @@ import { isDefined, isString } from "../../../core/utils";
  * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
  */
 export class UrlConfig {
-  /** @internal */ constructor(/** @internal */ router) {
+  /**
+   * @param {import('../router').UIRouter} router
+   */
+  constructor(router) {
+    /** @type {import('../router').UIRouter} */
     this.router = router;
-    /** @internal */ this.paramTypes = new ParamTypes();
-    /** @internal */ this._decodeParams = true;
-    /** @internal */ this._isCaseInsensitive = false;
-    /** @internal */ this._isStrictMode = true;
-    /** @internal */ this._defaultSquashPolicy = false;
-    /** @internal */ this.dispose = () => this.paramTypes.dispose();
+    /** @type {ParamTypes} */
+    this.paramTypes = new ParamTypes();
+    /** @type {boolean} */
+    this._decodeParams = true;
+    /** @type {boolean} */
+    this._isCaseInsensitive = false;
+    /** @type {boolean} */
+    this._isStrictMode = true;
+    /** @type {boolean} */
+    this._defaultSquashPolicy = false;
+    this.dispose = () => this.paramTypes.dispose();
     // Delegate these calls to the current LocationConfig implementation
     /**
      * Gets the base Href, e.g., `http://localhost/approot/`
      *
      * @return the application's base href
      */
-    this.baseHref = () => this.router.locationConfig.baseHref();
+    this.baseHref = () => this.router.locationService.baseHref();
     /**
      * Gets or sets the hashPrefix
      *
@@ -39,31 +48,31 @@ export class UrlConfig {
      * @return the hash prefix
      */
     this.hashPrefix = (newprefix) =>
-      this.router.locationConfig.hashPrefix(newprefix);
+      this.router.locationService.$locationProvider.hashPrefix(newprefix);
     /**
      * Gets the host, e.g., `localhost`
      *
-     * @return the protocol
+     * @return {string} the protocol
      */
-    this.host = () => this.router.locationConfig.host();
+    this.host = () => this.router.locationService.$location.host();
     /**
      * Returns true when running in pushstate mode
      *
-     * @return true when running in html5 mode (pushstate mode).
+     * @return {boolean} true when running in html5 mode (pushstate mode).
      */
-    this.html5Mode = () => this.router.locationConfig.html5Mode();
+    this.html5Mode = () => this.router.locationService.html5Mode();
     /**
      * Gets the port, e.g., `80`
      *
-     * @return the port number
+     * @return {number} the port number
      */
-    this.port = () => this.router.locationConfig.port();
+    this.port = () => this.router.locationService.$location.port();
     /**
      * Gets the protocol, e.g., `http`
      *
-     * @return the protocol
+     * @return {string} the protocol
      */
-    this.protocol = () => this.router.locationConfig.protocol();
+    this.protocol = () => this.router.locationService.$location.protocol();
   }
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.

package/src/router/{core/url → url}/urlMatcher.js

@@ -9,11 +9,11 @@ import {
   unnestR,
   arrayTuples,
   defaults,
-} from "../common/common";
-import { prop, propEq } from "../common/hof";
-import { isArray, isString, isDefined } from "../common/predicates";
+} from "../../shared/common";
+import { prop, propEq } from "../../shared/hof";
+import { isDefined, isString } from "../../shared/utils";
 import { Param, DefType } from "../params/param";
-import { joinNeighborsR, splitOnDelim } from "../common/strings";
+import { joinNeighborsR, splitOnDelim } from "../../shared/strings";
 function quoteRegExp(str, param) {
   let surroundPattern = ["", ""],
     result = str.replace(/[\\\[\]\^$*+?.()|{}]/g, "\\$&");
@@ -94,7 +94,6 @@ const defaultConfig = {
  *
  */
 export class UrlMatcher {
-  /** @internal */
   static encodeDashes(str) {
     // Replace dashes with encoded "\-"
     return encodeURIComponent(str).replace(
@@ -185,15 +184,14 @@ export class UrlMatcher {
    * @param config  A [[UrlMatcherCompileConfig]] configuration object
    */
   constructor(pattern, paramTypes, paramFactory, config) {
-    /** @internal */
     this._cache = { path: [this] };
-    /** @internal */
+
     this._children = [];
-    /** @internal */
+
     this._params = [];
-    /** @internal */
+
     this._segments = [];
-    /** @internal */
+
     this._compiled = [];
     this.config = config = defaults(config, defaultConfig);
     this.pattern = pattern;
@@ -306,7 +304,7 @@ export class UrlMatcher {
     };
     return url;
   }
-  /** @internal */
+
   isRoot() {
     return this._cache.path[0] === this;
   }
@@ -317,7 +315,7 @@ export class UrlMatcher {
   _getDecodedParamValue(value, param) {
     if (isDefined(value)) {
       if (this.config.decodeParams && !param.type.raw) {
-        if (isArray(value)) {
+        if (Array.isArray(value)) {
           value = value.map((paramValue) => decodeURIComponent(paramValue));
         } else {
           value = decodeURIComponent(value);
@@ -449,7 +447,7 @@ export class UrlMatcher {
     params = params || {};
     // I'm not sure why this checks only the param keys passed in, and not all the params known to the matcher
     const paramSchema = this.parameters().filter((paramDef) =>
-      params.hasOwnProperty(paramDef.id),
+      Object.prototype.hasOwnProperty.call(params, paramDef.id),
     );
     return paramSchema
       .map((paramDef) => validParamVal(paramDef, params[paramDef.id]))
@@ -515,7 +513,7 @@ export class UrlMatcher {
       if (squash !== false) return acc; // ?
       if (encoded == null) return acc;
       // If this parameter value is an array, encode the value using encodeDashes
-      if (isArray(encoded))
+      if (Array.isArray(encoded))
         return acc + map(encoded, UrlMatcher.encodeDashes).join("-");
       // If the parameter type is "raw", then do not encodeURIComponent
       if (param.raw) return acc + encoded;
@@ -528,7 +526,7 @@ export class UrlMatcher {
       .map((paramDetails) => {
         let { param, squash, encoded, isDefaultValue } = paramDetails;
         if (encoded == null || (isDefaultValue && squash !== false)) return;
-        if (!isArray(encoded)) encoded = [encoded];
+        if (!Array.isArray(encoded)) encoded = [encoded];
         if (encoded.length === 0) return;
         if (!param.raw) encoded = map(encoded, encodeURIComponent);
         return encoded.map((val) => `${param.id}=${val}`);
@@ -544,5 +542,5 @@ export class UrlMatcher {
     );
   }
 }
-/** @internal */
+
 UrlMatcher.nameValidator = /^\w+([-.]+\w+)*(?:\[\])?$/;