@angular-wave/angular.ts 0.0.27 → 0.0.28

package/src/router/transition/transition.js

@@ -35,20 +35,6 @@ const stateSelf = prop("self");
  * It has information about all states being entered and exited as a result of the transition.
  */
 export class Transition {
-  /**
-   * Creates the transition-level hook registration functions
-   * (which can then be used to register hooks)
-   */
-  createTransitionHookRegFns() {
-    this.router.transitionService._pluginapi
-      ._getEvents()
-      .filter((type) => type.hookPhase !== TransitionHookPhase.CREATE)
-      .forEach((type) => makeEvent(this, this.router.transitionService, type));
-  }
-
-  getHooks(hookName) {
-    return this._registeredHooks[hookName];
-  }
   /**
    * Creates a new Transition object.
    *
@@ -59,10 +45,12 @@ 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 {import('../router').UIRouter} router The [[UIRouter]] instance
+   * @param {import('../transition/transition-service').TransitionService} transitionService The [[TransitionService]] instance
    * @internal
    */
-  constructor(fromPath, targetState, router) {
+  constructor(fromPath, targetState, transitionService, globals) {
+    this.globals = globals;
+    this.transitionService = transitionService;
     this._deferred = services.$q.defer();
     /**
      * This promise is resolved or rejected based on the outcome of the Transition.
@@ -76,8 +64,7 @@ export class Transition {
 
     this._hookBuilder = new HookBuilder(this);
     /** Checks if this transition is currently active/running. */
-    this.isActive = () => this.router.globals.transition === this;
-    this.router = router;
+    this.isActive = () => this.globals.transition === this;
     this._targetState = targetState;
     if (!targetState.valid()) {
       throw new Error(targetState.error());
@@ -87,7 +74,7 @@ export class Transition {
       { current: val(this) },
       targetState.options(),
     );
-    this.$id = router.transitionService._transitionCount++;
+    this.$id = transitionService._transitionCount++;
     const toPath = PathUtils.buildToPath(fromPath, targetState);
     this._treeChanges = PathUtils.treeChanges(
       fromPath,
@@ -99,12 +86,28 @@ export class Transition {
       TransitionHookPhase.CREATE,
     );
     TransitionHook.invokeHooks(onCreateHooks, () => null);
-    this.applyViewConfigs(router);
+    this.applyViewConfigs();
+  }
+
+  /**
+   * Creates the transition-level hook registration functions
+   * (which can then be used to register hooks)
+   */
+  createTransitionHookRegFns() {
+    this.transitionService._pluginapi
+      ._getEvents()
+      .filter((type) => type.hookPhase !== TransitionHookPhase.CREATE)
+      .forEach((type) => makeEvent(this, this.transitionService, type));
+  }
+
+  getHooks(hookName) {
+    return this._registeredHooks[hookName];
   }
-  applyViewConfigs(router) {
+
+  applyViewConfigs() {
     const enteringStates = this._treeChanges.entering.map((node) => node.state);
     PathUtils.applyViewConfigs(
-      router.transitionService.$view,
+      this.transitionService.$view,
       this._treeChanges.to,
       enteringStates,
     );
@@ -475,7 +478,7 @@ export class Transition {
       redirectOpts,
     );
     targetState = targetState.withOptions(newOptions, true);
-    const newTransition = this.router.transitionService.create(
+    const newTransition = this.transitionService.create(
       this._treeChanges.from,
       targetState,
     );
@@ -557,7 +560,7 @@ export class Transition {
   }
 
   _ignoredReason() {
-    const pending = this.router.globals.transition;
+    const pending = this.globals.transition;
     const reloadState = this._options.reloadState;
     const same = (pathA, pathB) => {
       if (pathA.length !== pathB.length) return false;
@@ -619,7 +622,7 @@ export class Transition {
       return TransitionHook.invokeHooks(allRunHooks, done);
     };
     const startTransition = () => {
-      const globals = this.router.globals;
+      const globals = this.globals;
       globals.lastStartedTransitionId = this.$id;
       globals.transition = this;
       globals.transitionHistory.enqueue(this);

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

@@ -14,12 +14,7 @@ import { isDefined, isString } from "../../shared/utils";
  * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
  */
 export class UrlConfig {
-  /**
-   * @param {import('../router').UIRouter} router
-   */
-  constructor(router) {
-    /** @type {import('../router').UIRouter} */
-    this.router = router;
+  constructor() {
     /** @type {ParamTypes} */
     this.paramTypes = new ParamTypes();
     /** @type {boolean} */
@@ -30,49 +25,6 @@ export class UrlConfig {
     this._isStrictMode = true;
     /** @type {boolean} */
     this._defaultSquashPolicy = false;
-
-    // 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.urlService.baseHref();
-    /**
-     * Gets or sets the hashPrefix
-     *
-     * This only applies when not running in [[html5Mode]] (pushstate mode)
-     *
-     * If the current url is `http://localhost/app#!/uirouter/path/#anchor`, it returns `!` which is the prefix for the "hashbang" portion.
-     *
-     * @return the hash prefix
-     */
-    this.hashPrefix = (newprefix) =>
-      this.router.$locationProvider.hashPrefix(newprefix);
-    /**
-     * Gets the host, e.g., `localhost`
-     *
-     * @return {string} the protocol
-     */
-    this.host = () => this.router.urlService.$location.host();
-    /**
-     * Returns true when running in pushstate mode
-     *
-     * @return {boolean} true when running in html5 mode (pushstate mode).
-     */
-    this.html5Mode = () => this.router.urlService.html5Mode();
-    /**
-     * Gets the port, e.g., `80`
-     *
-     * @return {number} the port number
-     */
-    this.port = () => this.router.urlService.$location.port();
-    /**
-     * Gets the protocol, e.g., `http`
-     *
-     * @return {string} the protocol
-     */
-    this.protocol = () => this.router.urlService.$location.protocol();
   }
   /**
    * Defines whether URL matching should be case sensitive (the default behavior), or not.

package/src/router/url/url-matcher-factory.js

@@ -1,40 +1,7 @@
 import { forEach, isDefined, isFunction, isObject } from "../../shared/utils";
 import { UrlMatcher } from "./url-matcher";
-import { DefType, Param } from "../params/param";
+import { ParamFactory } from "../params/param-factory";
 
-export class ParamFactory {
-  constructor(router) {
-    this.router = router;
-  }
-
-  fromConfig(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.CONFIG,
-      this.router.urlService.config,
-      state,
-    );
-  }
-  fromPath(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.PATH,
-      this.router.urlService.config,
-      state,
-    );
-  }
-  fromSearch(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.SEARCH,
-      this.router.urlService.config,
-      state,
-    );
-  }
-}
 /**
  * Factory for [[UrlMatcher]] instances.
  *
@@ -43,28 +10,20 @@ export class ParamFactory {
  */
 export class UrlMatcherFactory {
   // TODO: move implementations to UrlConfig (urlService.config)
-  constructor(router) {
-    this.router = router;
+  constructor(urlServiceConfig) {
+    this.urlServiceConfig = urlServiceConfig;
     /** Creates a new [[Param]] for a given location (DefType) */
-    this.paramFactory = new ParamFactory(this.router);
-    // TODO: Check if removal of this will break anything, then remove these
-    this.UrlMatcher = UrlMatcher;
-    this.Param = Param;
+    this.paramFactory = new ParamFactory(urlServiceConfig);
     /** @deprecated use [[UrlConfig.caseInsensitive]] */
-    this.caseInsensitive = (value) =>
-      this.router.urlService.config.caseInsensitive(value);
+    this.caseInsensitive = (value) => urlServiceConfig.caseInsensitive(value);
     /** @deprecated use [[UrlConfig.defaultSquashPolicy]] */
     this.defaultSquashPolicy = (value) =>
-      this.router.urlService.config.defaultSquashPolicy(value);
+      urlServiceConfig.defaultSquashPolicy(value);
     /** @deprecated use [[UrlConfig.strictMode]] */
-    this.strictMode = (value) =>
-      this.router.urlService.config.strictMode(value);
+    this.strictMode = (value) => urlServiceConfig.strictMode(value);
     /** @deprecated use [[UrlConfig.type]] */
     this.type = (name, definition, definitionFn) => {
-      return (
-        this.router.urlService.config.type(name, definition, definitionFn) ||
-        this
-      );
+      return urlServiceConfig.type(name, definition, definitionFn) || this;
     };
   }
   /**
@@ -75,7 +34,7 @@ export class UrlMatcherFactory {
    * @returns The UrlMatcher.
    */
   compile(pattern, config) {
-    const urlConfig = this.router.urlService.config;
+    const urlConfig = this.urlServiceConfig;
     // backward-compatible support for config.params -> config.state.params
     const params = config && !config.state && config.params;
     config = params ? Object.assign({ state: { params } }, config) : config;
@@ -110,7 +69,7 @@ export class UrlMatcherFactory {
   }
 
   $get() {
-    const urlConfig = this.router.urlService.config;
+    const urlConfig = this.urlServiceConfig;
     urlConfig.paramTypes.enqueue = false;
     urlConfig.paramTypes._flushTypeQueue();
     return this;

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

@@ -1,5 +1,5 @@
 import { stripLastPathElement } from "../../shared/strings";
-import { UrlRuleFactory } from "./url-rule";
+
 function appendBasePath(url, isHtml5, absolute, baseHref) {
   if (baseHref === "/") return url;
   if (isHtml5) return stripLastPathElement(baseHref) + url;
@@ -16,16 +16,16 @@ function appendBasePath(url, isHtml5, absolute, baseHref) {
  */
 export class UrlRouter {
   /**
-   *
-   * @param {import('../router').UIRouter} router
+   * @param {angular.UrlService} urlService
    */
-  constructor(router) {
-    this.router = router;
-    this.urlRuleFactory = new UrlRuleFactory(router);
+  constructor(urlService, urlRuleFactory, $locationProvider) {
+    this.urlService = urlService;
+    this.urlRuleFactory = urlRuleFactory;
+    this.$locationProvider = $locationProvider;
   }
-  /** Internal API. */
+
   update(read) {
-    const $url = this.router.urlService;
+    const $url = this.urlService;
     if (read) {
       this.location = $url.url();
       return;
@@ -34,8 +34,6 @@ export class UrlRouter {
     $url.url(this.location, true);
   }
   /**
-   * Internal API.
-   *
    * Pushes a new location to the browser history.
    *
    * @internal
@@ -45,7 +43,7 @@ export class UrlRouter {
    */
   push(urlMatcher, params, options) {
     const replace = options && !!options.replace;
-    this.router.urlService.url(urlMatcher.format(params || {}), replace);
+    this.urlService.url(urlMatcher.format(params || {}), replace);
   }
   /**
    * Builds and returns a URL with interpolated parameters
@@ -70,18 +68,30 @@ export class UrlRouter {
     let url = urlMatcher.format(params);
     if (url == null) return null;
     options = options || { absolute: false };
-    const cfg = this.router.urlService.config;
-    const isHtml5 = cfg.html5Mode();
+    const cfg = this.urlService.config;
+    const isHtml5 = this.urlService.html5Mode();
     if (!isHtml5 && url !== null) {
-      url = "#" + cfg.hashPrefix() + url;
+      url = "#" + this.$locationProvider.hashPrefix() + url;
     }
-    url = appendBasePath(url, isHtml5, options.absolute, cfg.baseHref());
+    url = appendBasePath(
+      url,
+      isHtml5,
+      options.absolute,
+      this.urlService.baseHref(),
+    );
     if (!options.absolute || !url) {
       return url;
     }
     const slash = !isHtml5 && url ? "/" : "";
-    const cfgPort = cfg.port();
+    const cfgPort = this.urlService.$location.port();
     const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
-    return [cfg.protocol(), "://", cfg.host(), port, slash, url].join("");
+    return [
+      cfg.protocol(),
+      "://",
+      this.urlService.$location.host(),
+      port,
+      slash,
+      url,
+    ].join("");
   }
 }

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

@@ -13,12 +13,10 @@ import { StateObject } from "../state/state-object";
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
-  constructor(router) {
-    this.router = router;
-  }
-
-  compile(str) {
-    return this.router.urlMatcherFactory.compile(str);
+  constructor(urlMatcherFactory, stateService, routerGlobals) {
+    this.urlMatcherFactory = urlMatcherFactory;
+    this.stateService = stateService;
+    this.routerGlobals = routerGlobals;
   }
 
   /**
@@ -30,11 +28,11 @@ export class UrlRuleFactory {
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
-      [isString, (_what) => makeRule(this.compile(_what))],
+      [isString, (_what) => makeRule(this.urlMatcherFactory.compile(_what))],
       [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
       [
         or(isState, isStateDeclaration),
-        (_what) => this.fromState(_what, this.router),
+        (_what) => this.fromState(_what, this.stateService, this.routerGlobals),
       ],
       [is(RegExp), (_what) => this.fromRegExp(_what, handler)],
       [isFunction, (_what) => new BaseUrlRule(_what, handler)],
@@ -81,8 +79,7 @@ export class UrlRuleFactory {
    */
   fromUrlMatcher(urlMatcher, handler) {
     let _handler = handler;
-    if (isString(handler))
-      handler = this.router.urlMatcherFactory.compile(handler);
+    if (isString(handler)) handler = this.urlMatcherFactory.compile(handler);
     if (is(UrlMatcher)(handler)) _handler = (match) => handler.format(match);
     function matchUrlParamters(url) {
       const params = urlMatcher.exec(url.path, url.search, url.hash);
@@ -115,7 +112,7 @@ export class UrlRuleFactory {
    * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }
    * ```
    */
-  fromState(stateOrDecl, router) {
+  fromState(stateOrDecl, stateService, globals) {
     const state = StateObject.isStateDeclaration(stateOrDecl)
       ? stateOrDecl.$$state()
       : stateOrDecl;
@@ -127,8 +124,7 @@ export class UrlRuleFactory {
      * and the new URL are already identical
      */
     const handler = (match) => {
-      const $state = router.stateService;
-      const globals = router.globals;
+      const $state = stateService;
       if (
         $state.href(state, match) !==
         $state.href(globals.current, globals.params)

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

@@ -62,14 +62,14 @@ function getHandlerFn(handler) {
  *
  * The most commonly used methods are [[otherwise]] and [[when]].
  *
- * This API is found at `router.urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+ * This API is found at `$urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
  */
 export class UrlRules {
-  constructor(router) {
+  constructor(urlRuleFactory) {
     this._sortFn = defaultRuleSortFn;
     this._rules = [];
     this._id = 0;
-    this.urlRuleFactory = new UrlRuleFactory(router);
+    this.urlRuleFactory = urlRuleFactory;
   }
 
   /**

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

@@ -4,20 +4,16 @@ import { UrlRules } from "./url-rules";
 import { UrlConfig } from "./url-config";
 import { TargetState } from "../state/target-state";
 import { removeFrom } from "../../shared/common";
+
 /**
  * API for URL management
  */
 export class UrlService {
   /**
-   *
-   * @param {import('../router').UIRouter} router
    * @param {angular.ILocationProvider} $locationProvider
    */
-  constructor(router, $locationProvider) {
-    /**
-     * @type {import('../router').UIRouter}
-     */
-    this.router = router;
+  constructor($locationProvider, urlRuleFactory, stateService) {
+    this.stateService = stateService;
 
     this.$locationProvider = $locationProvider;
 
@@ -29,14 +25,14 @@ export class UrlService {
      * See: [[UrlRules]] for details
      * @type {UrlRules}
      */
-    this.rules = new UrlRules(this.router);
+    this.rules = new UrlRules(urlRuleFactory);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
      *
      * See: [[UrlConfig]] for details
      * @type {UrlConfig}
      */
-    this.config = new UrlConfig(this.router);
+    this.config = new UrlConfig();
 
     /**
      * Gets the path part of the current url
@@ -188,15 +184,18 @@ export class UrlService {
    */
   sync(evt) {
     if (evt && evt.defaultPrevented) return;
-    const { urlService, stateService } = this.router;
+    const stateService = this.stateService;
     const url = {
-      path: urlService.path(),
-      search: urlService.search(),
-      hash: urlService.hash(),
+      path: this.path(),
+      search: this.search(),
+      hash: this.hash(),
     };
+    /**
+     * @type {angular.MatchResult}
+     */
     const best = this.match(url);
     const applyResult = pattern([
-      [isString, (newurl) => urlService.url(newurl, true)],
+      [isString, (newurl) => this.url(newurl, true)],
       [
         TargetState.isDef,
         (def) => stateService.go(def.state, def.params, def.options),
@@ -207,7 +206,8 @@ export class UrlService {
           stateService.go(target.state(), target.params(), target.options()),
       ],
     ]);
-    applyResult(best && best.rule.handler(best.match, url, this.router));
+
+    applyResult(best && best.rule.handler(best.match, url));
   }
   /**
    * Starts or stops listening for URL changes
@@ -237,8 +237,7 @@ export class UrlService {
       delete this._stopListeningFn;
     } else {
       return (this._stopListeningFn =
-        this._stopListeningFn ||
-        this.router.urlService.onChange((evt) => this.sync(evt)));
+        this._stopListeningFn || this.onChange((evt) => this.sync(evt)));
     }
   }
   /**
@@ -274,13 +273,18 @@ export class UrlService {
    *
    * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
    * Return the result as a [[MatchResult]].
+   * @returns {angular.MatchResult}
    */
   match(url) {
     url = Object.assign({ path: "", search: {}, hash: "" }, url);
     const rules = this.rules.rules();
     // Checks a single rule. Returns { rule: rule, match: match, weight: weight } if it matched, or undefined
+    /**
+     *
+     * @param {import("./url-rule").BaseUrlRule} rule
+     */
     const checkRule = (rule) => {
-      const match = rule.match(url, this.router);
+      const match = rule.match(url);
       return match && { match, rule, weight: rule.matchPriority(match) };
     };
     // The rules are pre-sorted.

package/src/router/view/view.js

@@ -26,9 +26,9 @@ import { trace } from "../common/trace";
  */
 export class ViewService {
   /**
-   * @param {import('../router').UIRouter} router
+   * @param {number} $id
    */
-  constructor(router) {
+  constructor($id) {
     this._uiViews = [];
     this._viewConfigs = [];
     this._viewConfigFactories = {};
@@ -37,7 +37,7 @@ export class ViewService {
       _rootViewContext: this._rootViewContext.bind(this),
       _viewConfigFactory: this._viewConfigFactory.bind(this),
       _registeredUIView: (id) =>
-        find(this._uiViews, (view) => `${router.$id}.${view.id}` === id),
+        find(this._uiViews, (view) => `${$id}.${view.id}` === id),
       _registeredUIViews: () => this._uiViews,
       _activeViewConfigs: () => this._viewConfigs,
       _onSync: (listener) => {

package/src/shared/hof.js

@@ -77,7 +77,7 @@ export function compose() {
  * let piped = pipe(f,g,h);
  * then, piped is: h(g(f(x)))
  */
-export function pipe(...funcs) {
+export function pipe() {
   return compose.apply(null, [].slice.call(arguments).reverse());
 }
 /**

package/test/angular.spec.js

@@ -48,6 +48,7 @@ describe("angular", () => {
 
   afterEach(() => {
     dealoc(element);
+    jqLite.CACHE.clear();
   });
 
   describe("case", () => {

package/test/aria/aria.spec.js

@@ -1,6 +1,6 @@
 import { createInjector } from "../../src/injector";
 import { publishExternalAPI } from "../../src/public";
-import { dealoc } from "../../src/jqLite";
+import { dealoc, jqLite } from "../../src/jqLite";
 
 describe("$aria", () => {
   let scope;
@@ -17,6 +17,7 @@ describe("$aria", () => {
 
   afterEach(() => {
     dealoc(element);
+    jqLite.CACHE.clear();
   });
 
   describe("with `ngAriaDisable`", () => {