@angular-wave/angular.ts 0.0.22 → 0.0.24

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

@@ -1,29 +1,54 @@
-/** @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() {
-    /** @hidden */ this.$get = [
-      "$http",
-      "$templateCache",
-      "$injector",
-      ($http, $templateCache, $injector) => {
-        this.$templateRequest =
-          $injector.has &&
-          $injector.has("$templateRequest") &&
-          $injector.get("$templateRequest");
-        this.$http = $http;
-        this.$templateCache = $templateCache;
-        return this;
-      },
-    ];
+    /** @type {boolean} */
+    this._useHttp = false;
+  }
+
+  $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
+   */
+  useHttpService(value) {
+    this._useHttp = value;
   }
 
   /**
@@ -33,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.
@@ -42,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.
@@ -104,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);
@@ -118,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);
@@ -136,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) {
@@ -151,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
@@ -170,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(",")})'`;
@@ -183,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.
  *

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");
 /**
@@ -358,7 +357,11 @@ export class Transition {
       : new Resolvable(resolvable);
     const stateName = typeof state === "string" ? state : state.name;
     const topath = this._treeChanges.to;
-    const targetNode = find(topath, (node) => node.state.name === stateName);
+    const targetNode = find(topath, (node) => {
+      return node.state.name === stateName;
+    });
+    console.assert(targetNode, `targetNode not found ${stateName}`);
+
     const resolveContext = new ResolveContext(topath);
     resolveContext.addResolvables([resolvable], targetNode.state);
   }
@@ -462,7 +465,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;

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,9 +16,17 @@ export class UrlRuleFactory {
   constructor(router) {
     this.router = router;
   }
+
   compile(str) {
     return this.router.urlMatcherFactory.compile(str);
   }
+
+  /**
+   *
+   * @param {*} what
+   * @param {*} handler
+   * @returns {BaseUrlRule}
+   */
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
@@ -193,13 +200,14 @@ UrlRuleFactory.isUrlRule = (obj) =>
  * A base rule which calls `match`
  *
  * The value from the `match` function is passed through to the `handler`.
- * @internal
+ * @type {angular.BaseUrlRule}
  */
 export class BaseUrlRule {
   constructor(match, handler) {
     this.match = match;
     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 };

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
  */
@@ -74,11 +74,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/services/browser.js

@@ -5,18 +5,11 @@ import { forEach, isUndefined, equals } from "../shared/utils";
 // This variable should be used *only* inside the cacheState function.
 let lastCachedState = null;
 
-export function getHash(url) {
-  const index = url.indexOf("#");
-  return index === -1 ? "" : url.substr(index);
-}
-
 export function trimEmptyHash(url) {
   return url.replace(/#$/, "");
 }
 
 /**
- *
- *
  * @name $browser
  * @requires $log
  * @description
@@ -32,8 +25,6 @@ export function trimEmptyHash(url) {
  */
 export function Browser($log, $$taskTrackerFactory) {
   const self = this;
-  let { location } = window;
-  let { history } = window;
   const { setTimeout } = window;
   const { clearTimeout } = window;
   const pendingDeferIds = {};
@@ -56,10 +47,8 @@ export function Browser($log, $$taskTrackerFactory) {
 
   let cachedState;
   let lastHistoryState;
-  let lastBrowserUrl = location.href;
-  const baseElement = jqLite(
-    Array.from(window.document.getElementsByTagName("base")),
-  );
+  let lastBrowserUrl = window.location.href;
+  const baseElement = jqLite(Array.from(document.getElementsByTagName("base")));
   let pendingLocation = null;
   const getCurrentState = function getCurrentState() {
     return history.state;
@@ -96,10 +85,6 @@ export function Browser($log, $$taskTrackerFactory) {
       state = null;
     }
 
-    // Android Browser BFCache causes location, history reference to become stale.
-    if (location !== window.location) location = window.location;
-    if (history !== window.history) history = window.history;
-
     // setter
     if (url) {
       const sameState = lastHistoryState === state;
@@ -129,7 +114,7 @@ export function Browser($log, $$taskTrackerFactory) {
     // - pendingLocation is needed as browsers don't allow to read out
     //   the new location.href if a reload happened or if there is a bug like in iOS 9 (see
     //   https://openradar.appspot.com/22186109).
-    return trimEmptyHash(pendingLocation || location.href);
+    return trimEmptyHash(pendingLocation || window.location.href);
   };
 
   /**

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/ng-state-builder.spec.js

@@ -0,0 +1,81 @@
+import { StateBuilder } from "../../src/router/state/stateBuilder";
+
+describe("Ng1 StateBuilder", function () {
+  const parent = { name: "" };
+  let builder,
+    matcher,
+    urlMatcherFactoryProvider = {
+      compile: function () {},
+      isMatcher: function () {},
+    };
+
+  beforeEach(function () {
+    matcher = new StateBuilder({});
+    builder = new StateBuilder(matcher, urlMatcherFactoryProvider);
+    builder.builder("views", ng1ViewsBuilder);
+  });
+
+  it("should use the state object to build a default view, when no `views` property is found", function () {
+    const config = {
+      url: "/foo",
+      templateUrl: "/foo.html",
+      controller: "FooController",
+      parent: parent,
+    };
+    const built = builder.builder("views")(config);
+
+    expect(built.$default).not.toEqual(config);
+    expect(built.$default).toEqual(
+      expect.objectContaining({
+        templateUrl: "/foo.html",
+        controller: "FooController",
+        resolveAs: "$resolve",
+      }),
+    );
+  });
+
+  it("It should use the views object to build views, when defined", function () {
+    const config = { a: { foo: "bar", controller: "FooController" } };
+    const builtViews = builder.builder("views")({
+      parent: parent,
+      views: config,
+    });
+    expect(builtViews.a.foo).toEqual(config.a.foo);
+    expect(builtViews.a.controller).toEqual(config.a.controller);
+  });
+
+  it("should not allow a view config with both component and template keys", inject(function (
+    $injector,
+  ) {
+    const config = {
+      name: "foo",
+      url: "/foo",
+      template: "<h1>hey</h1>",
+      controller: "FooController",
+      parent: parent,
+    };
+    expect(() => builder.builder("views")(config)).not.toThrow();
+    expect(() =>
+      builder.builder("views")(
+        Object.assign({ component: "fooComponent" }, config),
+      ),
+    ).toThrow();
+    expect(() =>
+      builder.builder("views")(
+        Object.assign({ componentProvider: () => "fooComponent" }, config),
+      ),
+    ).toThrow();
+    expect(() =>
+      builder.builder("views")(Object.assign({ bindings: {} }, config)),
+    ).toThrow();
+  }));
+
+  it("should replace a resolve: string value with a function that injects the service of the same name", inject(function (
+    $injector,
+  ) {
+    const config = { resolve: { foo: "bar" } };
+    expect(builder.builder("resolvables")).toBeDefined();
+    const built = builder.builder("resolvables")(config);
+    expect(built[0].deps).toEqual(["bar"]);
+  }));
+});

package/test/router/services.spec.js

@@ -19,7 +19,6 @@ describe("router services", () => {
         $transitionsProvider,
         $stateProvider,
       ) => {
-        debugger;
         $routerProvider = _$routerProvider_;
         expect($routerProvider["router"]).toBe($routerProvider);
         providers = {