@angular-wave/angular.ts 0.0.23 → 0.0.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@angular-wave/angular.ts",
   "license": "MIT",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "type": "module",
   "main": "dist/angular-ts.esm.js",
   "browser": "dist/angular-ts.umd.js",

package/src/core/compile.js

@@ -6,7 +6,6 @@ import {
   assertNotHasOwnProperty,
   createMap,
   forEach,
-  identity,
   isDefined,
   isFunction,
   isObject,
@@ -969,7 +968,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
       const endSymbol = $interpolate.endSymbol();
       const denormalizeTemplate =
         startSymbol === "{{" && endSymbol === "}}"
-          ? identity
+          ? (x) => x
           : function denormalizeTemplate(template) {
               return template
                 .replace(/\{\{/g, startSymbol)
@@ -2902,7 +2901,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         const nodeName = nodeName_(node);
         const trustedContext = getTrustedPropContext(nodeName, propName);
 
-        let sanitizer = identity;
+        let sanitizer = (x) => x;
         // Sanitize img[srcset] + source[srcset] values.
         if (
           propName === "srcset" &&

package/src/core/parser/parse.js

@@ -2,7 +2,6 @@ import {
   createMap,
   csp,
   forEach,
-  identity,
   isDefined,
   isFunction,
   minErr,
@@ -2213,7 +2212,7 @@ export function $ParseProvider() {
         var unwatch, lastValue;
 
         var exp = parsedExpression.$$intercepted || parsedExpression;
-        var post = parsedExpression.$$interceptor || identity;
+        var post = parsedExpression.$$interceptor || ((x) => x);
 
         var useInputs = parsedExpression.inputs && !exp.inputs;
 
@@ -2476,7 +2475,7 @@ export function oneTimeWatchDelegate(
   let lastValue;
 
   const exp = parsedExpression.$$intercepted || parsedExpression;
-  const post = parsedExpression.$$interceptor || identity;
+  const post = parsedExpression.$$interceptor || ((x) => x);
 
   const useInputs = parsedExpression.inputs && !exp.inputs;
 

package/src/router/directives/{stateDirectives.js → state-directives.js}

@@ -9,7 +9,6 @@ import {
   forEach,
   tail,
   unnestR,
-  identity,
   uniqR,
   inArray,
   removeFrom,
@@ -642,7 +641,7 @@ export let uiSrefActiveDirective = [
           }
           // Update route state
           function update() {
-            const splitClasses = (str) => str.split(/\s/).filter(identity);
+            const splitClasses = (str) => str.split(/\s/).filter(Boolean);
             const getClasses = (stateList) =>
               stateList
                 .map((x) => x.activeClass)

package/src/router/directives/{viewDirective.js → view-directive.js}

@@ -3,7 +3,7 @@ import { isDefined, isFunction, isString } from "../../shared/utils";
 import { kebobString } from "../../shared/strings";
 
 import { parse } from "../../shared/hof";
-import { ResolveContext } from "../resolve/resolveContext";
+import { ResolveContext } from "../resolve/resolve-context";
 import { trace } from "../common/trace";
 import { getLocals } from "../services";
 import { Ng1ViewConfig } from "../state/views";

package/src/router/globals.js

@@ -1,4 +1,4 @@
-import { StateParams } from "./params/stateParams";
+import { StateParams } from "./params/state-params";
 import { Queue } from "./common/queue";
 /**
  * Global router state

package/src/router/hooks/{ignoredTransition.js → ignored-transition.js}

@@ -1,5 +1,5 @@
 import { trace } from "../common/trace";
-import { Rejection } from "../transition/rejectFactory";
+import { Rejection } from "../transition/reject-factory";
 /**
  * A [[TransitionHookFn]] that skips a transition if it should be ignored
  *

package/src/router/hooks/{redirectTo.js → redirect-to.js}

@@ -1,6 +1,6 @@
 import { isString, isFunction } from "../../shared/utils";
 import { services } from "../common/coreservices";
-import { TargetState } from "../state/targetState";
+import { TargetState } from "../state/target-state";
 /**
  * A [[TransitionHookFn]] that redirects to a different state or params
  *

package/src/router/hooks/resolve.js

@@ -1,4 +1,4 @@
-import { ResolveContext } from "../resolve/resolveContext";
+import { ResolveContext } from "../resolve/resolve-context";
 import { val } from "../../shared/hof";
 export const RESOLVE_HOOK_PRIORITY = 1000;
 /**

package/src/router/index.js

@@ -6,16 +6,16 @@ import {
   runBlock,
   watchDigests,
 } from "./services";
-import { TemplateFactory } from "./templateFactory";
+import { TemplateFactory } from "./template-factory";
 import { trace } from "./common/trace";
-import { $ViewScrollProvider } from "./viewScroll";
-import { $IsStateFilter, $IncludedByStateFilter } from "./stateFilters";
+import { $ViewScrollProvider } from "./view-scroll";
+import { $IsStateFilter, $IncludedByStateFilter } from "./state-filters";
 import {
   uiSrefActiveDirective,
   uiStateDirective,
   uiSrefDirective,
-} from "./directives/stateDirectives";
-import { uiView, $ViewDirectiveFill } from "./directives/viewDirective";
+} from "./directives/state-directives";
+import { uiView, $ViewDirectiveFill } from "./directives/view-directive";
 
 export function initRouter() {
   window.angular
@@ -28,9 +28,7 @@ export function initRouter() {
         return router.urlMatcherFactory;
       },
     ])
-    .provider("$templateFactory", function () {
-      return new TemplateFactory();
-    })
+    .provider("$templateFactory", TemplateFactory)
     .provider("$stateRegistry", getProviderFor("stateRegistry"))
     .provider("$routerGlobals", getProviderFor("globals"))
     .provider("$transitions", getProviderFor("transitionService"))

package/src/router/params/{paramTypes.js → param-types.js}

@@ -1,7 +1,6 @@
 import {
   fromJson,
   toJson,
-  identity,
   equals,
   inherit,
   map,
@@ -11,7 +10,7 @@ import { isNullOrUndefined } from "../../shared/predicates";
 import { isDefined } from "../../shared/utils";
 import { is } from "../../shared/hof";
 import { services } from "../common/coreservices";
-import { ParamType } from "./paramType";
+import { ParamType } from "./param-type";
 /**
  * A registry for parameter types.
  *
@@ -153,8 +152,8 @@ function initDefaultTypes() {
     }),
     // does not encode/decode
     any: makeDefaultType({
-      encode: identity,
-      decode: identity,
+      encode: (x) => x,
+      decode: (x) => x,
       is: () => true,
       equals: equals,
     }),

package/src/router/params/param.js

@@ -3,7 +3,7 @@ import { prop } from "../../shared/hof";
 import { isInjectable } from "../../shared/predicates";
 import { isDefined, isUndefined, isString } from "../../shared/utils";
 import { services } from "../common/coreservices";
-import { ParamType } from "./paramType";
+import { ParamType } from "./param-type";
 const hasOwn = Object.prototype.hasOwnProperty;
 const isShorthand = (cfg) =>
   ["value", "type", "squash", "array", "dynamic"].filter(hasOwn.bind(cfg || {}))

package/src/router/path/{pathUtils.js → path-utils.js}

@@ -9,8 +9,8 @@ import {
   arrayTuples,
 } from "../../shared/common";
 import { prop, propEq } from "../../shared/hof";
-import { TargetState } from "../state/targetState";
-import { PathNode } from "./pathNode";
+import { TargetState } from "../state/target-state";
+import { PathNode } from "./path-node";
 /**
  * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
  */

package/src/router/resolve/resolvable.js

@@ -1,4 +1,4 @@
-import { identity, isFunction, isObject } from "../../shared/utils";
+import { isFunction, isObject } from "../../shared/utils";
 import { services } from "../common/coreservices";
 import { trace } from "../common/trace";
 import { stringify } from "../../shared/strings";
@@ -87,7 +87,7 @@ export class Resolvable {
     const node = resolveContext.findNode(this);
     const state = node && node.state;
     const asyncPolicy = this.getPolicy(state).async;
-    const customAsyncPolicy = isFunction(asyncPolicy) ? asyncPolicy : identity;
+    const customAsyncPolicy = isFunction(asyncPolicy) ? asyncPolicy : (x) => x;
     // After the final value has been resolved, update the state of the Resolvable
     const applyResolvedValue = (resolvedValue) => {
       this.data = resolvedValue;

package/src/router/resolve/{resolveContext.js → resolve-context.js}

@@ -3,7 +3,7 @@ import { propEq, not } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
 import { Resolvable } from "./resolvable";
-import { PathUtils } from "../path/pathUtils";
+import { PathUtils } from "../path/path-utils";
 import { stringify } from "../../shared/strings";
 import { isUndefined } from "../../shared/utils";
 

package/src/router/router.js

@@ -1,13 +1,13 @@
-import { UrlMatcherFactory } from "./url/urlMatcherFactory";
-import { UrlRouter } from "./url/urlRouter";
-import { TransitionService } from "./transition/transitionService";
+import { UrlMatcherFactory } from "./url/url-matcher-factory";
+import { UrlRouter } from "./url/url-router";
+import { TransitionService } from "./transition/transition-service";
 import { ViewService } from "./view/view";
-import { StateRegistry } from "./state/stateRegistry";
-import { StateService } from "./state/stateService";
+import { StateRegistry } from "./state/state-registry";
+import { StateService } from "./state/state-service";
 import { UIRouterGlobals } from "./globals";
 import { removeFrom } from "../shared/common";
 import { isFunction } from "../shared/utils";
-import { UrlService } from "./url/urlService";
+import { UrlService } from "./url/url-service";
 import { trace } from "./common/trace";
 
 /**
@@ -26,11 +26,11 @@ export class UIRouter {
   /**
    * Creates a new `UIRouter` object
    *
-   * @param {import('./locationServices').Ng1LocationServices} locationService
+   * @param {import('./location-services').Ng1LocationServices} locationService
    */
   constructor(locationService) {
     /**
-     * @type {import('./locationServices').Ng1LocationServices}
+     * @type {import('./location-services').Ng1LocationServices}
      */
     this.locationService = locationService;
     /**  @type {number} */ this.$id = routerId++;

package/src/router/services.js

@@ -15,9 +15,9 @@ import { trace } from "./common/trace";
 import { UIRouter } from "./router";
 import { ng1ViewsBuilder, getNg1ViewConfigFactory } from "./state/views";
 
-import { StateProvider } from "./stateProvider";
-import { Ng1LocationServices } from "./locationServices";
-import { ResolveContext } from "./resolve/resolveContext";
+import { StateProvider } from "./state-provider";
+import { Ng1LocationServices } from "./location-services";
+import { ResolveContext } from "./resolve/resolve-context";
 
 export let router = null;
 $routerProvider.$inject = ["$locationProvider"];

package/src/router/state/{stateBuilder.js → state-builder.js}

@@ -1,6 +1,5 @@
 import {
   applyPairs,
-  identity,
   inherit,
   mapObj,
   omit,
@@ -201,12 +200,12 @@ export function resolvablesBuilder(state) {
     ],
     [
       prop("useExisting"),
-      (p) => new Resolvable(getToken(p), identity, [p.useExisting], p.policy),
+      (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, identity, [tuple.val], tuple.policy)],
+        [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, annotate(tuple.val), tuple.policy)],
     ]);

package/src/router/state/{stateQueueManager.js → state-queue-manager.js}

@@ -1,7 +1,8 @@
 import { inArray } from "../../shared/common";
 import { prop } from "../../shared/hof";
 import { isString } from "../../shared/utils";
-import { StateObject } from "./stateObject";
+import { StateObject } from "./state-object";
+
 export class StateQueueManager {
   constructor(router, states, builder, listeners) {
     this.router = router;

package/src/router/state/{stateRegistry.js → state-registry.js}

@@ -1,6 +1,6 @@
-import { StateMatcher } from "./stateMatcher";
-import { StateBuilder } from "./stateBuilder";
-import { StateQueueManager } from "./stateQueueManager";
+import { StateMatcher } from "./state-matcher";
+import { StateBuilder } from "./state-builder";
+import { StateQueueManager } from "./state-queue-manager";
 import { removeFrom } from "../../shared/common";
 import { propEq } from "../../shared/hof";
 /**

package/src/router/state/{stateService.js → state-service.js}

@@ -9,15 +9,15 @@ import {
 import { isDefined, isObject, isString } from "../../shared/utils";
 import { Queue } from "../common/queue";
 import { services } from "../common/coreservices";
-import { PathUtils } from "../path/pathUtils";
-import { PathNode } from "../path/pathNode";
-import { defaultTransOpts } from "../transition/transitionService";
-import { Rejection, RejectType } from "../transition/rejectFactory";
-import { TargetState } from "./targetState";
+import { PathUtils } from "../path/path-utils";
+import { PathNode } from "../path/path-node";
+import { defaultTransOpts } from "../transition/transition-service";
+import { Rejection, RejectType } from "../transition/reject-factory";
+import { TargetState } from "./target-state";
 import { Param } from "../params/param";
 import { Glob } from "../common/glob";
-import { ResolveContext } from "../resolve/resolveContext";
-import { lazyLoadState } from "../hooks/lazyLoad";
+import { ResolveContext } from "../resolve/resolve-context";
+import { lazyLoadState } from "../hooks/lazy-load";
 import { not, val } from "../../shared/hof";
 /**
  * Provides services related to ui-router states.

package/src/router/state/views.js

@@ -4,7 +4,7 @@ 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 { ResolveContext } from "../resolve/resolve-context";
 import { Resolvable } from "../resolve/resolvable";
 
 export function getNg1ViewConfigFactory() {

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,