| 1 | import { Predicate } from '../common/common';
|
| 2 | import { TreeChanges } from '../transition/interface';
|
| 3 | import { StateObject } from '../state/stateObject';
|
| 4 | import { TargetState } from '../state/targetState';
|
| 5 | import { GetParamsFn, PathNode } from './pathNode';
|
| 6 | import { ViewService } from '../view/view';
|
| 7 | import { Param } from '../params/param';
|
| 8 | import { StateRegistry } from '../state';
|
| 9 | /**
|
| 10 | * This class contains functions which convert TargetStates, Nodes and paths from one type to another.
|
| 11 | */
|
| 12 | export declare class PathUtils {
|
| 13 | /** Given a PathNode[], create an TargetState */
|
| 14 | static makeTargetState(registry: StateRegistry, path: PathNode[]): TargetState;
|
| 15 | static buildPath(targetState: TargetState): PathNode[];
|
| 16 | /** Given a fromPath: PathNode[] and a TargetState, builds a toPath: PathNode[] */
|
| 17 | static buildToPath(fromPath: PathNode[], targetState: TargetState): PathNode[];
|
| 18 | /**
|
| 19 | * Creates ViewConfig objects and adds to nodes.
|
| 20 | *
|
| 21 | * On each [[PathNode]], creates ViewConfig objects from the views: property of the node's state
|
| 22 | */
|
| 23 | static applyViewConfigs($view: ViewService, path: PathNode[], states: StateObject[]): void;
|
| 24 | /**
|
| 25 | * Given a fromPath and a toPath, returns a new to path which inherits parameters from the fromPath
|
| 26 | *
|
| 27 | * For a parameter in a node to be inherited from the from path:
|
| 28 | * - The toPath's node must have a matching node in the fromPath (by state).
|
| 29 | * - The parameter name must not be found in the toKeys parameter array.
|
| 30 | *
|
| 31 | * Note: the keys provided in toKeys are intended to be those param keys explicitly specified by some
|
| 32 | * caller, for instance, $state.transitionTo(..., toParams). If a key was found in toParams,
|
| 33 | * it is not inherited from the fromPath.
|
| 34 | */
|
| 35 | static inheritParams(fromPath: PathNode[], toPath: PathNode[], toKeys?: string[]): PathNode[];
|
| 36 | static nonDynamicParams: (node: PathNode) => Param[];
|
| 37 | /**
|
| 38 | * Computes the tree changes (entering, exiting) between a fromPath and toPath.
|
| 39 | */
|
| 40 | static treeChanges(fromPath: PathNode[], toPath: PathNode[], reloadState: StateObject): TreeChanges;
|
| 41 | /**
|
| 42 | * Returns a new path which is: the subpath of the first path which matches the second path.
|
| 43 | *
|
| 44 | * The new path starts from root and contains any nodes that match the nodes in the second path.
|
| 45 | * It stops before the first non-matching node.
|
| 46 | *
|
| 47 | * Nodes are compared using their state property and their parameter values.
|
| 48 | * If a `paramsFn` is provided, only the [[Param]] returned by the function will be considered when comparing nodes.
|
| 49 | *
|
| 50 | * @param pathA the first path
|
| 51 | * @param pathB the second path
|
| 52 | * @param paramsFn a function which returns the parameters to consider when comparing
|
| 53 | *
|
| 54 | * @returns an array of PathNodes from the first path which match the nodes in the second path
|
| 55 | */
|
| 56 | static matching(pathA: PathNode[], pathB: PathNode[], paramsFn?: GetParamsFn): PathNode[];
|
| 57 | /**
|
| 58 | * Returns true if two paths are identical.
|
| 59 | *
|
| 60 | * @param pathA
|
| 61 | * @param pathB
|
| 62 | * @param paramsFn a function which returns the parameters to consider when comparing
|
| 63 | * @returns true if the the states and parameter values for both paths are identical
|
| 64 | */
|
| 65 | static equals(pathA: PathNode[], pathB: PathNode[], paramsFn?: GetParamsFn): boolean;
|
| 66 | /**
|
| 67 | * Return a subpath of a path, which stops at the first matching node
|
| 68 | *
|
| 69 | * Given an array of nodes, returns a subset of the array starting from the first node,
|
| 70 | * stopping when the first node matches the predicate.
|
| 71 | *
|
| 72 | * @param path a path of [[PathNode]]s
|
| 73 | * @param predicate a [[Predicate]] fn that matches [[PathNode]]s
|
| 74 | * @returns a subpath up to the matching node, or undefined if no match is found
|
| 75 | */
|
| 76 | static subPath(path: PathNode[], predicate: Predicate<PathNode>): PathNode[];
|
| 77 | /** Gets the raw parameter values from a path */
|
| 78 | static paramValues: (path: PathNode[]) => any;
|
| 79 | }
|