@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/common/hof.js

@@ -0,0 +1,194 @@
+/**
+ * Higher order functions
+ *
+ * These utility functions are exported, but are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
+ *
+ * Given a function with N parameters, returns a new function that supports partial application.
+ * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,
+ * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to
+ * accept more parameters until all N parameters have been supplied.
+ *
+ *
+ * This contrived example uses a partially applied function as an predicate, which returns true
+ * if an object is found in both arrays.
+ * @example
+ * ```
+ * // returns true if an object is in both of the two arrays
+ * function inBoth(array1, array2, object) {
+ *   return array1.indexOf(object) !== -1 &&
+ *          array2.indexOf(object) !== 1;
+ * }
+ * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
+ * let foos = [obj1, obj3]
+ * let bars = [obj3, obj4, obj5]
+ *
+ * // A curried "copy" of inBoth
+ * let curriedInBoth = curry(inBoth);
+ * // Partially apply both the array1 and array2
+ * let inFoosAndBars = curriedInBoth(foos, bars);
+ *
+ * // Supply the final argument; since all arguments are
+ * // supplied, the original inBoth function is then called.
+ * let obj1InBoth = inFoosAndBars(obj1); // false
+ *
+ * // Use the inFoosAndBars as a predicate.
+ * // Filter, on each iteration, supplies the final argument
+ * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
+ * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
+ *
+ * ```
+ *
+ * @param fn
+ * @returns {*|function(): (*|any)}
+ */
+export function curry(fn) {
+  return function curried() {
+    if (arguments.length >= fn.length) {
+      return fn.apply(this, arguments);
+    }
+    const args = Array.prototype.slice.call(arguments);
+    return curried.bind(this, ...args);
+  };
+}
+/**
+ * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
+ * given: f(x), g(x), h(x)
+ * let composed = compose(f,g,h)
+ * then, composed is: f(g(h(x)))
+ */
+export function compose() {
+  const args = arguments;
+  const start = args.length - 1;
+  return function () {
+    let i = start,
+      result = args[start].apply(this, arguments);
+    while (i--) result = args[i].call(this, result);
+    return result;
+  };
+}
+/**
+ * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right
+ * given: f(x), g(x), h(x)
+ * let piped = pipe(f,g,h);
+ * then, piped is: h(g(f(x)))
+ */
+export function pipe(...funcs) {
+  return compose.apply(null, [].slice.call(arguments).reverse());
+}
+/**
+ * Given a property name, returns a function that returns that property from an object
+ * let obj = { foo: 1, name: "blarg" };
+ * let getName = prop("name");
+ * getName(obj) === "blarg"
+ */
+export const prop = (name) => (obj) => obj && obj[name];
+/**
+ * Given a property name and a value, returns a function that returns a boolean based on whether
+ * the passed object has a property that matches the value
+ * let obj = { foo: 1, name: "blarg" };
+ * let getName = propEq("name", "blarg");
+ * getName(obj) === true
+ */
+export const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
+/**
+ * Given a dotted property name, returns a function that returns a nested property from an object, or undefined
+ * let obj = { id: 1, nestedObj: { foo: 1, name: "blarg" }, };
+ * let getName = prop("nestedObj.name");
+ * getName(obj) === "blarg"
+ * let propNotFound = prop("this.property.doesnt.exist");
+ * propNotFound(obj) === undefined
+ */
+export const parse = (name) => pipe.apply(null, name.split(".").map(prop));
+/**
+ * Given a function that returns a truthy or falsey value, returns a
+ * function that returns the opposite (falsey or truthy) value given the same inputs
+ */
+export const not =
+  (fn) =>
+  (...args) =>
+    !fn.apply(null, args);
+/**
+ * Given two functions that return truthy or falsey values, returns a function that returns truthy
+ * if both functions return truthy for the given arguments
+ */
+export function and(fn1, fn2) {
+  return (...args) => fn1.apply(null, args) && fn2.apply(null, args);
+}
+/**
+ * Given two functions that return truthy or falsey values, returns a function that returns truthy
+ * if at least one of the functions returns truthy for the given arguments
+ */
+export function or(fn1, fn2) {
+  return (...args) => fn1.apply(null, args) || fn2.apply(null, args);
+}
+/**
+ * Check if all the elements of an array match a predicate function
+ *
+ * @param fn1 a predicate function `fn1`
+ * @returns a function which takes an array and returns true if `fn1` is true for all elements of the array
+ */
+export const all = (fn1) => (arr) => arr.reduce((b, x) => b && !!fn1(x), true);
+// tslint:disable-next-line:variable-name
+export const any = (fn1) => (arr) => arr.reduce((b, x) => b || !!fn1(x), false);
+/** Given a class, returns a Predicate function that returns true if the object is of that class */
+export const is = (ctor) => (obj) =>
+  (obj != null && obj.constructor === ctor) || obj instanceof ctor;
+/** Given a value, returns a Predicate function that returns true if another value is === equal to the original value */
+export const eq = (value) => (other) => value === other;
+/** Given a value, returns a function which returns the value */
+export const val = (v) => () => v;
+export function invoke(fnName, args) {
+  return (obj) => obj[fnName].apply(obj, args);
+}
+/**
+ * Sorta like Pattern Matching (a functional programming conditional construct)
+ *
+ * See http://c2.com/cgi/wiki?PatternMatching
+ *
+ * This is a conditional construct which allows a series of predicates and output functions
+ * to be checked and then applied.  Each predicate receives the input.  If the predicate
+ * returns truthy, then its matching output function (mapping function) is provided with
+ * the input and, then the result is returned.
+ *
+ * Each combination (2-tuple) of predicate + output function should be placed in an array
+ * of size 2: [ predicate, mapFn ]
+ *
+ * These 2-tuples should be put in an outer array.
+ *
+ * @example
+ * ```
+ *
+ * // Here's a 2-tuple where the first element is the isString predicate
+ * // and the second element is a function that returns a description of the input
+ * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
+ *
+ * // Second tuple: predicate "isNumber", mapfn returns a description
+ * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
+ *
+ * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
+ *
+ * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
+ *
+ * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
+ *
+ * console.log(descriptionOf(undefined)); // 'notdefined'
+ * console.log(descriptionOf(55)); // '(55) That's a number!'
+ * console.log(descriptionOf("foo")); // 'Here's your string foo'
+ * ```
+ *
+ * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
+ * with a Predicate and a mapping/output function
+ * @returns {function(any): *}
+ */
+export function pattern(struct) {
+  return function (x) {
+    for (let i = 0; i < struct.length; i++) {
+      if (struct[i][0](x)) return struct[i][1](x);
+    }
+  };
+}

