@angular-wave/angular.ts 0.0.11 → 0.0.12

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/vanilla/baseLocationService.js

@@ -0,0 +1,31 @@
+import { deregAll, isDefined, removeFrom, root } from "../common/index";
+import { buildUrl, getParams, parseUrl } from "./utils";
+/** A base `LocationServices` */
+export class BaseLocationServices {
+  constructor(router, fireAfterUpdate) {
+    this.fireAfterUpdate = fireAfterUpdate;
+    this._listeners = [];
+    this._listener = (evt) => this._listeners.forEach((cb) => cb(evt));
+    this.hash = () => parseUrl(this._get()).hash;
+    this.path = () => parseUrl(this._get()).path;
+    this.search = () => getParams(parseUrl(this._get()).search);
+    this._location = root.location;
+    this._history = root.history;
+  }
+  url(url, replace = true) {
+    if (isDefined(url) && url !== this._get()) {
+      this._set(null, null, url, replace);
+      if (this.fireAfterUpdate) {
+        this._listeners.forEach((cb) => cb({ url }));
+      }
+    }
+    return buildUrl(this);
+  }
+  onChange(cb) {
+    this._listeners.push(cb);
+    return () => removeFrom(this._listeners, cb);
+  }
+  dispose(router) {
+    deregAll(this._listeners);
+  }
+}

package/src/router/core/vanilla/browserLocationConfig.js

@@ -0,0 +1,42 @@
+import { isDefined, isUndefined } from "../common/predicates";
+/** A `LocationConfig` that delegates to the browser's `location` object */
+export class BrowserLocationConfig {
+  constructor(router, _isHtml5 = false) {
+    this._isHtml5 = _isHtml5;
+    this._baseHref = undefined;
+    this._hashPrefix = "";
+  }
+  port() {
+    if (location.port) {
+      return Number(location.port);
+    }
+    return this.protocol() === "https" ? 443 : 80;
+  }
+  protocol() {
+    return location.protocol.replace(/:/g, "");
+  }
+  host() {
+    return location.hostname;
+  }
+  html5Mode() {
+    return this._isHtml5;
+  }
+  hashPrefix(newprefix) {
+    return isDefined(newprefix)
+      ? (this._hashPrefix = newprefix)
+      : this._hashPrefix;
+  }
+  baseHref(href) {
+    if (isDefined(href)) this._baseHref = href;
+    if (isUndefined(this._baseHref)) this._baseHref = this.getBaseHref();
+    return this._baseHref;
+  }
+  getBaseHref() {
+    const baseTag = document.getElementsByTagName("base")[0];
+    if (baseTag && baseTag.href) {
+      return baseTag.href.replace(/^([^/:]*:)?\/\/[^/]*/, "");
+    }
+    return this._isHtml5 ? "/" : location.pathname || "/";
+  }
+  dispose() {}
+}

package/src/router/core/vanilla/hashLocationService.js

@@ -0,0 +1,19 @@
+import { root, trimHashVal } from "../common/index";
+import { BaseLocationServices } from "./baseLocationService";
+/** A `LocationServices` that uses the browser hash "#" to get/set the current location */
+export class HashLocationService extends BaseLocationServices {
+  constructor(router) {
+    super(router, false);
+    root.addEventListener("hashchange", this._listener, false);
+  }
+  _get() {
+    return trimHashVal(this._location.hash);
+  }
+  _set(state, title, url, replace) {
+    this._location.hash = url;
+  }
+  dispose(router) {
+    super.dispose(router);
+    root.removeEventListener("hashchange", this._listener);
+  }
+}

package/src/router/core/vanilla/injector.js

