@angular-wave/angular.ts 0.9.1 → 0.9.3

package/@types/router/template-factory.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @typedef BindingTuple
+ * @property {string} name
+ * @property {string} type
+ */
+/**
+ * Service which manages loading of templates from a ViewConfig.
+ */
+export class TemplateFactoryProvider {
+  /** @type {boolean} */
+  _useHttp: boolean;
+  $get: (
+    | string
+    | ((
+        $http: any,
+        $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
+        $templateRequest: any,
+        $injector: import("../core/di/internal-injector.js").InjectorService,
+      ) => this)
+  )[];
+  $templateRequest: any;
+  $http: any;
+  $templateCache: import("../interface.ts").TemplateCache;
+  $injector: import("../core/di/internal-injector.js").InjectorService;
+  /**
+   * Forces the provider to use $http service directly
+   * @param {boolean} value
+   */
+  useHttpService(value: boolean): void;
+  /**
+   * Creates a template from a configuration object.
+   *
+   * @param config Configuration object for which to load a template.
+   * The following properties are search in the specified order, and the first one
+   * that is defined is used to create the template:
+   *
+   * @param {any} config
+   * @param {any} params  Parameters to pass to the template function.
+   * @param {import("./resolve/resolve-context.js").ResolveContext} context The resolve context associated with the template's view
+   *
+   * @return {string|object}  The template html as a string, or a promise for
+   * that string,or `null` if no template is configured.
+   */
+  fromConfig(
+    config: any,
+    params: any,
+    context: import("./resolve/resolve-context.js").ResolveContext,
+  ): string | object;
+  /**
+   * Creates a template from a string or a function returning a string.
+   *
+   * @param {string | Function} template html template as a string or function that returns an html template as a string.
+   * @param {any} [params] Parameters to pass to the template function.
+   *
+   * @return {string|object} The template html as a string, or a promise for that
+   * string.
+   */
+  fromString(template: string | Function, params?: any): string | object;
+  /**
+   * Loads a template from the a URL via `$http` and `$templateCache`.
+   *
+   * @param {string|Function} url url of the template to load, or a function
+   * that returns a url.
+   * @param {Object} params Parameters to pass to the url function.
+   * @return {string|Promise.<string>} The template html as a string, or a promise
+   * for that string.
+   */
+  fromUrl(url: string | Function, params: any): string | Promise<string>;
+  /**
+   * Creates a template by invoking an injectable provider function.
+   *
+   * @param {import('../interface.ts').Injectable} provider Function to invoke via `locals`
+   * @param {Function} params a function used to invoke the template provider
+   * @param {import("./resolve/resolve-context.js").ResolveContext} context
+   * @return {string|Promise.<string>} The template html as a string, or a promise
+   * for that string.
+   */
+  fromProvider(
+    provider: import("../interface.ts").Injectable,
+    params: Function,
+    context: import("./resolve/resolve-context.js").ResolveContext,
+  ): string | Promise<string>;
+  /**
+   * Creates a component's template by invoking an injectable provider function.
+   *
+   * @param {import('../interface.ts').Injectable} provider Function to invoke via `locals`
+   * @return {Promise<any>} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
+   */
+  fromComponentProvider(
+    provider: import("../interface.ts").Injectable,
+    context: any,
+  ): Promise<any>;
+  /**
+   * Creates a template from a component's name
+   *
+   * This implements route-to-component.
+   * It works by retrieving the component (directive) metadata from the injector.
+   * It analyses the component's bindings, then constructs a template that instantiates the component.
+   * The template wires input and output bindings to resolves or from the parent component.
+   *
+   * @param {any} ngView {object} The parent ng-view (for binding outputs to callbacks)
+   * @param {import("./resolve/resolve-context.js").ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
+   * @param {string} component {string} Component's name in camel case.
+   * @param {any} [bindings] An object defining the component's bindings: {foo: '<'}
+   * @return {string} The template as a string: "<component-name input1='$resolve.foo'></component-name>".
+   */
+  makeComponentTemplate(
+    ngView: any,
+    context: import("./resolve/resolve-context.js").ResolveContext,
+    component: string,
+    bindings?: any,
+  ): string;
+}
+export type BindingTuple = {
+  name: string;
+  type: string;
+};