package/src/router/core/common/predicates.js

@@ -0,0 +1,44 @@
+/**
+ * Predicates
+ *
+ * These predicates return true/false based on the input.
+ * Although these functions are exported, they are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+import { and, not, pipe, prop, or } from "./hof";
+const toStr = Object.prototype.toString;
+const tis = (t) => (x) => typeof x === t;
+export const isUndefined = tis("undefined");
+export const isDefined = not(isUndefined);
+export const isNull = (o) => o === null;
+export const isNullOrUndefined = or(isNull, isUndefined);
+export const isFunction = tis("function");
+export const isNumber = tis("number");
+export const isString = tis("string");
+export const isObject = (x) => x !== null && typeof x === "object";
+export const isArray = Array.isArray;
+export const isDate = (x) => toStr.call(x) === "[object Date]";
+export const isRegExp = (x) => toStr.call(x) === "[object RegExp]";
+/**
+ * Predicate which checks if a value is injectable
+ *
+ * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
+ * where all the elements in the array are Strings, except the last one, which is a Function
+ */
+export function isInjectable(val) {
+  if (isArray(val) && val.length) {
+    const head = val.slice(0, -1),
+      tail = val.slice(-1);
+    return !(
+      head.filter(not(isString)).length || tail.filter(not(isFunction)).length
+    );
+  }
+  return isFunction(val);
+}
+/**
+ * Predicate which checks if a value looks like a Promise
+ *
+ * It is probably a Promise if it's an object, and it has a `then` property which is a Function
+ */
+export const isPromise = and(isObject, pipe(prop("then"), isFunction));

