@angular-wave/angular.ts 0.0.23 → 0.0.25

package/src/router/{templateFactory.js → template-factory.js}

@@ -1,29 +1,48 @@
-/** @publicapi @module view */ /** */
 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";
 
+/**
+ * @typedef BindingTuple
+ * @property {string} name
+ * @property {string} type
+ */
+
 /**
  * Service which manages loading of templates from a ViewConfig.
  */
 export class TemplateFactory {
   constructor() {
+    /** @type {boolean} */
     this._useHttp = false;
-    this.$get = [
-      "$http",
-      "$templateCache",
-      "$templateRequest",
-      ($http, $templateCache, $templateRequest) => {
-        this.$templateRequest = $templateRequest;
-        this.$http = $http;
-        this.$templateCache = $templateCache;
-        return this;
-      },
-    ];
   }
 
+  $get = [
+    "$http",
+    "$templateCache",
+    "$templateRequest",
+    "$q",
+    "$injector",
+    /**
+     * @param {angular.IHttpService} $http
+     * @param {angular.ITemplateCacheService} $templateCache
+     * @param {angular.ITemplateRequestService} $templateRequest
+     * @param {angular.IQService} $q
+     * @param {angular.auto.IInjectorService} $injector
+     * @returns
+     */
+    ($http, $templateCache, $templateRequest, $q, $injector) => {
+      this.$templateRequest = $templateRequest;
+      this.$http = $http;
+      this.$templateCache = $templateCache;
+      this.$q = $q;
+      this.$injector = $injector;
+      return this;
+    },
+  ];
+
   /**
    * Forces the provider to use $http service directly
    * @param {boolean} value
@@ -39,8 +58,9 @@ export class TemplateFactory {
    * The following properties are search in the specified order, and the first one
    * that is defined is used to create the template:
    *
-   * @param params  Parameters to pass to the template function.
-   * @param context The resolve context associated with the template's view
+   * @param {angular.Ng1ViewDeclaration} config
+   * @param {any} params  Parameters to pass to the template function.
+   * @param {angular.ResolveContext} context The resolve context associated with the template's view
    *
    * @return {string|object}  The template html as a string, or a promise for
    * that string,or `null` if no template is configured.
@@ -48,34 +68,43 @@ export class TemplateFactory {
   fromConfig(config, params, context) {
     const defaultTemplate = "<ui-view></ui-view>";
     const asTemplate = (result) =>
-      services.$q.when(result).then((str) => ({ template: str }));
+      this.$q.when(result).then((str) => ({ template: str }));
     const asComponent = (result) =>
-      services.$q.when(result).then((str) => ({ component: str }));
-    return isDefined(config.template)
-      ? asTemplate(this.fromString(config.template, params))
-      : isDefined(config.templateUrl)
-        ? asTemplate(this.fromUrl(config.templateUrl, params))
-        : isDefined(config.templateProvider)
-          ? asTemplate(
-              this.fromProvider(config.templateProvider, params, context),
-            )
-          : isDefined(config.component)
-            ? asComponent(config.component)
-            : isDefined(config.componentProvider)
-              ? asComponent(
-                  this.fromComponentProvider(
-                    config.componentProvider,
-                    params,
-                    context,
-                  ),
-                )
-              : asTemplate(defaultTemplate);
+      this.$q.when(result).then((str) => ({ component: str }));
+
+    const getConfigType = (config) => {
+      if (isDefined(config.template)) return "template";
+      if (isDefined(config.templateUrl)) return "templateUrl";
+      if (isDefined(config.templateProvider)) return "templateProvider";
+      if (isDefined(config.component)) return "component";
+      if (isDefined(config.componentProvider)) return "componentProvider";
+      return "default";
+    };
+
+    switch (getConfigType(config)) {
+      case "template":
+        return asTemplate(this.fromString(config.template, params));
+      case "templateUrl":
+        return asTemplate(this.fromUrl(config.templateUrl, params));
+      case "templateProvider":
+        return asTemplate(
+          this.fromProvider(config.templateProvider, params, context),
+        );
+      case "component":
+        return asComponent(config.component);
+      case "componentProvider":
+        return asComponent(
+          this.fromComponentProvider(config.componentProvider, params, context),
+        );
+      default:
+        return asTemplate(defaultTemplate);
+    }
   }
   /**
    * Creates a template from a string or a function returning a string.
    *
-   * @param template html template as a string or function that returns an html template as a string.
-   * @param params Parameters to pass to the template function.
+   * @param {string | Function} template html template as a string or function that returns an html template as a string.
+   * @param {angular.RawParams} [params] Parameters to pass to the template function.
    *
    * @return {string|object} The template html as a string, or a promise for that
    * string.
@@ -110,13 +139,14 @@ export class TemplateFactory {
   /**
    * Creates a template by invoking an injectable provider function.
    *
-   * @param provider Function to invoke via `locals`
+   * @param {angular.IInjectable} provider Function to invoke via `locals`
    * @param {Function} injectFn a function used to invoke the template provider
+   * @param {angular.ResolveContext} context
    * @return {string|Promise.<string>} The template html as a string, or a promise
    * for that string.
    */
   fromProvider(provider, params, context) {
-    const deps = services.$injector.annotate(provider);
+    const deps = this.$injector.annotate(provider);
     const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
@@ -124,12 +154,12 @@ export class TemplateFactory {
   /**
    * Creates a component's template by invoking an injectable provider function.
    *
-   * @param provider Function to invoke via `locals`
+   * @param {angular.IInjectable} provider Function to invoke via `locals`
    * @param {Function} injectFn a function used to invoke the template provider
    * @return {string} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
    */
   fromComponentProvider(provider, params, context) {
-    const deps = services.$injector.annotate(provider);
+    const deps = this.$injector.annotate(provider);
     const providerFn = Array.isArray(provider) ? tail(provider) : provider;
     const resolvable = new Resolvable("", providerFn, deps);
     return resolvable.get(context);
@@ -142,10 +172,10 @@ export class TemplateFactory {
    * It analyses the component's bindings, then constructs a template that instantiates the component.
    * The template wires input and output bindings to resolves or from the parent component.
    *
-   * @param uiView {object} The parent ui-view (for binding outputs to callbacks)
-   * @param context The ResolveContext (for binding outputs to callbacks returned from resolves)
-   * @param component {string} Component's name in camel case.
-   * @param bindings An object defining the component's bindings: {foo: '<'}
+   * @param {angular.IAugmentedJQuery} uiView {object} The parent ui-view (for binding outputs to callbacks)
+   * @param {angular.ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
+   * @param {string} component {string} Component's name in camel case.
+   * @param {any} [bindings] An object defining the component's bindings: {foo: '<'}
    * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".
    */
   makeComponentTemplate(uiView, context, component, bindings) {
@@ -157,7 +187,8 @@ export class TemplateFactory {
       const kebobed = kebobString(camelCase);
       return /^(x|data)-/.exec(kebobed) ? `x-${kebobed}` : kebobed;
     };
-    const attributeTpl = (input) => {
+
+    const attributeTpl = /** @param {BindingTuple} input*/ (input) => {
       const { name, type } = input;
       const attrName = kebob(name);
       // If the ui-view has an attribute which matches a binding on the routed component
@@ -176,7 +207,7 @@ export class TemplateFactory {
       if (type === "&") {
         const res = context.getResolvable(resolveName);
         const fn = res && res.data;
-        const args = (fn && services.$injector.annotate(fn)) || [];
+        const args = (fn && this.$injector.annotate(fn)) || [];
         // account for array style injection, i.e., ['foo', function(foo) {}]
         const arrayIdxStr = Array.isArray(fn) ? `[${fn.length - 1}]` : "";
         return `${attrName}='$resolve.${resolveName}${arrayIdxStr}(${args.join(",")})'`;
@@ -189,7 +220,12 @@ export class TemplateFactory {
     return `<${kebobName} ${attrs}></${kebobName}>`;
   }
 }
-// Gets all the directive(s)' inputs ('@', '=', and '<') and outputs ('&')
+
+/**
+ * Gets all the directive(s)' inputs ('@', '=', and '<') and outputs ('&')
+ * @param {string} name
+ * @returns
+ */
 function getComponentBindings(name) {
   const cmpDefs = services.$injector.get(name + "Directive"); // could be multiple
   if (!cmpDefs || !cmpDefs.length)

package/src/router/transition/{hookBuilder.js → hook-builder.js}

@@ -1,6 +1,6 @@
-import { assertPredicate, unnestR, identity } from "../../shared/common";
+import { assertPredicate, unnestR } from "../../shared/common";
 import { TransitionHookPhase, TransitionHookScope } from "./interface";
-import { TransitionHook } from "./transitionHook";
+import { TransitionHook } from "./transition-hook";
 /**
  * This class returns applicable TransitionHooks for a specific Transition instance.
  *
@@ -24,7 +24,7 @@ export class HookBuilder {
       ._getEvents(phase)
       .map((type) => this.buildHooks(type))
       .reduce(unnestR, [])
-      .filter(identity);
+      .filter(Boolean);
   }
   /**
    * Returns an array of newly built TransitionHook objects.

package/src/router/transition/{transitionEventType.js → transition-event-type.js}

@@ -1,4 +1,4 @@
-import { TransitionHook } from "./transitionHook";
+import { TransitionHook } from "./transition-hook";
 /**
  * This class defines a type of hook, such as `onBefore` or `onEnter`.
  * Plugins can define custom hook types, such as sticky states does for `onInactive`.

package/src/router/transition/{transitionHook.js → transition-hook.js}

@@ -5,8 +5,8 @@ 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";
-import { TargetState } from "../state/targetState";
+import { Rejection } from "./reject-factory";
+import { TargetState } from "../state/target-state";
 const defaultOptions = {
   current: () => {},
   transition: null,

package/src/router/transition/{transitionService.js → transition-service.js}

@@ -1,16 +1,16 @@
 import { TransitionHookScope, TransitionHookPhase } from "./interface";
 import { Transition } from "./transition";
-import { makeEvent } from "./hookRegistry";
+import { makeEvent } from "./hook-registry";
 import {
   registerAddCoreResolvables,
   treeChangesCleanup,
-} from "../hooks/coreResolvables";
-import { registerRedirectToHook } from "../hooks/redirectTo";
+} from "../hooks/core-resolvables";
+import { registerRedirectToHook } from "../hooks/redirect-to";
 import {
   registerOnExitHook,
   registerOnRetainHook,
   registerOnEnterHook,
-} from "../hooks/onEnterExitRetain";
+} from "../hooks/on-enter-exit-retain";
 import {
   registerEagerResolvePath,
   registerLazyResolveState,
@@ -20,16 +20,16 @@ import {
   registerLoadEnteringViews,
   registerActivateViews,
 } from "../hooks/views";
-import { registerUpdateGlobalState } from "../hooks/updateGlobals";
+import { registerUpdateGlobalState } from "../hooks/update-globals";
 import { registerUpdateUrl } from "../hooks/url";
-import { registerLazyLoadHook } from "../hooks/lazyLoad";
-import { TransitionEventType } from "./transitionEventType";
-import { TransitionHook } from "./transitionHook";
+import { registerLazyLoadHook } from "../hooks/lazy-load";
+import { TransitionEventType } from "./transition-event-type";
+import { TransitionHook } from "./transition-hook";
 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";
+import { registerIgnoredTransitionHook } from "../hooks/ignored-transition";
+import { registerInvalidTransitionHook } from "../hooks/invalid-transition";
 /**
  * The default [[Transition]] options.
  *
@@ -109,46 +109,12 @@ export class TransitionService {
    * @param options the registration options
    * @returns a function which deregisters the hook.
    */
-  onCreate(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onBefore(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onStart(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onExit(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onRetain(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onEnter(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onFinish(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onSuccess(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onError(criteria, callback, options) {
-    return;
-  }
+
   /**
    * dispose
    * @internal
    */
-  dispose(router) {
+  dispose() {
     Object.values(this._registeredHooks).forEach((hooksArray) =>
       hooksArray.forEach((hook) => {
         hook._deregistered = true;

package/src/router/transition/transition.js

@@ -9,7 +9,6 @@ import {
   omit,
   arrayTuples,
   unnestR,
-  identity,
   anyTrueR,
   flattenR,
   uniqR,
@@ -17,14 +16,14 @@ import {
 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";
-import { HookBuilder } from "./hookBuilder";
-import { PathUtils } from "../path/pathUtils";
+import { TransitionHook } from "./transition-hook";
+import { matchState, makeEvent } from "./hook-registry";
+import { HookBuilder } from "./hook-builder";
+import { PathUtils } from "../path/path-utils";
 import { Param } from "../params/param";
 import { Resolvable } from "../resolve/resolvable";
-import { ResolveContext } from "../resolve/resolveContext";
-import { Rejection } from "./rejectFactory";
+import { ResolveContext } from "../resolve/resolve-context";
+import { Rejection } from "./reject-factory";
 
 const stateSelf = prop("self");
 /**
@@ -36,38 +35,7 @@ const stateSelf = prop("self");
  * It has information about all states being entered and exited as a result of the transition.
  */
 export class Transition {
-  onBefore(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onStart(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onExit(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onRetain(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onEnter(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onFinish(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onSuccess(criteria, callback, options) {
-    return;
-  }
-  /** @inheritdoc */
-  onError(criteria, callback, options) {
-    return;
-  }
-  /** @internal
+  /**
    * Creates the transition-level hook registration functions
    * (which can then be used to register hooks)
    */
@@ -466,7 +434,7 @@ export class Transition {
   views(pathname = "entering", state) {
     let path = this._treeChanges[pathname];
     path = !state ? path : path.filter(propEq("state", state));
-    return path.map(prop("views")).filter(identity).reduce(unnestR, []);
+    return path.map(prop("views")).reduce(unnestR, []);
   }
   treeChanges(pathname) {
     return pathname ? this._treeChanges[pathname] : this._treeChanges;

package/src/router/url/{urlConfig.js → url-config.js}

@@ -1,4 +1,4 @@
-import { ParamTypes } from "../params/paramTypes";
+import { ParamTypes } from "../params/param-types";
 import { isDefined, isString } from "../../shared/utils";
 /**
  * An API to customize the URL behavior and retrieve URL configuration

package/src/router/url/{urlMatcherFactory.js → url-matcher-factory.js}

@@ -1,5 +1,5 @@
 import { forEach, isDefined, isFunction, isObject } from "../../shared/utils";
-import { UrlMatcher } from "./urlMatcher";
+import { UrlMatcher } from "./url-matcher";
 import { DefType, Param } from "../params/param";
 
 export class ParamFactory {

package/src/router/url/{urlMatcher.js → url-matcher.js}

@@ -1,7 +1,6 @@
 import {
   map,
   inherit,
-  identity,
   unnest,
   tail,
   find,
@@ -530,7 +529,6 @@ export class UrlMatcher {
         if (!param.raw) encoded = map(encoded, encodeURIComponent);
         return encoded.map((val) => `${param.id}=${val}`);
       })
-      .filter(identity)
       .reduce(unnestR, [])
       .join("&");
     // Concat the pathstring with the queryString (if exists) and the hashString (if exists)

package/src/router/url/{urlRouter.js → url-router.js}

@@ -1,5 +1,5 @@
 import { stripLastPathElement } from "../../shared/strings";
-import { UrlRuleFactory } from "./urlRule";
+import { UrlRuleFactory } from "./url-rule";
 function appendBasePath(url, isHtml5, absolute, baseHref) {
   if (baseHref === "/") return url;
   if (isHtml5) return stripLastPathElement(baseHref) + url;
@@ -84,8 +84,4 @@ export class UrlRouter {
     const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
     return [cfg.protocol(), "://", cfg.host(), port, slash, url].join("");
   }
-  /** @deprecated use [[UrlService.interceptDeferred]]*/
-  get interceptDeferred() {
-    return this.router.urlService.interceptDeferred;
-  }
 }

package/src/router/url/{urlRule.js → url-rule.js}

@@ -1,8 +1,7 @@
-import { UrlMatcher } from "./urlMatcher";
+import { UrlMatcher } from "./url-matcher";
 import { isString, isFunction, isDefined } from "../../shared/utils";
-import { identity } from "../../shared/common";
 import { is, or, pattern } from "../../shared/hof";
-import { StateObject } from "../state/stateObject";
+import { StateObject } from "../state/state-object";
 /**
  * Creates a [[UrlRule]]
  *
@@ -17,6 +16,7 @@ export class UrlRuleFactory {
   constructor(router) {
     this.router = router;
   }
+
   compile(str) {
     return this.router.urlMatcherFactory.compile(str);
   }
@@ -208,6 +208,6 @@ export class BaseUrlRule {
     this.type = "RAW";
     this.$id = -1;
     this.matchPriority = () => 0 - this.$id;
-    this.handler = handler || identity;
+    this.handler = handler || ((x) => x);
   }
 }

package/src/router/url/{urlRules.js → url-rules.js}

@@ -1,9 +1,9 @@
-import { TargetState } from "../state/targetState";
-import { UrlMatcher } from "./urlMatcher";
+import { TargetState } from "../state/target-state";
+import { UrlMatcher } from "./url-matcher";
 import { is, val } from "../../shared/hof";
 import { isDefined, isFunction, isString } from "../../shared/utils";
 import { removeFrom } from "../../shared/common";
-import { UrlRuleFactory } from "./urlRule";
+import { UrlRuleFactory } from "./url-rule";
 const prioritySort = (a, b) => (b.priority || 0) - (a.priority || 0);
 const typeSort = (a, b) => {
   const weights = { STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1 };
@@ -66,7 +66,6 @@ function getHandlerFn(handler) {
  */
 export class UrlRules {
   constructor(router) {
-    this.router = router;
     this._sortFn = defaultRuleSortFn;
     this._rules = [];
     this._id = 0;

package/src/router/url/{urlService.js → url-service.js}

@@ -1,8 +1,8 @@
 import { isString } from "../../shared/utils";
 import { is, pattern } from "../../shared/hof";
-import { UrlRules } from "./urlRules";
-import { UrlConfig } from "./urlConfig";
-import { TargetState } from "../state/targetState";
+import { UrlRules } from "./url-rules";
+import { UrlConfig } from "./url-config";
+import { TargetState } from "../state/target-state";
 /**
  * API for URL management
  */
@@ -16,17 +16,21 @@ export class UrlService {
      * @type {import('../router').UIRouter}
      */
     this.router = router;
+
+    /** @type {boolean} */
     this.interceptDeferred = false;
     /**
      * The nested [[UrlRules]] API for managing URL rules and rewrites
      *
      * See: [[UrlRules]] for details
+     * @type {UrlRules}
      */
     this.rules = new UrlRules(this.router);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
      *
      * See: [[UrlConfig]] for details
+     * @type {UrlConfig}
      */
     this.config = new UrlConfig(this.router);
     // Delegate these calls to the current LocationServices implementation
@@ -74,11 +78,11 @@ export class UrlService {
      * locationServices.url("/some/path?query=value#anchor", true);
      * ```
      *
-     * @param newurl The new value for the URL.
+     * @param {string} newurl The new value for the URL.
      *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
      *               It should not include the protocol, site, port, or base path of an absolute HREF.
-     * @param replace When true, replaces the current history entry (instead of appending it) with this new url
-     * @param state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+     * @param {boolean} replace When true, replaces the current history entry (instead of appending it) with this new url
+     * @param {any} state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
      *
      * @return the url (after potentially being processed)
      */

package/src/router/view/view.js

@@ -29,10 +29,6 @@ export class ViewService {
    * @param {import('../router').UIRouter} router
    */
   constructor(router) {
-    /**
-     * @type {import('../router').UIRouter}
-     */
-    this.router = router;
     this._uiViews = [];
     this._viewConfigs = [];
     this._viewConfigFactories = {};
@@ -41,7 +37,7 @@ export class ViewService {
       _rootViewContext: this._rootViewContext.bind(this),
       _viewConfigFactory: this._viewConfigFactory.bind(this),
       _registeredUIView: (id) =>
-        find(this._uiViews, (view) => `${this.router.$id}.${view.id}` === id),
+        find(this._uiViews, (view) => `${router.$id}.${view.id}` === id),
       _registeredUIViews: () => this._uiViews,
       _activeViewConfigs: () => this._viewConfigs,
       _onSync: (listener) => {

package/src/shared/common.js

@@ -3,8 +3,6 @@
  *
  * These functions are exported, but are subject to change without notice.
  *
- * @packageDocumentation
- * @preferred
  */
 import { isDate, isFunction, isRegExp, isString } from "./utils";
 import { all, any, prop, curry, not } from "./hof";

package/src/shared/strings.js

@@ -7,7 +7,7 @@
  */
 import { isInjectable, isNull, isPromise } from "./predicates";
 import { isUndefined, isFunction, isString, isObject } from "./utils";
-import { Rejection } from "../router/transition/rejectFactory";
+import { Rejection } from "../router/transition/reject-factory";
 import { identity, pushR, tail } from "./common";
 import { pattern, val } from "./hof";
 /**
@@ -112,7 +112,7 @@ export const trimHashVal = (str) => (str ? str.replace(/^#/, "") : "");
  */
 export function splitOnDelim(delim) {
   const re = new RegExp("(" + delim + ")", "g");
-  return (str) => str.split(re).filter(identity);
+  return (str) => str.split(re).filter(Boolean);
 }
 /**
  * Reduce fn that joins neighboring strings

package/test/router/view.spec.js

@@ -2,16 +2,16 @@ import { dealoc } from "../../src/jqLite";
 import { Angular } from "../../src/loader";
 import { publishExternalAPI } from "../../src/public";
 import { curry } from "../../src/shared/hof";
-import { StateMatcher } from "../../src/router/state/stateMatcher";
-import { StateBuilder } from "../../src/router/state/stateBuilder";
-import { StateObject } from "../../src/router/state/stateObject";
+import { StateMatcher } from "../../src/router/state/state-matcher";
+import { StateBuilder } from "../../src/router/state/state-builder";
+import { StateObject } from "../../src/router/state/state-object";
 import { ViewService } from "../../src/router/view/view";
 import {
   ng1ViewsBuilder,
   getNg1ViewConfigFactory,
 } from "../../src/router/state/views";
-import { PathNode } from "../../src/router/path/pathNode";
-import { PathUtils } from "../../src/router/path/pathUtils";
+import { PathNode } from "../../src/router/path/path-node";
+import { PathUtils } from "../../src/router/path/path-utils";
 import { tail } from "../../src/shared/common";
 import { wait } from "../test-utils";