@@ -0,0 +1,98 @@
+import {
+  extend,
+  assertPredicate,
+  isFunction,
+  isArray,
+  isInjectable,
+} from "../common/index";
+// globally available injectables
+const globals = {};
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const ARGUMENT_NAMES = /([^\s,]+)/g;
+/**
+ * A basic angular1-like injector api
+ *
+ * This object implements four methods similar to the
+ * [angular 1 dependency injector](https://docs.angularjs.org/api/auto/service/$injector)
+ *
+ * UI-Router evolved from an angular 1 library to a framework agnostic library.
+ * However, some of the `@uirouter/core` code uses these ng1 style APIs to support ng1 style dependency injection.
+ *
+ * This object provides a naive implementation of a globally scoped dependency injection system.
+ * It supports the following DI approaches:
+ *
+ * ### Function parameter names
+ *
+ * A function's `.toString()` is called, and the parameter names are parsed.
+ * This only works when the parameter names aren't "mangled" by a minifier such as UglifyJS.
+ *
+ * ```js
+ * function injectedFunction(FooService, BarService) {
+ *   // FooService and BarService are injected
+ * }
+ * ```
+ *
+ * ### Function annotation
+ *
+ * A function may be annotated with an array of dependency names as the `$inject` property.
+ *
+ * ```js
+ * injectedFunction.$inject = [ 'FooService', 'BarService' ];
+ * function injectedFunction(fs, bs) {
+ *   // FooService and BarService are injected as fs and bs parameters
+ * }
+ * ```
+ *
+ * ### Array notation
+ *
+ * An array provides the names of the dependencies to inject (as strings).
+ * The function is the last element of the array.
+ *
+ * ```js
+ * [ 'FooService', 'BarService', function (fs, bs) {
+ *   // FooService and BarService are injected as fs and bs parameters
+ * }]
+ * ```
+ *
+ * @type {$InjectorLike}
+ */
+export const $injector = {
+  /** Gets an object from DI based on a string token */
+  get: (name) => globals[name],
+  /** Returns true if an object named `name` exists in global DI */
+  has: (name) => $injector.get(name) != null,
+  /**
+   * Injects a function
+   *
+   * @param fn the function to inject
+   * @param context the function's `this` binding
+   * @param locals An object with additional DI tokens and values, such as `{ someToken: { foo: 1 } }`
+   */
+  invoke: (fn, context, locals) => {
+    const all = extend({}, globals, locals || {});
+    const params = $injector.annotate(fn);
+    const ensureExist = assertPredicate(
+      (key) => all.hasOwnProperty(key),
+      (key) => `DI can't find injectable: '${key}'`,
+    );
+    const args = params.filter(ensureExist).map((x) => all[x]);
+    if (isFunction(fn)) return fn.apply(context, args);
+    else return fn.slice(-1)[0].apply(context, args);
+  },
+  /**
+   * Returns a function's dependencies
+   *
+   * Analyzes a function (or array) and returns an array of DI tokens that the function requires.
+   * @return an array of `string`s
+   */
+  annotate: (fn) => {
+    if (!isInjectable(fn)) throw new Error(`Not an injectable function: ${fn}`);
+    if (fn && fn.$inject) return fn.$inject;
+    if (isArray(fn)) return fn.slice(0, -1);
+    const fnStr = fn.toString().replace(STRIP_COMMENTS, "");
+    const result = fnStr
+      .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
+      .match(ARGUMENT_NAMES);
+    return result || [];
+  },
+};

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

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

package/src/router/core/vanilla/memoryLocationConfig.js

@@ -0,0 +1,20 @@
+import { isDefined } from "../common/predicates";
+import { noop } from "../common/index";
+/** A `LocationConfig` mock that gets/sets all config from an in-memory object */
+export class MemoryLocationConfig {
+  constructor() {
+    this.dispose = noop;
+    this._baseHref = "";
+    this._port = 80;
+    this._protocol = "http";
+    this._host = "localhost";
+    this._hashPrefix = "";
+    this.port = () => this._port;
+    this.protocol = () => this._protocol;
+    this.host = () => this._host;
+    this.baseHref = () => this._baseHref;
+    this.html5Mode = () => false;
+    this.hashPrefix = (newval) =>
+      isDefined(newval) ? (this._hashPrefix = newval) : this._hashPrefix;
+  }
+}

package/src/router/core/vanilla/memoryLocationService.js

@@ -0,0 +1,13 @@
+import { BaseLocationServices } from "./baseLocationService";
+/** A `LocationServices` that gets/sets the current location from an in-memory object */
+export class MemoryLocationService extends BaseLocationServices {
+  constructor(router) {
+    super(router, true);
+  }
+  _get() {
+    return this._url;
+  }
+  _set(state, title, url, replace) {
+    this._url = url;
+  }
+}

package/src/router/core/vanilla/plugins.js

@@ -0,0 +1,35 @@
+import { BrowserLocationConfig } from "./browserLocationConfig";
+import { HashLocationService } from "./hashLocationService";
+import { locationPluginFactory } from "./utils";
+import { PushStateLocationService } from "./pushStateLocationService";
+import { MemoryLocationService } from "./memoryLocationService";
+import { MemoryLocationConfig } from "./memoryLocationConfig";
+import { $injector } from "./injector";
+import { $q } from "./q";
+import { services } from "../common/coreservices";
+export function servicesPlugin(router) {
+  services.$injector = $injector;
+  services.$q = $q;
+  return { name: "vanilla.services", $q, $injector, dispose: () => null };
+}
+/** A `UIRouterPlugin` uses the browser hash to get/set the current location */
+export const hashLocationPlugin = locationPluginFactory(
+  "vanilla.hashBangLocation",
+  false,
+  HashLocationService,
+  BrowserLocationConfig,
+);
+/** A `UIRouterPlugin` that gets/sets the current location using the browser's `location` and `history` apis */
+export const pushStateLocationPlugin = locationPluginFactory(
+  "vanilla.pushStateLocation",
+  true,
+  PushStateLocationService,
+  BrowserLocationConfig,
+);
+/** A `UIRouterPlugin` that gets/sets the current location from an in-memory object */
+export const memoryLocationPlugin = locationPluginFactory(
+  "vanilla.memoryLocation",
+  false,
+  MemoryLocationService,
+  MemoryLocationConfig,
+);

