@angular-wave/angular.ts 0.0.11 → 0.0.13

package/src/router/core/transition/transitionEventType.js

@@ -0,0 +1,27 @@
+import { TransitionHook } from "./transitionHook";
+/**
+ * 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`.
+ */
+export class TransitionEventType {
+  /* tslint:disable:no-inferrable-types */
+  constructor(
+    name,
+    hookPhase,
+    hookOrder,
+    criteriaMatchPath,
+    reverseSort = false,
+    getResultHandler = TransitionHook.HANDLE_RESULT,
+    getErrorHandler = TransitionHook.REJECT_ERROR,
+    synchronous = false,
+  ) {
+    this.name = name;
+    this.hookPhase = hookPhase;
+    this.hookOrder = hookOrder;
+    this.criteriaMatchPath = criteriaMatchPath;
+    this.reverseSort = reverseSort;
+    this.getResultHandler = getResultHandler;
+    this.getErrorHandler = getErrorHandler;
+    this.synchronous = synchronous;
+  }
+}

package/src/router/core/transition/transitionHook.js

@@ -0,0 +1,199 @@
+import { TransitionHookPhase } from "./interface";
+import { defaults, noop, silentRejection } from "../common/common";
+import { fnToString, maxLength } from "../common/strings";
+import { isPromise } from "../common/predicates";
+import { is, parse } from "../common/hof";
+import { trace } from "../common/trace";
+import { services } from "../common/coreservices";
+import { Rejection } from "./rejectFactory";
+import { TargetState } from "../state/targetState";
+const defaultOptions = {
+  current: noop,
+  transition: null,
+  traceData: {},
+  bind: null,
+};
+export class TransitionHook {
+  /**
+   * Chains together an array of TransitionHooks.
+   *
+   * Given a list of [[TransitionHook]] objects, chains them together.
+   * Each hook is invoked after the previous one completes.
+   *
+   * #### Example:
+   * ```js
+   * var hooks: TransitionHook[] = getHooks();
+   * let promise: Promise<any> = TransitionHook.chain(hooks);
+   *
+   * promise.then(handleSuccess, handleError);
+   * ```
+   *
+   * @param hooks the list of hooks to chain together
+   * @param waitFor if provided, the chain is `.then()`'ed off this promise
+   * @returns a `Promise` for sequentially invoking the hooks (in order)
+   */
+  static chain(hooks, waitFor) {
+    // Chain the next hook off the previous
+    const createHookChainR = (prev, nextHook) =>
+      prev.then(() => nextHook.invokeHook());
+    return hooks.reduce(createHookChainR, waitFor || services.$q.when());
+  }
+  /**
+   * Invokes all the provided TransitionHooks, in order.
+   * Each hook's return value is checked.
+   * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
+   * If no hook returns a promise, then all hooks are processed synchronously.
+   *
+   * @param hooks the list of TransitionHooks to invoke
+   * @param doneCallback a callback that is invoked after all the hooks have successfully completed
+   *
+   * @returns a promise for the async result, or the result of the callback
+   */
+  static invokeHooks(hooks, doneCallback) {
+    for (let idx = 0; idx < hooks.length; idx++) {
+      const hookResult = hooks[idx].invokeHook();
+      if (isPromise(hookResult)) {
+        const remainingHooks = hooks.slice(idx + 1);
+        return TransitionHook.chain(remainingHooks, hookResult).then(
+          doneCallback,
+        );
+      }
+    }
+    return doneCallback();
+  }
+  /**
+   * Run all TransitionHooks, ignoring their return value.
+   */
+  static runAllHooks(hooks) {
+    hooks.forEach((hook) => hook.invokeHook());
+  }
+  constructor(transition, stateContext, registeredHook, options) {
+    this.transition = transition;
+    this.stateContext = stateContext;
+    this.registeredHook = registeredHook;
+    this.options = options;
+    this.isSuperseded = () =>
+      this.type.hookPhase === TransitionHookPhase.RUN &&
+      !this.options.transition.isActive();
+    this.options = defaults(options, defaultOptions);
+    this.type = registeredHook.eventType;
+  }
+  logError(err) {
+    this.transition.router.stateService.defaultErrorHandler()(err);
+  }
+  invokeHook() {
+    const hook = this.registeredHook;
+    if (hook._deregistered) return;
+    const notCurrent = this.getNotCurrentRejection();
+    if (notCurrent) return notCurrent;
+    const options = this.options;
+    trace.traceHookInvocation(this, this.transition, options);
+    const invokeCallback = () =>
+      hook.callback.call(options.bind, this.transition, this.stateContext);
+    const normalizeErr = (err) => Rejection.normalize(err).toPromise();
+    const handleError = (err) => hook.eventType.getErrorHandler(this)(err);
+    const handleResult = (result) =>
+      hook.eventType.getResultHandler(this)(result);
+    try {
+      const result = invokeCallback();
+      if (!this.type.synchronous && isPromise(result)) {
+        return result.catch(normalizeErr).then(handleResult, handleError);
+      } else {
+        return handleResult(result);
+      }
+    } catch (err) {
+      // If callback throws (synchronously)
+      return handleError(Rejection.normalize(err));
+    } finally {
+      if (hook.invokeLimit && ++hook.invokeCount >= hook.invokeLimit) {
+        hook.deregister();
+      }
+    }
+  }
+  /**
+   * This method handles the return value of a Transition Hook.
+   *
+   * A hook can return false (cancel), a TargetState (redirect),
+   * or a promise (which may later resolve to false or a redirect)
+   *
+   * This also handles "transition superseded" -- when a new transition
+   * was started while the hook was still running
+   */
+  handleHookResult(result) {
+    const notCurrent = this.getNotCurrentRejection();
+    if (notCurrent) return notCurrent;
+    // Hook returned a promise
+    if (isPromise(result)) {
+      // Wait for the promise, then reprocess with the resulting value
+      return result.then((val) => this.handleHookResult(val));
+    }
+    trace.traceHookResult(result, this.transition, this.options);
+    // Hook returned false
+    if (result === false) {
+      // Abort this Transition
+      return Rejection.aborted("Hook aborted transition").toPromise();
+    }
+    const isTargetState = is(TargetState);
+    // hook returned a TargetState
+    if (isTargetState(result)) {
+      // Halt the current Transition and redirect (a new Transition) to the TargetState.
+      return Rejection.redirected(result).toPromise();
+    }
+  }
+  /**
+   * Return a Rejection promise if the transition is no longer current due
+   * to a stopped router (disposed), or a new transition has started and superseded this one.
+   */
+  getNotCurrentRejection() {
+    const router = this.transition.router;
+    // The router is stopped
+    if (router._disposed) {
+      return Rejection.aborted(
+        `UIRouter instance #${router.$id} has been stopped (disposed)`,
+      ).toPromise();
+    }
+    if (this.transition._aborted) {
+      return Rejection.aborted().toPromise();
+    }
+    // This transition is no longer current.
+    // Another transition started while this hook was still running.
+    if (this.isSuperseded()) {
+      // Abort this transition
+      return Rejection.superseded(this.options.current()).toPromise();
+    }
+  }
+  toString() {
+    const { options, registeredHook } = this;
+    const event = parse("traceData.hookType")(options) || "internal",
+      context =
+        parse("traceData.context.state.name")(options) ||
+        parse("traceData.context")(options) ||
+        "unknown",
+      name = fnToString(registeredHook.callback);
+    return `${event} context: ${context}, ${maxLength(200, name)}`;
+  }
+}
+/**
+ * These GetResultHandler(s) are used by [[invokeHook]] below
+ * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
+ */
+TransitionHook.HANDLE_RESULT = (hook) => (result) =>
+  hook.handleHookResult(result);
+/**
+ * If the result is a promise rejection, log it.
+ * Otherwise, ignore the result.
+ */
+TransitionHook.LOG_REJECTED_RESULT = (hook) => (result) => {
+  isPromise(result) &&
+    result.catch((err) => hook.logError(Rejection.normalize(err)));
+  return undefined;
+};
+/**
+ * These GetErrorHandler(s) are used by [[invokeHook]] below
+ * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
+ */
+TransitionHook.LOG_ERROR = (hook) => (error) => hook.logError(error);
+TransitionHook.REJECT_ERROR = (hook) => (error) => silentRejection(error);
+TransitionHook.THROW_ERROR = (hook) => (error) => {
+  throw error;
+};