package/@types/router/transition/hook-builder.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This class returns applicable TransitionHooks for a specific Transition instance.
+ *
+ * Hooks ([[RegisteredHook]]) may be registered globally, e.g., $transitions.onEnter(...), or locally, e.g.
+ * myTransition.onEnter(...).  The HookBuilder finds matching RegisteredHooks (where the match criteria is
+ * determined by the type of hook)
+ *
+ * The HookBuilder also converts RegisteredHooks objects to TransitionHook objects, which are used to run a Transition.
+ *
+ * The HookBuilder constructor is given the $transitions service and a Transition instance.  Thus, a HookBuilder
+ * instance may only be used for one specific Transition object. (side note: the _treeChanges accessor is private
+ * in the Transition class, so we must also provide the Transition's _treeChanges)
+ */
+export class HookBuilder {
+  constructor(transition: any);
+  transition: any;
+  /**
+   * @param {TransitionHookPhase} phase
+   * @returns
+   */
+  buildHooksForPhase(phase: TransitionHookPhase): any;
+  /**
+   * Returns an array of newly built TransitionHook objects.
+   *
+   * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].
+   * - Finds [[PathNode]] (or `PathNode[]`) to use as the TransitionHook context(s)
+   * - For each of the [[PathNode]]s, creates a TransitionHook
+   *
+   * @param hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.
+   */
+  buildHooks(hookType: any): any;
+  /**
+   * Finds all RegisteredHooks from:
+   * - The Transition object instance hook registry
+   * - The TransitionService ($transitions) global hook registry
+   *
+   * which matched:
+   * - the eventType
+   * - the matchCriteria (to, from, exiting, retained, entering)
+   *
+   * @returns an array of matched [[RegisteredHook]]s
+   */
+  getMatchingHooks(hookType: any, treeChanges: any, transition: any): any;
+}
+import { TransitionHookPhase } from "./interface.js";

package/@types/router/transition/hook-registry.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Determines if the given state matches the matchCriteria
+ *
+ * @internal
+ *
+ * @param state a State Object to test against
+ * @param criterion
+ * - If a string, matchState uses the string as a glob-matcher against the state name
+ * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name
+ *   and returns a positive match if any of the globs match.
+ * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.
+ * @returns {boolean}
+ */
+export function matchState(
+  state: any,
+  criterion: any,
+  transition: any,
+): boolean;
+/** Return a registration function of the requested type. */
+export function makeEvent(
+  registry: any,
+  transitionService: any,
+  eventType: any,
+): (matchObject: any, callback: any, options?: {}) => any;
+/**
+ * The registration data for a registered transition hook
+ */
+export class RegisteredHook {
+  constructor(
+    tranSvc: any,
+    eventType: any,
+    callback: any,
+    matchCriteria: any,
+    removeHookFromRegistry: any,
+    options?: {},
+  );
+  tranSvc: any;
+  eventType: any;
+  callback: any;
+  matchCriteria: any;
+  removeHookFromRegistry: any;
+  invokeCount: number;
+  _deregistered: boolean;
+  priority: any;
+  bind: any;
+  invokeLimit: any;
+  /**
+   * Gets the matching [[PathNode]]s
+   *
+   * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing
+   * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.
+   *
+   * Returning `null` is significant to distinguish between the default
+   * "match-all criterion value" of `true` compared to a `() => true` function,
+   * when the nodes is an empty array.
+   *
+   * This is useful to allow a transition match criteria of `entering: true`
+   * to still match a transition, even when `entering === []`.  Contrast that
+   * with `entering: (state) => true` which only matches when a state is actually
+   * being entered.
+   */
+  _matchingNodes(nodes: any, criterion: any, transition: any): any;
+  /**
+   * Gets the default match criteria (all `true`)
+   *
+   * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:
+   *
+   * ```js
+   * {
+   *   to: true,
+   *   from: true,
+   *   entering: true,
+   *   exiting: true,
+   *   retained: true,
+   * }
+   */
+  _getDefaultMatchCriteria(): any;
+  /**
+   * Gets matching nodes as [[IMatchingNodes]]
+   *
+   * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:
+   *
+   * ```js
+   * let matches: IMatchingNodes = {
+   *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),
+   *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),
+   *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),
+   *   retained: _matchingNodes(treeChanges.retained,     mc.retained),
+   *   entering: _matchingNodes(treeChanges.entering,     mc.entering),
+   * };
+   * ```
+   */
+  _getMatchingNodes(treeChanges: any, transition: any): any;
+  /**
+   * Determines if this hook's [[matchCriteria]] match the given [[TreeChanges]]
+   *
+   * @returns an IMatchingNodes object, or null. If an IMatchingNodes object is returned, its values
+   * are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)
+   */
+  matches(treeChanges: any, transition: any): any;
+  deregister(): void;
+}