@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/url/urlService.js

@@ -0,0 +1,268 @@
+import { extend, isString } from "../../../core/utils";
+import { is, pattern } from "../common/hof";
+import { UrlRules } from "./urlRules";
+import { UrlConfig } from "./urlConfig";
+import { TargetState } from "../state/targetState";
+/**
+ * API for URL management
+ */
+export class UrlService {
+  /** @internal */
+  constructor(/** @internal */ router) {
+    this.router = router;
+    /** @internal */ this.interceptDeferred = false;
+    /**
+     * The nested [[UrlRules]] API for managing URL rules and rewrites
+     *
+     * See: [[UrlRules]] for details
+     */
+    this.rules = new UrlRules(this.router);
+    /**
+     * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
+     *
+     * See: [[UrlConfig]] for details
+     */
+    this.config = new UrlConfig(this.router);
+    // Delegate these calls to the current LocationServices implementation
+    /**
+     * Gets the current url, or updates the url
+     *
+     * ### Getting the current URL
+     *
+     * When no arguments are passed, returns the current URL.
+     * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
+     *
+     * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
+     * have a base HREF prepended ([[PushStateLocationServices]]).
+     *
+     * The raw URL in the browser might be:
+     *
+     * ```
+     * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
+     * ```
+     *
+     * or
+     *
+     * ```
+     * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
+     * ```
+     *
+     * then this method returns:
+     *
+     * ```
+     * /internal/path/123?param1=foo#anchor
+     * ```
+     *
+     *
+     * #### Example:
+     * ```js
+     * locationServices.url(); // "/some/path?query=value#anchor"
+     * ```
+     *
+     * ### Updating the URL
+     *
+     * When `newurl` arguments is provided, changes the URL to reflect `newurl`
+     *
+     * #### Example:
+     * ```js
+     * locationServices.url("/some/path?query=value#anchor", true);
+     * ```
+     *
+     * @param 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)
+     *
+     * @return the url (after potentially being processed)
+     */
+    this.url = (newurl, replace, state) =>
+      this.router.locationService.url(newurl, replace, state);
+    /**
+     * Gets the path part of the current url
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
+     *
+     * @return the path portion of the url
+     */
+    this.path = () => this.router.locationService.path();
+    /**
+     * Gets the search part of the current url as an object
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
+     *
+     * @return the search (query) portion of the url, as an object
+     */
+    this.search = () => this.router.locationService.search();
+    /**
+     * Gets the hash part of the current url
+     *
+     * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
+     *
+     * @return the hash (anchor) portion of the url
+     */
+    this.hash = () => this.router.locationService.hash();
+    /**
+     * @internal
+     *
+     * Registers a low level url change handler
+     *
+     * Note: Because this is a low level handler, it's not recommended for general use.
+     *
+     * #### Example:
+     * ```js
+     * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
+     * ```
+     *
+     * @param callback a function that will be called when the url is changing
+     * @return a function that de-registers the callback
+     */
+    this.onChange = (callback) =>
+      this.router.locationService.onChange(callback);
+  }
+  /** @internal */
+  dispose() {
+    this.listen(false);
+    this.rules.dispose();
+  }
+  /**
+   * Gets the current URL parts
+   *
+   * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+   */
+  parts() {
+    return { path: this.path(), search: this.search(), hash: this.hash() };
+  }
+  /**
+   * Activates the best rule for the current URL
+   *
+   * Checks the current URL for a matching [[UrlRule]], then invokes that rule's handler.
+   * This method is called internally any time the URL has changed.
+   *
+   * This effectively activates the state (or redirect, etc) which matches the current URL.
+   *
+   * #### Example:
+   * ```js
+   * urlService.deferIntercept();
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   urlService.listen();
+   *   // Find the matching URL and invoke the handler.
+   *   urlService.sync();
+   * });
+   * ```
+   */
+  sync(evt) {
+    if (evt && evt.defaultPrevented) return;
+    const { urlService, stateService } = this.router;
+    const url = {
+      path: urlService.path(),
+      search: urlService.search(),
+      hash: urlService.hash(),
+    };
+    const best = this.match(url);
+    const applyResult = pattern([
+      [isString, (newurl) => urlService.url(newurl, true)],
+      [
+        TargetState.isDef,
+        (def) => stateService.go(def.state, def.params, def.options),
+      ],
+      [
+        is(TargetState),
+        (target) =>
+          stateService.go(target.state(), target.params(), target.options()),
+      ],
+    ]);
+    applyResult(best && best.rule.handler(best.match, url, this.router));
+  }
+  /**
+   * Starts or stops listening for URL changes
+   *
+   * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
+   * This causes UI-Router to start listening for changes to the URL, if it wasn't already listening.
+   *
+   * If called with `false`, UI-Router will stop listening (call listen(true) to start listening again).
+   *
+   * #### Example:
+   * ```js
+   * urlService.deferIntercept();
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   // Start responding to URL changes
+   *   urlService.listen();
+   *   urlService.sync();
+   * });
+   * ```
+   *
+   * @param enabled `true` or `false` to start or stop listening to URL changes
+   */
+  listen(enabled) {
+    if (enabled === false) {
+      this._stopListeningFn && this._stopListeningFn();
+      delete this._stopListeningFn;
+    } else {
+      return (this._stopListeningFn =
+        this._stopListeningFn ||
+        this.router.urlService.onChange((evt) => this.sync(evt)));
+    }
+  }
+  /**
+   * Disables monitoring of the URL.
+   *
+   * Call this method before UI-Router has bootstrapped.
+   * It will stop UI-Router from performing the initial url sync.
+   *
+   * This can be useful to perform some asynchronous initialization before the router starts.
+   * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
+   *
+   * #### Example:
+   * ```js
+   * // Prevent UI-Router from automatically intercepting URL changes when it starts;
+   * urlService.deferIntercept();
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   urlService.listen();
+   *   urlService.sync();
+   * });
+   * ```
+   *
+   * @param defer Indicates whether to defer location change interception.
+   *        Passing no parameter is equivalent to `true`.
+   */
+  deferIntercept(defer) {
+    if (defer === undefined) defer = true;
+    this.interceptDeferred = defer;
+  }
+  /**
+   * Matches a URL
+   *
+   * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
+   * Return the result as a [[MatchResult]].
+   */
+  match(url) {
+    url = extend({ 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
+    const checkRule = (rule) => {
+      const match = rule.match(url, this.router);
+      return match && { match, rule, weight: rule.matchPriority(match) };
+    };
+    // The rules are pre-sorted.
+    // - Find the first matching rule.
+    // - Find any other matching rule that sorted *exactly the same*, according to `.sort()`.
+    // - Choose the rule with the highest match weight.
+    let best;
+    for (let i = 0; i < rules.length; i++) {
+      // Stop when there is a 'best' rule and the next rule sorts differently than it.
+      if (best && best.rule._group !== rules[i]._group) break;
+      const current = checkRule(rules[i]);
+      // Pick the best MatchResult
+      best =
+        !best || (current && current.weight > best.weight) ? current : best;
+    }
+    return best;
+  }
+}

package/src/router/core/view/interface.js

@@ -0,0 +1 @@
+export {};

package/src/router/core/view/view.js

@@ -0,0 +1,312 @@
+import {
+  equals,
+  applyPairs,
+  removeFrom,
+  inArray,
+  find,
+} from "../common/common";
+import { curry, prop } from "../common/hof";
+import { isString, isArray } from "../common/predicates";
+import { trace } from "../common/trace";
+/**
+ * The View service
+ *
+ * This service pairs existing `ui-view` components (which live in the DOM)
+ * with view configs (from the state declaration objects: [[StateDeclaration.views]]).
+ *
+ * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].
+ *   The views from exited states are deactivated via [[deactivateViewConfig]].
+ *   (See: the [[registerActivateViews]] Transition Hook)
+ *
+ * - As `ui-view` components pop in and out of existence, they register themselves using [[registerUIView]].
+ *
+ * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveUIView]])
+ * are configured with the matching [[ViewConfig]](s)
+ *
+ */
+export class ViewService {
+  /**
+   * Normalizes a view's name from a state.views configuration block.
+   *
+   * This should be used by a framework implementation to calculate the values for
+   * [[_ViewDeclaration.$uiViewName]] and [[_ViewDeclaration.$uiViewContextAnchor]].
+   *
+   * @param context the context object (state declaration) that the view belongs to
+   * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
+   *
+   * @returns the normalized uiViewName and uiViewContextAnchor that the view targets
+   */
+  static normalizeUIViewTarget(context, rawViewName = "") {
+    // TODO: Validate incoming view name with a regexp to allow:
+    // ex: "view.name@foo.bar" , "^.^.view.name" , "view.name@^.^" , "" ,
+    // "@" , "$default@^" , "!$default.$default" , "!foo.bar"
+    const viewAtContext = rawViewName.split("@");
+    let uiViewName = viewAtContext[0] || "$default"; // default to unnamed view
+    let uiViewContextAnchor = isString(viewAtContext[1])
+      ? viewAtContext[1]
+      : "^"; // default to parent context
+    // Handle relative view-name sugar syntax.
+    // Matches rawViewName "^.^.^.foo.bar" into array: ["^.^.^.foo.bar", "^.^.^", "foo.bar"],
+    const relativeViewNameSugar = /^(\^(?:\.\^)*)\.(.*$)/.exec(uiViewName);
+    if (relativeViewNameSugar) {
+      // Clobbers existing contextAnchor (rawViewName validation will fix this)
+      uiViewContextAnchor = relativeViewNameSugar[1]; // set anchor to "^.^.^"
+      uiViewName = relativeViewNameSugar[2]; // set view-name to "foo.bar"
+    }
+    if (uiViewName.charAt(0) === "!") {
+      uiViewName = uiViewName.substr(1);
+      uiViewContextAnchor = ""; // target absolutely from root
+    }
+    // handle parent relative targeting "^.^.^"
+    const relativeMatch = /^(\^(?:\.\^)*)$/;
+    if (relativeMatch.exec(uiViewContextAnchor)) {
+      const anchorState = uiViewContextAnchor
+        .split(".")
+        .reduce((anchor, x) => anchor.parent, context);
+      uiViewContextAnchor = anchorState.name;
+    } else if (uiViewContextAnchor === ".") {
+      uiViewContextAnchor = context.name;
+    }
+    return { uiViewName, uiViewContextAnchor };
+  }
+  /** @internal */
+  constructor(/** @internal */ router) {
+    this.router = router;
+    /** @internal */ this._uiViews = [];
+    /** @internal */ this._viewConfigs = [];
+    /** @internal */ this._viewConfigFactories = {};
+    /** @internal */ this._listeners = [];
+    /** @internal */
+    this._pluginapi = {
+      _rootViewContext: this._rootViewContext.bind(this),
+      _viewConfigFactory: this._viewConfigFactory.bind(this),
+      _registeredUIView: (id) =>
+        find(this._uiViews, (view) => `${this.router.$id}.${view.id}` === id),
+      _registeredUIViews: () => this._uiViews,
+      _activeViewConfigs: () => this._viewConfigs,
+      _onSync: (listener) => {
+        this._listeners.push(listener);
+        return () => removeFrom(this._listeners, listener);
+      },
+    };
+  }
+  /** @internal */
+  _rootViewContext(context) {
+    return (this._rootContext = context || this._rootContext);
+  }
+  /** @internal */
+  _viewConfigFactory(viewType, factory) {
+    this._viewConfigFactories[viewType] = factory;
+  }
+  createViewConfig(path, decl) {
+    const cfgFactory = this._viewConfigFactories[decl.$type];
+    if (!cfgFactory)
+      throw new Error(
+        "ViewService: No view config factory registered for type " + decl.$type,
+      );
+    const cfgs = cfgFactory(path, decl);
+    return isArray(cfgs) ? cfgs : [cfgs];
+  }
+  /**
+   * Deactivates a ViewConfig.
+   *
+   * This function deactivates a `ViewConfig`.
+   * After calling [[sync]], it will un-pair from any `ui-view` with which it is currently paired.
+   *
+   * @param viewConfig The ViewConfig view to deregister.
+   */
+  deactivateViewConfig(viewConfig) {
+    trace.traceViewServiceEvent("<- Removing", viewConfig);
+    removeFrom(this._viewConfigs, viewConfig);
+  }
+  activateViewConfig(viewConfig) {
+    trace.traceViewServiceEvent("-> Registering", viewConfig);
+    this._viewConfigs.push(viewConfig);
+  }
+  sync() {
+    const uiViewsByFqn = this._uiViews
+      .map((uiv) => [uiv.fqn, uiv])
+      .reduce(applyPairs, {});
+    // Return a weighted depth value for a uiView.
+    // The depth is the nesting depth of ui-views (based on FQN; times 10,000)
+    // plus the depth of the state that is populating the uiView
+    function uiViewDepth(uiView) {
+      const stateDepth = (context) =>
+        context && context.parent ? stateDepth(context.parent) + 1 : 1;
+      return (
+        uiView.fqn.split(".").length * 10000 +
+        stateDepth(uiView.creationContext)
+      );
+    }
+    // Return the ViewConfig's context's depth in the context tree.
+    function viewConfigDepth(config) {
+      let context = config.viewDecl.$context,
+        count = 0;
+      while (++count && context.parent) context = context.parent;
+      return count;
+    }
+    // Given a depth function, returns a compare function which can return either ascending or descending order
+    const depthCompare = curry(
+      (depthFn, posNeg, left, right) =>
+        posNeg * (depthFn(left) - depthFn(right)),
+    );
+    const matchingConfigPair = (uiView) => {
+      const matchingConfigs = this._viewConfigs.filter(
+        ViewService.matches(uiViewsByFqn, uiView),
+      );
+      if (matchingConfigs.length > 1) {
+        // This is OK.  Child states can target a ui-view that the parent state also targets (the child wins)
+        // Sort by depth and return the match from the deepest child
+        // console.log(`Multiple matching view configs for ${uiView.fqn}`, matchingConfigs);
+        matchingConfigs.sort(depthCompare(viewConfigDepth, -1)); // descending
+      }
+      return { uiView, viewConfig: matchingConfigs[0] };
+    };
+    const configureUIView = (tuple) => {
+      // If a parent ui-view is reconfigured, it could destroy child ui-views.
+      // Before configuring a child ui-view, make sure it's still in the active uiViews array.
+      if (this._uiViews.indexOf(tuple.uiView) !== -1)
+        tuple.uiView.configUpdated(tuple.viewConfig);
+    };
+    // Sort views by FQN and state depth. Process uiviews nearest the root first.
+    const uiViewTuples = this._uiViews
+      .sort(depthCompare(uiViewDepth, 1))
+      .map(matchingConfigPair);
+    const matchedViewConfigs = uiViewTuples.map((tuple) => tuple.viewConfig);
+    const unmatchedConfigTuples = this._viewConfigs
+      .filter((config) => !inArray(matchedViewConfigs, config))
+      .map((viewConfig) => ({ uiView: undefined, viewConfig }));
+    uiViewTuples.forEach(configureUIView);
+    const allTuples = uiViewTuples.concat(unmatchedConfigTuples);
+    this._listeners.forEach((cb) => cb(allTuples));
+    trace.traceViewSync(allTuples);
+  }
+  /**
+   * Registers a `ui-view` component
+   *
+   * When a `ui-view` component is created, it uses this method to register itself.
+   * After registration the [[sync]] method is used to ensure all `ui-view` are configured with the proper [[ViewConfig]].
+   *
+   * Note: the `ui-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ui-view`,
+   * and what the view's state context is.
+   *
+   * Note: There is no corresponding `deregisterUIView`.
+   *       A `ui-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.
+   *
+   * @param uiView The metadata for a UIView
+   * @return a de-registration function used when the view is destroyed.
+   */
+  registerUIView(uiView) {
+    trace.traceViewServiceUIViewEvent("-> Registering", uiView);
+    const uiViews = this._uiViews;
+    const fqnAndTypeMatches = (uiv) =>
+      uiv.fqn === uiView.fqn && uiv.$type === uiView.$type;
+    if (uiViews.filter(fqnAndTypeMatches).length)
+      trace.traceViewServiceUIViewEvent("!!!! duplicate uiView named:", uiView);
+    uiViews.push(uiView);
+    this.sync();
+    return () => {
+      const idx = uiViews.indexOf(uiView);
+      if (idx === -1) {
+        trace.traceViewServiceUIViewEvent(
+          "Tried removing non-registered uiView",
+          uiView,
+        );
+        return;
+      }
+      trace.traceViewServiceUIViewEvent("<- Deregistering", uiView);
+      removeFrom(uiViews)(uiView);
+    };
+  }
+  /**
+   * Returns the list of views currently available on the page, by fully-qualified name.
+   *
+   * @return {Array} Returns an array of fully-qualified view names.
+   */
+  available() {
+    return this._uiViews.map(prop("fqn"));
+  }
+  /**
+   * Returns the list of views on the page containing loaded content.
+   *
+   * @return {Array} Returns an array of fully-qualified view names.
+   */
+  active() {
+    return this._uiViews.filter(prop("$config")).map(prop("name"));
+  }
+}
+/**
+ * Given a ui-view and a ViewConfig, determines if they "match".
+ *
+ * A ui-view has a fully qualified name (fqn) and a context object.  The fqn is built from its overall location in
+ * the DOM, describing its nesting relationship to any parent ui-view tags it is nested inside of.
+ *
+ * A ViewConfig has a target ui-view name and a context anchor.  The ui-view name can be a simple name, or
+ * can be a segmented ui-view path, describing a portion of a ui-view fqn.
+ *
+ * In order for a ui-view to match ViewConfig, ui-view's $type must match the ViewConfig's $type
+ *
+ * If the ViewConfig's target ui-view name is a simple name (no dots), then a ui-view matches if:
+ * - the ui-view's name matches the ViewConfig's target name
+ * - the ui-view's context matches the ViewConfig's anchor
+ *
+ * If the ViewConfig's target ui-view name is a segmented name (with dots), then a ui-view matches if:
+ * - There exists a parent ui-view where:
+ *    - the parent ui-view's name matches the first segment (index 0) of the ViewConfig's target name
+ *    - the parent ui-view's context matches the ViewConfig's anchor
+ * - And the remaining segments (index 1..n) of the ViewConfig's target name match the tail of the ui-view's fqn
+ *
+ * Example:
+ *
+ * DOM:
+ * <ui-view>                        <!-- created in the root context (name: "") -->
+ *   <ui-view name="foo">                <!-- created in the context named: "A"      -->
+ *     <ui-view>                    <!-- created in the context named: "A.B"    -->
+ *       <ui-view name="bar">            <!-- created in the context named: "A.B.C"  -->
+ *       </ui-view>
+ *     </ui-view>
+ *   </ui-view>
+ * </ui-view>
+ *
+ * uiViews: [
+ *  { fqn: "$default",                  creationContext: { name: "" } },
+ *  { fqn: "$default.foo",              creationContext: { name: "A" } },
+ *  { fqn: "$default.foo.$default",     creationContext: { name: "A.B" } }
+ *  { fqn: "$default.foo.$default.bar", creationContext: { name: "A.B.C" } }
+ * ]
+ *
+ * These four view configs all match the ui-view with the fqn: "$default.foo.$default.bar":
+ *
+ * - ViewConfig1: { uiViewName: "bar",                       uiViewContextAnchor: "A.B.C" }
+ * - ViewConfig2: { uiViewName: "$default.bar",              uiViewContextAnchor: "A.B" }
+ * - ViewConfig3: { uiViewName: "foo.$default.bar",          uiViewContextAnchor: "A" }
+ * - ViewConfig4: { uiViewName: "$default.foo.$default.bar", uiViewContextAnchor: "" }
+ *
+ * Using ViewConfig3 as an example, it matches the ui-view with fqn "$default.foo.$default.bar" because:
+ * - The ViewConfig's segmented target name is: [ "foo", "$default", "bar" ]
+ * - There exists a parent ui-view (which has fqn: "$default.foo") where:
+ *    - the parent ui-view's name "foo" matches the first segment "foo" of the ViewConfig's target name
+ *    - the parent ui-view's context "A" matches the ViewConfig's anchor context "A"
+ * - And the remaining segments [ "$default", "bar" ].join("."_ of the ViewConfig's target name match
+ *   the tail of the ui-view's fqn "default.bar"
+ *
+ * @internal
+ */
+ViewService.matches = (uiViewsByFqn, uiView) => (viewConfig) => {
+  // Don't supply an ng1 ui-view with an ng2 ViewConfig, etc
+  if (uiView.$type !== viewConfig.viewDecl.$type) return false;
+  // Split names apart from both viewConfig and uiView into segments
+  const vc = viewConfig.viewDecl;
+  const vcSegments = vc.$uiViewName.split(".");
+  const uivSegments = uiView.fqn.split(".");
+  // Check if the tails of the segment arrays match. ex, these arrays' tails match:
+  // vc: ["foo", "bar"], uiv fqn: ["$default", "foo", "bar"]
+  if (!equals(vcSegments, uivSegments.slice(0 - vcSegments.length)))
+    return false;
+  // Now check if the fqn ending at the first segment of the viewConfig matches the context:
+  // ["$default", "foo"].join(".") == "$default.foo", does the ui-view $default.foo context match?
+  const negOffset = 1 - vcSegments.length || undefined;
+  const fqnToFirstSegment = uivSegments.slice(0, negOffset).join(".");
+  const uiViewContext = uiViewsByFqn[fqnToFirstSegment].creationContext;
+  return vc.$uiViewContextAnchor === (uiViewContext && uiViewContext.name);
+};

package/src/router/router.js

@@ -0,0 +1,58 @@
+import {
+  $uiRouterProvider,
+  getProviderFor,
+  getStateProvider,
+  router,
+  runBlock,
+  watchDigests,
+} from "./adapter/services";
+import { TemplateFactory } from "./adapter/templateFactory";
+import { trace } from "./core/common/trace";
+
+export function initRouter() {
+  window.angular.module("ui.router.angular1", []);
+  const mod_init = window.angular.module("ui.router.init", ["ng"]);
+  const mod_util = window.angular.module("ui.router.util", ["ui.router.init"]);
+  const mod_state = window.angular.module("ui.router.state", [
+    "ui.router.util",
+    "ui.router.angular1",
+  ]);
+
+  const mod_main = window.angular.module("ui.router", [
+    "ui.router.init",
+    "ui.router.state",
+    "ui.router.angular1",
+  ]);
+
+  mod_init.provider("$uiRouter", $uiRouterProvider);
+  mod_util.provider("$urlService", getProviderFor("urlService"));
+  mod_util.provider("$urlMatcherFactory", [
+    "$uiRouterProvider",
+    function RouterProvide() {
+      return router.urlMatcherFactory;
+    },
+  ]);
+  mod_util.provider("$templateFactory", function () {
+    return new TemplateFactory();
+  });
+  mod_state.provider("$stateRegistry", getProviderFor("stateRegistry"));
+  mod_state.provider("$uiRouterGlobals", getProviderFor("globals"));
+  mod_state.provider("$transitions", getProviderFor("transitionService"));
+  mod_state.provider("$state", ["$uiRouterProvider", getStateProvider]);
+  mod_state.factory("$stateParams", [
+    "$uiRouter",
+    function StateParamse($uiRouter) {
+      return $uiRouter.globals.params;
+    },
+  ]);
+  mod_main.factory("$view", function View() {
+    return router.viewService;
+  });
+  mod_main.service("$trace", function Trace() {
+    return trace;
+  });
+  mod_main.run(watchDigests);
+  mod_util.run(["$urlMatcherFactory", function MatcherFac() {}]);
+  mod_state.run(["$state", function State() {}]);
+  mod_init.run(runBlock);
+}

package/test/module-test.html

@@ -1,10 +1,14 @@
 <!doctype html>
 <html>
   <head>
-    <script></script>
+    <script>
+      document.addEventListener("DOMContentLoaded", () => {
+        window.angular.module("test", ["ui.router"]);
+      });
+    </script>
     <script type="module" src="../src/index.js"></script>
   </head>
-  <body ng-app>
+  <body ng-app="test">
     <div ng-init='list = [{ name: "x" }, { name: "y" }, { name: "z" }]'>
       <label>Name:</label>
       <input type="text" ng-model="yourName" placeholder="Enter a name here" />