package/src/router/core/vanilla/pushStateLocationService.js

@@ -0,0 +1,69 @@
+import { BaseLocationServices } from "./baseLocationService";
+import {
+  root,
+  splitHash,
+  splitQuery,
+  stripLastPathElement,
+} from "../common/index";
+/**
+ * A `LocationServices` that gets/sets the current location using the browser's `location` and `history` apis
+ *
+ * Uses `history.pushState` and `history.replaceState`
+ */
+export class PushStateLocationService extends BaseLocationServices {
+  constructor(router) {
+    super(router, true);
+    this._config = router.urlService.config;
+    root.addEventListener("popstate", this._listener, false);
+  }
+  /**
+   * Gets the base prefix without:
+   * - trailing slash
+   * - trailing filename
+   * - protocol and hostname
+   *
+   * If <base href='/base/'>, this returns '/base'.
+   * If <base href='/foo/base/'>, this returns '/foo/base'.
+   * If <base href='/base/index.html'>, this returns '/base'.
+   * If <base href='http://localhost:8080/base/index.html'>, this returns '/base'.
+   * If <base href='/base'>, this returns ''.
+   * If <base href='http://localhost:8080'>, this returns ''.
+   * If <base href='http://localhost:8080/'>, this returns ''.
+   *
+   * See: https://html.spec.whatwg.org/dev/semantics.html#the-base-element
+   */
+  _getBasePrefix() {
+    return stripLastPathElement(this._config.baseHref());
+  }
+  _get() {
+    let { pathname, hash, search } = this._location;
+    search = splitQuery(search)[1]; // strip ? if found
+    hash = splitHash(hash)[1]; // strip # if found
+    const basePrefix = this._getBasePrefix();
+    const exactBaseHrefMatch = pathname === this._config.baseHref();
+    const startsWithBase = pathname.substr(0, basePrefix.length) === basePrefix;
+    pathname = exactBaseHrefMatch
+      ? "/"
+      : startsWithBase
+        ? pathname.substring(basePrefix.length)
+        : pathname;
+    return pathname + (search ? "?" + search : "") + (hash ? "#" + hash : "");
+  }
+  _set(state, title, url, replace) {
+    const basePrefix = this._getBasePrefix();
+    const slash = url && url[0] !== "/" ? "/" : "";
+    const fullUrl =
+      url === "" || url === "/"
+        ? this._config.baseHref()
+        : basePrefix + slash + url;
+    if (replace) {
+      this._history.replaceState(state, title, fullUrl);
+    } else {
+      this._history.pushState(state, title, fullUrl);
+    }
+  }
+  dispose(router) {
+    super.dispose(router);
+    root.removeEventListener("popstate", this._listener);
+  }
+}

package/src/router/core/vanilla/q.js

@@ -0,0 +1,54 @@
+import { isArray, isObject } from "../common/index";
+/**
+ * An angular1-like promise api
+ *
+ * This object implements four methods similar to the
+ * [angular 1 promise api](https://docs.angularjs.org/api/ng/service/$q)
+ *
+ * UI-Router evolved from an angular 1 library to a framework agnostic library.
+ * However, some of the `@uirouter/core` code uses these ng1 style APIs to support ng1 style dependency injection.
+ *
+ * This API provides native ES6 promise support wrapped as a $q-like API.
+ * Internally, UI-Router uses this $q object to perform promise operations.
+ * The `angular-ui-router` (ui-router for angular 1) uses the $q API provided by angular.
+ *
+ * $q-like promise api
+ */
+export const $q = {
+  /** Normalizes a value as a promise */
+  when: (val) => new Promise((resolve, reject) => resolve(val)),
+  /** Normalizes a value as a promise rejection */
+  reject: (val) =>
+    new Promise((resolve, reject) => {
+      reject(val);
+    }),
+  /** @returns a deferred object, which has `resolve` and `reject` functions */
+  defer: () => {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+      deferred.resolve = resolve;
+      deferred.reject = reject;
+    });
+    return deferred;
+  },
+  /** Like Promise.all(), but also supports object key/promise notation like $q */
+  all: (promises) => {
+    if (isArray(promises)) {
+      return Promise.all(promises);
+    }
+    if (isObject(promises)) {
+      // Convert promises map to promises array.
+      // When each promise resolves, map it to a tuple { key: key, val: val }
+      const chain = Object.keys(promises).map((key) =>
+        promises[key].then((val) => ({ key, val })),
+      );
+      // Then wait for all promises to resolve, and convert them back to an object
+      return $q.all(chain).then((values) =>
+        values.reduce((acc, tuple) => {
+          acc[tuple.key] = tuple.val;
+          return acc;
+        }, {}),
+      );
+    }
+  },
+};