package/src/router/core/common/queue.js

@@ -0,0 +1,41 @@
+import { pushTo } from "./common";
+export class Queue {
+  constructor(_items = [], _limit = null) {
+    this._items = _items;
+    this._limit = _limit;
+    this._evictListeners = [];
+    this.onEvict = pushTo(this._evictListeners);
+  }
+  enqueue(item) {
+    const items = this._items;
+    items.push(item);
+    if (this._limit && items.length > this._limit) this.evict();
+    return item;
+  }
+  evict() {
+    const item = this._items.shift();
+    this._evictListeners.forEach((fn) => fn(item));
+    return item;
+  }
+  dequeue() {
+    if (this.size()) return this._items.splice(0, 1)[0];
+  }
+  clear() {
+    const current = this._items;
+    this._items = [];
+    return current;
+  }
+  size() {
+    return this._items.length;
+  }
+  remove(item) {
+    const idx = this._items.indexOf(item);
+    return idx > -1 && this._items.splice(idx, 1)[0];
+  }
+  peekTail() {
+    return this._items[this._items.length - 1];
+  }
+  peekHead() {
+    if (this.size()) return this._items[0];
+  }
+}

package/src/router/core/common/safeConsole.js

@@ -0,0 +1,38 @@
+/**
+ * workaround for missing console object in IE9 when dev tools haven't been opened o_O
+ * @packageDocumentation
+ */
+/* tslint:disable:no-console */
+import { noop } from "./common";
+const noopConsoleStub = { log: noop, error: noop, table: noop };
+function ie9Console(console) {
+  const bound = (fn) => Function.prototype.bind.call(fn, console);
+  return {
+    log: bound(console.log),
+    error: bound(console.log),
+    table: bound(console.log),
+  };
+}
+function fallbackConsole(console) {
+  const log = console.log.bind(console);
+  const error = console.error ? console.error.bind(console) : log;
+  const table = console.table ? console.table.bind(console) : log;
+  return { log, error, table };
+}
+function getSafeConsole() {
+  // @ts-ignore
+  const isIE9 =
+    typeof document !== "undefined" &&
+    document.documentMode &&
+    document.documentMode === 9;
+  if (isIE9) {
+    return window && window.console
+      ? ie9Console(window.console)
+      : noopConsoleStub;
+  } else if (!console.table || !console.error) {
+    return fallbackConsole(console);
+  } else {
+    return console;
+  }
+}
+export const safeConsole = getSafeConsole();

package/src/router/core/common/strings.js