package/src/router/core/transition/transitionService.js

@@ -0,0 +1,311 @@
+import { TransitionHookScope, TransitionHookPhase } from "./interface";
+import { Transition } from "./transition";
+import { makeEvent } from "./hookRegistry";
+import {
+  registerAddCoreResolvables,
+  treeChangesCleanup,
+} from "../hooks/coreResolvables";
+import { registerRedirectToHook } from "../hooks/redirectTo";
+import {
+  registerOnExitHook,
+  registerOnRetainHook,
+  registerOnEnterHook,
+} from "../hooks/onEnterExitRetain";
+import {
+  registerEagerResolvePath,
+  registerLazyResolveState,
+  registerResolveRemaining,
+} from "../hooks/resolve";
+import {
+  registerLoadEnteringViews,
+  registerActivateViews,
+} from "../hooks/views";
+import { registerUpdateGlobalState } from "../hooks/updateGlobals";
+import { registerUpdateUrl } from "../hooks/url";
+import { registerLazyLoadHook } from "../hooks/lazyLoad";
+import { TransitionEventType } from "./transitionEventType";
+import { TransitionHook } from "./transitionHook";
+import { isDefined } from "../common/predicates";
+import { removeFrom, createProxyFunctions } from "../common/common";
+import { val } from "../common/hof";
+import { registerIgnoredTransitionHook } from "../hooks/ignoredTransition";
+import { registerInvalidTransitionHook } from "../hooks/invalidTransition";
+/**
+ * The default [[Transition]] options.
+ *
+ * Include this object when applying custom defaults:
+ * let reloadOpts = { reload: true, notify: true }
+ * let options = defaults(theirOpts, customDefaults, defaultOptions);
+ */
+export let defaultTransOpts = {
+  location: true,
+  relative: null,
+  inherit: false,
+  notify: true,
+  reload: false,
+  supercede: true,
+  custom: {},
+  current: () => null,
+  source: "unknown",
+};
+/**
+ * This class provides services related to Transitions.
+ *
+ * - Most importantly, it allows global Transition Hooks to be registered.
+ * - It allows the default transition error handler to be set.
+ * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).
+ *
+ * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.
+ *
+ * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
+ */
+export class TransitionService {
+  /** @internal */
+  constructor(_router) {
+    /** @internal */
+    this._transitionCount = 0;
+    /** The transition hook types, such as `onEnter`, `onStart`, etc */
+    this._eventTypes = [];
+    /** @internal The registered transition hooks */
+    this._registeredHooks = {};
+    /** The  paths on a criteria object */
+    this._criteriaPaths = {};
+    this._router = _router;
+    this.$view = _router.viewService;
+    this._deregisterHookFns = {};
+    this._pluginapi = createProxyFunctions(val(this), {}, val(this), [
+      "_definePathType",
+      "_defineEvent",
+      "_getPathTypes",
+      "_getEvents",
+      "getHooks",
+    ]);
+    this._defineCorePaths();
+    this._defineCoreEvents();
+    this._registerCoreTransitionHooks();
+    _router.globals.successfulTransitions.onEvict(treeChangesCleanup);
+  }
+  /**
+   * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
+   *
+   * Registers a transition lifecycle hook, which is invoked during transition construction.
+   *
+   * This low level hook should only be used by plugins.
+   * This can be a useful time for plugins to add resolves or mutate the transition as needed.
+   * The Sticky States plugin uses this hook to modify the treechanges.
+   *
+   * ### Lifecycle
+   *
+   * `onCreate` hooks are invoked *while a transition is being constructed*.
+   *
+   * ### Return value
+   *
+   * The hook's return value is ignored
+   *
+   * @internal
+   * @param criteria defines which Transitions the Hook should be invoked for.
+   * @param callback the hook function which will be invoked.
+   * @param options the registration options
+   * @returns a function which deregisters the hook.
+   */
+  onCreate(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onBefore(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onStart(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onExit(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onRetain(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onEnter(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onFinish(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onSuccess(criteria, callback, options) {
+    return;
+  }
+  /** @inheritdoc */
+  onError(criteria, callback, options) {
+    return;
+  }
+  /**
+   * dispose
+   * @internal
+   */
+  dispose(router) {
+    Object.values(this._registeredHooks).forEach((hooksArray) =>
+      hooksArray.forEach((hook) => {
+        hook._deregistered = true;
+        removeFrom(hooksArray, hook);
+      }),
+    );
+  }
+  /**
+   * Creates a new [[Transition]] object
+   *
+   * This is a factory function for creating new Transition objects.
+   * It is used internally by the [[StateService]] and should generally not be called by application code.
+   *
+   * @internal
+   * @param fromPath the path to the current state (the from state)
+   * @param targetState the target state (destination)
+   * @returns a Transition
+   */
+  create(fromPath, targetState) {
+    return new Transition(fromPath, targetState, this._router);
+  }
+  /** @internal */
+  _defineCoreEvents() {
+    const Phase = TransitionHookPhase;
+    const TH = TransitionHook;
+    const paths = this._criteriaPaths;
+    const NORMAL_SORT = false,
+      REVERSE_SORT = true;
+    const SYNCHRONOUS = true;
+    this._defineEvent(
+      "onCreate",
+      Phase.CREATE,
+      0,
+      paths.to,
+      NORMAL_SORT,
+      TH.LOG_REJECTED_RESULT,
+      TH.THROW_ERROR,
+      SYNCHRONOUS,
+    );
+    this._defineEvent("onBefore", Phase.BEFORE, 0, paths.to);
+    this._defineEvent("onStart", Phase.RUN, 0, paths.to);
+    this._defineEvent("onExit", Phase.RUN, 100, paths.exiting, REVERSE_SORT);
+    this._defineEvent("onRetain", Phase.RUN, 200, paths.retained);
+    this._defineEvent("onEnter", Phase.RUN, 300, paths.entering);
+    this._defineEvent("onFinish", Phase.RUN, 400, paths.to);
+    this._defineEvent(
+      "onSuccess",
+      Phase.SUCCESS,
+      0,
+      paths.to,
+      NORMAL_SORT,
+      TH.LOG_REJECTED_RESULT,
+      TH.LOG_ERROR,
+      SYNCHRONOUS,
+    );
+    this._defineEvent(
+      "onError",
+      Phase.ERROR,
+      0,
+      paths.to,
+      NORMAL_SORT,
+      TH.LOG_REJECTED_RESULT,
+      TH.LOG_ERROR,
+      SYNCHRONOUS,
+    );
+  }
+  /** @internal */
+  _defineCorePaths() {
+    const { STATE, TRANSITION } = TransitionHookScope;
+    this._definePathType("to", TRANSITION);
+    this._definePathType("from", TRANSITION);
+    this._definePathType("exiting", STATE);
+    this._definePathType("retained", STATE);
+    this._definePathType("entering", STATE);
+  }
+  /** @internal */
+  _defineEvent(
+    name,
+    hookPhase,
+    hookOrder,
+    criteriaMatchPath,
+    reverseSort = false,
+    getResultHandler = TransitionHook.HANDLE_RESULT,
+    getErrorHandler = TransitionHook.REJECT_ERROR,
+    synchronous = false,
+  ) {
+    const eventType = new TransitionEventType(
+      name,
+      hookPhase,
+      hookOrder,
+      criteriaMatchPath,
+      reverseSort,
+      getResultHandler,
+      getErrorHandler,
+      synchronous,
+    );
+    this._eventTypes.push(eventType);
+    makeEvent(this, this, eventType);
+  }
+  /** @internal */
+  _getEvents(phase) {
+    const transitionHookTypes = isDefined(phase)
+      ? this._eventTypes.filter((type) => type.hookPhase === phase)
+      : this._eventTypes.slice();
+    return transitionHookTypes.sort((l, r) => {
+      const cmpByPhase = l.hookPhase - r.hookPhase;
+      return cmpByPhase === 0 ? l.hookOrder - r.hookOrder : cmpByPhase;
+    });
+  }
+  /**
+   * Adds a Path to be used as a criterion against a TreeChanges path
+   *
+   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
+   * Each state in the exiting path is checked against the criteria and returned as part of the match.
+   *
+   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
+   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
+   *
+   * @internal
+   */
+  _definePathType(name, hookScope) {
+    this._criteriaPaths[name] = { name, scope: hookScope };
+  }
+  /** @internal */
+  // tslint:disable-next-line
+  _getPathTypes() {
+    return this._criteriaPaths;
+  }
+  /** @internal */
+  getHooks(hookName) {
+    return this._registeredHooks[hookName];
+  }
+  /** @internal */
+  _registerCoreTransitionHooks() {
+    const fns = this._deregisterHookFns;
+    fns.addCoreResolves = registerAddCoreResolvables(this);
+    fns.ignored = registerIgnoredTransitionHook(this);
+    fns.invalid = registerInvalidTransitionHook(this);
+    // Wire up redirectTo hook
+    fns.redirectTo = registerRedirectToHook(this);
+    // Wire up onExit/Retain/Enter state hooks
+    fns.onExit = registerOnExitHook(this);
+    fns.onRetain = registerOnRetainHook(this);
+    fns.onEnter = registerOnEnterHook(this);
+    // Wire up Resolve hooks
+    fns.eagerResolve = registerEagerResolvePath(this);
+    fns.lazyResolve = registerLazyResolveState(this);
+    fns.resolveAll = registerResolveRemaining(this);
+    // Wire up the View management hooks
+    fns.loadViews = registerLoadEnteringViews(this);
+    fns.activateViews = registerActivateViews(this);
+    // Updates global state after a transition
+    fns.updateGlobals = registerUpdateGlobalState(this);
+    // After globals.current is updated at priority: 10000
+    fns.updateUrl = registerUpdateUrl(this);
+    // Lazy load state trees
+    fns.lazyLoad = registerLazyLoadHook(this);
+  }
+}

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

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

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

@@ -0,0 +1,165 @@
+import { ParamTypes } from "../../core/params/paramTypes";
+import { isDefined, isString } from "../../../core/utils";
+/**
+ * An API to customize the URL behavior and retrieve URL configuration
+ *
+ * This API is used to customize the behavior of the URL.
+ * This includes optional trailing slashes ([[strictMode]]), case sensitivity ([[caseInsensitive]]),
+ * and custom parameter encoding (custom [[type]]).
+ *
+ * It also has information about the location (url) configuration such as [[port]] and [[baseHref]].
+ * This information can be used to build absolute URLs, such as
+ * `https://example.com:443/basepath/state/substate?param1=a#hashvalue`;
+ *
+ * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
+ */
+export class UrlConfig {
+  /** @internal */ constructor(/** @internal */ router) {
+    this.router = router;
+    /** @internal */ this.paramTypes = new ParamTypes();
+    /** @internal */ this._decodeParams = true;
+    /** @internal */ this._isCaseInsensitive = false;
+    /** @internal */ this._isStrictMode = true;
+    /** @internal */ this._defaultSquashPolicy = false;
+    /** @internal */ this.dispose = () => this.paramTypes.dispose();
+    // Delegate these calls to the current LocationConfig implementation
+    /**
+     * Gets the base Href, e.g., `http://localhost/approot/`
+     *
+     * @return the application's base href
+     */
+    this.baseHref = () => this.router.locationConfig.baseHref();
+    /**
+     * Gets or sets the hashPrefix
+     *
+     * This only applies when not running in [[html5Mode]] (pushstate mode)
+     *
+     * If the current url is `http://localhost/app#!/uirouter/path/#anchor`, it returns `!` which is the prefix for the "hashbang" portion.
+     *
+     * @return the hash prefix
+     */
+    this.hashPrefix = (newprefix) =>
+      this.router.locationConfig.hashPrefix(newprefix);
+    /**
+     * Gets the host, e.g., `localhost`
+     *
+     * @return the protocol
+     */
+    this.host = () => this.router.locationConfig.host();
+    /**
+     * Returns true when running in pushstate mode
+     *
+     * @return true when running in html5 mode (pushstate mode).
+     */
+    this.html5Mode = () => this.router.locationConfig.html5Mode();
+    /**
+     * Gets the port, e.g., `80`
+     *
+     * @return the port number
+     */
+    this.port = () => this.router.locationConfig.port();
+    /**
+     * Gets the protocol, e.g., `http`
+     *
+     * @return the protocol
+     */
+    this.protocol = () => this.router.locationConfig.protocol();
+  }
+  /**
+   * Defines whether URL matching should be case sensitive (the default behavior), or not.
+   *
+   * #### Example:
+   * ```js
+   * // Allow case insensitive url matches
+   * urlService.config.caseInsensitive(true);
+   * ```
+   *
+   * @param value `false` to match URL in a case sensitive manner; otherwise `true`;
+   * @returns the current value of caseInsensitive
+   */
+  caseInsensitive(value) {
+    return (this._isCaseInsensitive = isDefined(value)
+      ? value
+      : this._isCaseInsensitive);
+  }
+  /**
+   * Sets the default behavior when generating or matching URLs with default parameter values.
+   *
+   * #### Example:
+   * ```js
+   * // Remove default parameter values from the url
+   * urlService.config.defaultSquashPolicy(true);
+   * ```
+   *
+   * @param value A string that defines the default parameter URL squashing behavior.
+   *    - `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL
+   *    - `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the
+   *      parameter is surrounded by slashes, squash (remove) one slash from the URL
+   *    - any other string, e.g. "~": When generating an href with a default parameter value, squash (remove)
+   *      the parameter value from the URL and replace it with this string.
+   * @returns the current value of defaultSquashPolicy
+   */
+  defaultSquashPolicy(value) {
+    if (
+      isDefined(value) &&
+      value !== true &&
+      value !== false &&
+      !isString(value)
+    )
+      throw new Error(
+        `Invalid squash policy: ${value}. Valid policies: false, true, arbitrary-string`,
+      );
+    return (this._defaultSquashPolicy = isDefined(value)
+      ? value
+      : this._defaultSquashPolicy);
+  }
+  /**
+   * Defines whether URLs should match trailing slashes, or not (the default behavior).
+   *
+   * #### Example:
+   * ```js
+   * // Allow optional trailing slashes
+   * urlService.config.strictMode(false);
+   * ```
+   *
+   * @param value `false` to match trailing slashes in URLs, otherwise `true`.
+   * @returns the current value of strictMode
+   */
+  strictMode(value) {
+    return (this._isStrictMode = isDefined(value) ? value : this._isStrictMode);
+  }
+  /**
+   * Creates and registers a custom [[ParamType]] object
+   *
+   * A custom parameter type can be used to generate URLs with typed parameters or custom encoding/decoding.
+   *
+   * #### Note: Register custom types *before using them* in a state definition.
+   *
+   * #### Example:
+   * ```js
+   * // Encode object parameter as JSON string
+   * urlService.config.type('myjson', {
+   *   encode: (obj) => JSON.stringify(obj),
+   *   decode: (str) => JSON.parse(str),
+   *   is: (val) => typeof(val) === 'object',
+   *   pattern: /[^/]+/,
+   *   equals: (a, b) => _.isEqual(a, b),
+   * });
+   * ```
+   *
+   * See [[ParamTypeDefinition]] for more examples
+   *
+   * @param name The type name.
+   * @param definition The type definition. See [[ParamTypeDefinition]] for information on the values accepted.
+   * @param definitionFn A function that is injected before the app runtime starts.
+   *        The result of this function should be a [[ParamTypeDefinition]].
+   *        The result is merged into the existing `definition`.
+   *        See [[ParamType]] for information on the values accepted.
+   *
+   * @returns if only the `name` parameter was specified: the currently registered [[ParamType]] object, or undefined
+   */
+  type(name, definition, definitionFn) {
+    const type = this.paramTypes.type(name, definition, definitionFn);
+    return !isDefined(definition) ? type : this;
+  }
+}