@@ -0,0 +1,141 @@
+/**
+ * Functions that manipulate strings
+ *
+ * Although these functions are exported, they are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+import {
+  isArray,
+  isFunction,
+  isInjectable,
+  isNull,
+  isObject,
+  isPromise,
+  isString,
+  isUndefined,
+} from "./predicates";
+import { Rejection } from "../transition/rejectFactory";
+import { identity, pushR, tail } from "./common";
+import { pattern, val } from "./hof";
+/**
+ * Returns a string shortened to a maximum length
+ *
+ * If the string is already less than the `max` length, return the string.
+ * Else return the string, shortened to `max - 3` and append three dots ("...").
+ *
+ * @param max the maximum length of the string to return
+ * @param str the input string
+ */
+export function maxLength(max, str) {
+  if (str.length <= max) return str;
+  return str.substr(0, max - 3) + "...";
+}
+/**
+ * Returns a string, with spaces added to the end, up to a desired str length
+ *
+ * If the string is already longer than the desired length, return the string.
+ * Else returns the string, with extra spaces on the end, such that it reaches `length` characters.
+ *
+ * @param length the desired length of the string to return
+ * @param str the input string
+ */
+export function padString(length, str) {
+  while (str.length < length) str += " ";
+  return str;
+}
+export function kebobString(camelCase) {
+  return camelCase
+    .replace(/^([A-Z])/, ($1) => $1.toLowerCase()) // replace first char
+    .replace(/([A-Z])/g, ($1) => "-" + $1.toLowerCase()); // replace rest
+}
+export function functionToString(fn) {
+  const fnStr = fnToString(fn);
+  const namedFunctionMatch = fnStr.match(/^(function [^ ]+\([^)]*\))/);
+  const toStr = namedFunctionMatch ? namedFunctionMatch[1] : fnStr;
+  const fnName = fn["name"] || "";
+  if (fnName && toStr.match(/function \(/)) {
+    return "function " + fnName + toStr.substr(9);
+  }
+  return toStr;
+}
+export function fnToString(fn) {
+  const _fn = isArray(fn) ? fn.slice(-1)[0] : fn;
+  return (_fn && _fn.toString()) || "undefined";
+}
+export function stringify(o) {
+  const seen = [];
+  const isRejection = Rejection.isRejectionPromise;
+  const hasToString = (obj) =>
+    isObject(obj) &&
+    !isArray(obj) &&
+    obj.constructor !== Object &&
+    isFunction(obj.toString);
+  const stringifyPattern = pattern([
+    [isUndefined, val("undefined")],
+    [isNull, val("null")],
+    [isPromise, val("[Promise]")],
+    [isRejection, (x) => x._transitionRejection.toString()],
+    [hasToString, (x) => x.toString()],
+    [isInjectable, functionToString],
+    [val(true), identity],
+  ]);
+  function format(value) {
+    if (isObject(value)) {
+      if (seen.indexOf(value) !== -1) return "[circular ref]";
+      seen.push(value);
+    }
+    return stringifyPattern(value);
+  }
+  if (isUndefined(o)) {
+    // Workaround for IE & Edge Spec incompatibility where replacer function would not be called when JSON.stringify
+    // is given `undefined` as value. To work around that, we simply detect `undefined` and bail out early by
+    // manually stringifying it.
+    return format(o);
+  }
+  return JSON.stringify(o, (key, value) => format(value)).replace(/\\"/g, '"');
+}
+/** Returns a function that splits a string on a character or substring */
+export const beforeAfterSubstr = (char) => (str) => {
+  if (!str) return ["", ""];
+  const idx = str.indexOf(char);
+  if (idx === -1) return [str, ""];
+  return [str.substr(0, idx), str.substr(idx + 1)];
+};
+export const hostRegex = new RegExp("^(?:[a-z]+:)?//[^/]+/");
+export const stripLastPathElement = (str) => str.replace(/\/[^/]*$/, "");
+export const splitHash = beforeAfterSubstr("#");
+export const splitQuery = beforeAfterSubstr("?");
+export const splitEqual = beforeAfterSubstr("=");
+export const trimHashVal = (str) => (str ? str.replace(/^#/, "") : "");
+/**
+ * Splits on a delimiter, but returns the delimiters in the array
+ *
+ * #### Example:
+ * ```js
+ * var splitOnSlashes = splitOnDelim('/');
+ * splitOnSlashes("/foo"); // ["/", "foo"]
+ * splitOnSlashes("/foo/"); // ["/", "foo", "/"]
+ * ```
+ */
+export function splitOnDelim(delim) {
+  const re = new RegExp("(" + delim + ")", "g");
+  return (str) => str.split(re).filter(identity);
+}
+/**
+ * Reduce fn that joins neighboring strings
+ *
+ * Given an array of strings, returns a new array
+ * where all neighboring strings have been joined.
+ *
+ * #### Example:
+ * ```js
+ * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
+ * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
+ * ```
+ */
+export function joinNeighborsR(acc, x) {
+  if (isString(tail(acc)) && isString(x))
+    return acc.slice(0, -1).concat(tail(acc) + x);
+  return pushR(acc, x);
+}

package/src/router/core/common/trace.js

@@ -0,0 +1,232 @@
+/**
+ * # Transition tracing (debug)
+ *
+ * Enable transition tracing to print transition information to the console,
+ * in order to help debug your application.
+ * Tracing logs detailed information about each Transition to your console.
+ *
+ * To enable tracing, import the [[Trace]] singleton and enable one or more categories.
+ *
+ * ### ES6
+ * ```js
+ * import {trace} from "@uirouter/core/index";
+ * trace.enable(1, 5); // TRANSITION and VIEWCONFIG
+ * ```
+ *
+ * ### CJS
+ * ```js
+ * let trace = require("@uirouter/core").trace;
+ * trace.enable("TRANSITION", "VIEWCONFIG");
+ * ```
+ *
+ * ### Globals
+ * ```js
+ * let trace = window["@uirouter/core"].trace;
+ * trace.enable(); // Trace everything (very verbose)
+ * ```
+ *
+ * ### Angular 1:
+ * ```js
+ * app.run($trace => $trace.enable());
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { parse } from "../common/hof";
+import { isNumber } from "../common/predicates";
+import { stringify, functionToString, maxLength, padString } from "./strings";
+import { safeConsole } from "./safeConsole";
+function uiViewString(uiview) {
+  if (!uiview) return "ui-view (defunct)";
+  const state = uiview.creationContext
+    ? uiview.creationContext.name || "(root)"
+    : "(none)";
+  return `[ui-view#${uiview.id} ${uiview.$type}:${uiview.fqn} (${uiview.name}@${state})]`;
+}
+const viewConfigString = (viewConfig) => {
+  const view = viewConfig.viewDecl;
+  const state = view.$context.name || "(root)";
+  return `[View#${viewConfig.$id} from '${state}' state]: target ui-view: '${view.$uiViewName}@${view.$uiViewContextAnchor}'`;
+};
+function normalizedCat(input) {
+  return isNumber(input) ? Category[input] : Category[Category[input]];
+}
+/**
+ * Trace categories Enum
+ *
+ * Enable or disable a category using [[Trace.enable]] or [[Trace.disable]]
+ *
+ * `trace.enable(Category.TRANSITION)`
+ *
+ * These can also be provided using a matching string, or position ordinal
+ *
+ * `trace.enable("TRANSITION")`
+ *
+ * `trace.enable(1)`
+ */
+var Category;
+(function (Category) {
+  Category[(Category["RESOLVE"] = 0)] = "RESOLVE";
+  Category[(Category["TRANSITION"] = 1)] = "TRANSITION";
+  Category[(Category["HOOK"] = 2)] = "HOOK";
+  Category[(Category["UIVIEW"] = 3)] = "UIVIEW";
+  Category[(Category["VIEWCONFIG"] = 4)] = "VIEWCONFIG";
+})(Category || (Category = {}));
+export { Category };
+const _tid = parse("$id");
+const _rid = parse("router.$id");
+const transLbl = (trans) => `Transition #${_tid(trans)}-${_rid(trans)}`;
+/**
+ * Prints UI-Router Transition trace information to the console.
+ */
+export class Trace {
+  /** @internal */
+  constructor() {
+    /** @internal */
+    this._enabled = {};
+    this.approximateDigests = 0;
+  }
+  /** @internal */
+  _set(enabled, categories) {
+    if (!categories.length) {
+      categories = Object.keys(Category)
+        .map((k) => parseInt(k, 10))
+        .filter((k) => !isNaN(k))
+        .map((key) => Category[key]);
+    }
+    categories
+      .map(normalizedCat)
+      .forEach((category) => (this._enabled[category] = enabled));
+  }
+  enable(...categories) {
+    this._set(true, categories);
+  }
+  disable(...categories) {
+    this._set(false, categories);
+  }
+  /**
+   * Retrieves the enabled stateus of a [[Category]]
+   *
+   * ```js
+   * trace.enabled("VIEWCONFIG"); // true or false
+   * ```
+   *
+   * @returns boolean true if the category is enabled
+   */
+  enabled(category) {
+    return !!this._enabled[normalizedCat(category)];
+  }
+  /** @internal called by ui-router code */
+  traceTransitionStart(trans) {
+    if (!this.enabled(Category.TRANSITION)) return;
+    safeConsole.log(`${transLbl(trans)}: Started  -> ${stringify(trans)}`);
+  }
+  /** @internal called by ui-router code */
+  traceTransitionIgnored(trans) {
+    if (!this.enabled(Category.TRANSITION)) return;
+    safeConsole.log(`${transLbl(trans)}: Ignored  <> ${stringify(trans)}`);
+  }
+  /** @internal called by ui-router code */
+  traceHookInvocation(step, trans, options) {
+    if (!this.enabled(Category.HOOK)) return;
+    const event = parse("traceData.hookType")(options) || "internal",
+      context =
+        parse("traceData.context.state.name")(options) ||
+        parse("traceData.context")(options) ||
+        "unknown",
+      name = functionToString(step.registeredHook.callback);
+    safeConsole.log(
+      `${transLbl(trans)}:   Hook -> ${event} context: ${context}, ${maxLength(200, name)}`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceHookResult(hookResult, trans, transitionOptions) {
+    if (!this.enabled(Category.HOOK)) return;
+    safeConsole.log(
+      `${transLbl(trans)}:   <- Hook returned: ${maxLength(200, stringify(hookResult))}`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceResolvePath(path, when, trans) {
+    if (!this.enabled(Category.RESOLVE)) return;
+    safeConsole.log(`${transLbl(trans)}:         Resolving ${path} (${when})`);
+  }
+  /** @internal called by ui-router code */
+  traceResolvableResolved(resolvable, trans) {
+    if (!this.enabled(Category.RESOLVE)) return;
+    safeConsole.log(
+      `${transLbl(trans)}:               <- Resolved  ${resolvable} to: ${maxLength(200, stringify(resolvable.data))}`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceError(reason, trans) {
+    if (!this.enabled(Category.TRANSITION)) return;
+    safeConsole.log(
+      `${transLbl(trans)}: <- Rejected ${stringify(trans)}, reason: ${reason}`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceSuccess(finalState, trans) {
+    if (!this.enabled(Category.TRANSITION)) return;
+    safeConsole.log(
+      `${transLbl(trans)}: <- Success  ${stringify(trans)}, final state: ${finalState.name}`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceUIViewEvent(event, viewData, extra = "") {
+    if (!this.enabled(Category.UIVIEW)) return;
+    safeConsole.log(
+      `ui-view: ${padString(30, event)} ${uiViewString(viewData)}${extra}`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceUIViewConfigUpdated(viewData, context) {
+    if (!this.enabled(Category.UIVIEW)) return;
+    this.traceUIViewEvent(
+      "Updating",
+      viewData,
+      ` with ViewConfig from context='${context}'`,
+    );
+  }
+  /** @internal called by ui-router code */
+  traceUIViewFill(viewData, html) {
+    if (!this.enabled(Category.UIVIEW)) return;
+    this.traceUIViewEvent("Fill", viewData, ` with: ${maxLength(200, html)}`);
+  }
+  /** @internal called by ui-router code */
+  traceViewSync(pairs) {
+    if (!this.enabled(Category.VIEWCONFIG)) return;
+    const uivheader = "uiview component fqn";
+    const cfgheader = "view config state (view name)";
+    const mapping = pairs
+      .map(({ uiView, viewConfig }) => {
+        const uiv = uiView && uiView.fqn;
+        const cfg =
+          viewConfig &&
+          `${viewConfig.viewDecl.$context.name}: (${viewConfig.viewDecl.$name})`;
+        return { [uivheader]: uiv, [cfgheader]: cfg };
+      })
+      .sort((a, b) => (a[uivheader] || "").localeCompare(b[uivheader] || ""));
+    safeConsole.table(mapping);
+  }
+  /** @internal called by ui-router code */
+  traceViewServiceEvent(event, viewConfig) {
+    if (!this.enabled(Category.VIEWCONFIG)) return;
+    safeConsole.log(`VIEWCONFIG: ${event} ${viewConfigString(viewConfig)}`);
+  }
+  /** @internal called by ui-router code */
+  traceViewServiceUIViewEvent(event, viewData) {
+    if (!this.enabled(Category.VIEWCONFIG)) return;
+    safeConsole.log(`VIEWCONFIG: ${event} ${uiViewString(viewData)}`);
+  }
+}
+/**
+ * The [[Trace]] singleton
+ *
+ * #### Example:
+ * ```js
+ * import {trace} from "@uirouter/core/index";
+ * trace.enable(1, 5);
+ * ```
+ */
+export const trace = new Trace();