@player-ui/player 0.8.0--canary.307.9621 → 0.8.0-next.0

package/types/plugins/default-view-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { Player, PlayerPlugin } from "../player";
+/**
+ * A plugin that provides the out-of-the-box expressions for player
+ */
+export declare class DefaultViewPlugin implements PlayerPlugin {
+    name: string;
+    apply(player: Player): void;
+}
+//# sourceMappingURL=default-view-plugin.d.ts.map

package/types/plugins/flow-exp-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Player, PlayerPlugin } from "../player";
+/**
+ * A plugin that taps into the flow controller to evaluate available expressions
+ * Expressions can be exposed via lifecycle "hooks" in flow/state nodes
+ * e.g: onStart, onEnd
+ */
+export declare class FlowExpPlugin implements PlayerPlugin {
+    name: string;
+    apply(player: Player): void;
+}
+//# sourceMappingURL=flow-exp-plugin.d.ts.map

package/types/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./schema";
+//# sourceMappingURL=index.d.ts.map

package/types/schema/schema.d.ts

@@ -0,0 +1,36 @@
+import { SyncWaterfallHook } from "tapable-ts";
+import type { Schema as SchemaType, Formatting } from "@player-ui/types";
+import type { BindingInstance } from "../binding";
+import type { ValidationProvider, ValidationObject } from "../validator";
+import type { FormatDefinition, FormatOptions, FormatType } from "./types";
+/** Expand the authored schema into a set of paths -> DataTypes */
+export declare function parse(schema: SchemaType.Schema): Map<string, SchemaType.DataTypes>;
+/**
+ * The Schema is the central hub for all data invariants, and metaData associated with the data-model itself
+ * Outside of the types defined in the JSON payload, it doesn't manage or keep any state.
+ * It simply servers as an orchestrator for other modules to interface w/ the schema.
+ */
+export declare class SchemaController implements ValidationProvider {
+    private formatters;
+    private types;
+    readonly schema: Map<string, SchemaType.DataTypes>;
+    private bindingSchemaNormalizedCache;
+    readonly hooks: {
+        resolveTypeForBinding: SyncWaterfallHook<[SchemaType.DataTypes | undefined, BindingInstance], Record<string, any>>;
+    };
+    constructor(schema?: SchemaType.Schema);
+    addFormatters(fns: Array<FormatType<any, any, FormatOptions>>): void;
+    addDataTypes(types: Array<SchemaType.DataType<any>>): void;
+    getValidationsForBinding(binding: BindingInstance): Array<ValidationObject> | undefined;
+    private normalizeBinding;
+    getType(binding: BindingInstance): SchemaType.DataTypes | undefined;
+    getApparentType(binding: BindingInstance): SchemaType.DataTypes | undefined;
+    getTypeDefinition(dataType: string): SchemaType.DataType<any> | undefined;
+    getFormatterForType(formatReference: Formatting.Reference): FormatDefinition<unknown, unknown> | undefined;
+    /**
+     * Given a binding, fetch a function that's responsible for formatting, and/or de-formatting the data
+     * If no formatter is registered, it will return undefined
+     */
+    getFormatter(binding: BindingInstance): FormatDefinition<unknown, unknown> | undefined;
+}
+//# sourceMappingURL=schema.d.ts.map

package/types/schema/types.d.ts

@@ -0,0 +1,38 @@
+import type { Formatting } from "@player-ui/types";
+export type FormatOptions = Omit<Formatting.Reference, "type">;
+/**
+ * The return types for the schema don't include options.
+ * These are already sent to the generic formatter function for that type
+ */
+export type FormatFunction<From, To = From, Options = unknown> = (val: From, options?: Options) => To | undefined;
+export type FormatHandler<From, To = From> = (val: From) => To;
+export interface FormatDefinition<DataModelType, UserDisplayType> {
+    /**
+     * A function to format data (from the data-model to the user).
+     * Defaults to the identify function
+     */
+    format: FormatHandler<DataModelType, UserDisplayType>;
+    /**
+     * A function to invert the formatting (from the user to the data-model)
+     * Defaults to the identify function.
+     */
+    deformat: FormatHandler<UserDisplayType, DataModelType>;
+}
+export interface FormatType<DataModelType, UserDisplayType = DataModelType, Options = undefined> {
+    /**
+     * The name of the formatter.
+     * This corresponds to the 'type' format property when creating a DataType
+     */
+    name: string;
+    /**
+     * An optional function to format data for display to the user.
+     * This goes from dataModel -> UI display
+     */
+    format?: FormatFunction<DataModelType | UserDisplayType, UserDisplayType, Options>;
+    /**
+     * An optional function for undo the action of a format function for storage.
+     * This goes from UI -> dataModel
+     */
+    deformat?: FormatFunction<UserDisplayType | DataModelType, DataModelType, Options>;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/string-resolver/index.d.ts

@@ -0,0 +1,30 @@
+import type { Expression } from "@player-ui/types";
+import type { DataModelWithParser } from "../data";
+export interface Options {
+    /**
+     * The model to use when resolving refs
+     * Passing `false` will skip trying to resolve any direct model refs ({{foo}})
+     */
+    model: false | DataModelWithParser;
+    /**
+     * A function to evaluate an expression
+     * Passing `false` will skip trying to evaluate any expressions (@[ foo() ]@)
+     */
+    evaluate: false | ((exp: Expression) => any);
+    /**
+     * Optionaly resolve binding without formatting in case Type format applies
+     */
+    formatted?: boolean;
+}
+/** Search the given string for the coordinates of the next expression to resolve */
+export declare function findNextExp(str: string): {
+    start: number;
+    end: number;
+} | undefined;
+/** Finds any subset of the string wrapped in @[]@ and evaluates it as an expression */
+export declare function resolveExpressionsInString(val: string, { evaluate }: Options): string;
+/** Return a string with all data model references resolved */
+export declare function resolveDataRefsInString(val: string, options: Options): string;
+/** Recursively resolve all model refs in whatever you pass in */
+export declare function resolveDataRefs<T>(val: T, options: Options): T;
+//# sourceMappingURL=index.d.ts.map

package/types/types.d.ts

@@ -0,0 +1,73 @@
+import type { Flow, FlowResult } from "@player-ui/types";
+import type { BindingParser, BindingLike } from "./binding";
+import type { SchemaController } from "./schema";
+import type { ExpressionEvaluator } from "./expressions";
+import type { Logger } from "./logger";
+import type { ViewController, DataController, ValidationController, FlowController } from "./controllers";
+import type { ReadOnlyDataController } from "./controllers/data/utils";
+/** The status for a flow's execution state */
+export type PlayerFlowStatus = "not-started" | "in-progress" | "completed" | "error";
+/** Common interface for the state of Player's flow execution */
+export interface BaseFlowState<T extends PlayerFlowStatus> {
+    /** A unique reference for the life-cycle of a flow */
+    ref: symbol;
+    /** The status of the given flow */
+    status: T;
+}
+/** The beginning state of Player, before it's seen a flow  */
+export type NotStartedState = BaseFlowState<"not-started">;
+export declare const NOT_STARTED_STATE: NotStartedState;
+/** Shared properties for a flow in any state of execution (in-progress, completed successfully, or errored out) */
+export interface PlayerFlowExecutionData {
+    /** The currently executing flow */
+    flow: Flow;
+}
+export interface ControllerState {
+    /** The manager for data for a flow */
+    data: DataController;
+    /** The view manager for a flow */
+    view: ViewController;
+    /** The schema manager for a flow */
+    schema: SchemaController;
+    /** The validation manager for a flow */
+    validation: ValidationController;
+    /** The expression evaluator for a flow */
+    expression: ExpressionEvaluator;
+    /** The manager for parsing and resolving bindings */
+    binding: BindingParser;
+    /** the manager for the flow state machine */
+    flow: FlowController;
+}
+/** A flow is currently executing */
+export type InProgressState = BaseFlowState<"in-progress"> & PlayerFlowExecutionData & {
+    /** A promise that resolves when the flow is completed */
+    flowResult: Promise<FlowResult>;
+    /** The underlying state controllers for the current flow */
+    controllers: ControllerState;
+    /** Allow other platforms to abort the current flow with an error  */
+    fail: (error: Error) => void;
+    /**
+     * The Logger for the current player instance
+     */
+    logger: Logger;
+};
+/** The flow completed properly */
+export type CompletedState = BaseFlowState<"completed"> & PlayerFlowExecutionData & FlowResult & {
+    /** Readonly Player controllers to provide Player functionality after the flow has ended */
+    controllers: {
+        /** A read only instance of the Data Controller */
+        data: ReadOnlyDataController;
+    };
+};
+/** The flow finished but not successfully */
+export type ErrorState = BaseFlowState<"error"> & {
+    /** The currently executing flow */
+    flow: Flow;
+    /** The error associated with the failed flow */
+    error: Error;
+};
+/** Any Player state  */
+export type PlayerFlowState = NotStartedState | InProgressState | CompletedState | ErrorState;
+export type RawSetType = [BindingLike, any];
+export type RawSetTransaction = Record<string, any> | RawSetType[];
+//# sourceMappingURL=types.d.ts.map

package/types/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./replaceParams";
+//# sourceMappingURL=index.d.ts.map

package/types/utils/replaceParams.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Replaces %num in message with the provided parameters in order.
+ *
+ * @param message - Parameterized string like "This is a %1"
+ * @param params - Parameters to replace in message E.g. ['tax2021.amount']
+ * @returns A message with the parameters replaced.
+ */
+export declare function replaceParams(message: string, params: Record<string, any>): string;
+//# sourceMappingURL=replaceParams.d.ts.map

package/types/validator/binding-map-splice.d.ts

@@ -0,0 +1,10 @@
+import type { BindingInstance } from "../binding";
+/**
+ * Remove a binding, and any children from from the map
+ * If the binding is an array-item, then it will be spliced from the array and the others will be shifted down
+ *
+ * @param sourceMap - A map of bindings to values
+ * @param binding - The binding to remove from the map
+ */
+export declare function removeBindingAndChildrenFromMap<T>(sourceMap: Map<BindingInstance, T>, binding: BindingInstance): Map<BindingInstance, T>;
+//# sourceMappingURL=binding-map-splice.d.ts.map

package/types/validator/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./validation-middleware";
+export * from "./types";
+export * from "./registry";
+export * from "./binding-map-splice";
+//# sourceMappingURL=index.d.ts.map

package/types/validator/registry.d.ts

@@ -0,0 +1,11 @@
+import type { ValidatorFunction } from "./types";
+/** A registry that tracks validators  */
+export declare class ValidatorRegistry {
+    private registry;
+    constructor();
+    /** Use the given validator name to fetch the handler */
+    get(name: string): ValidatorFunction | undefined;
+    /** Register a new validator */
+    register<T>(name: string, handler: ValidatorFunction<T>): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/types/validator/types.d.ts

@@ -0,0 +1,53 @@
+import type { Schema, Validation } from "@player-ui/types";
+import type { BindingInstance, BindingFactory } from "../binding";
+import type { DataModelWithParser } from "../data";
+import type { ExpressionEvaluatorFunction } from "../expressions";
+import type { Logger } from "../logger";
+import type { ConstantsProvider } from "../controllers";
+interface BaseValidationResponse<T = Validation.Severity> {
+    /** The validation message to show to the user */
+    message: string;
+    /** List of parameters associated with a validation. These can be replaced into a templatized message string. */
+    parameters?: Record<string, any>;
+    /** How serious is this violation */
+    severity: T;
+    /** Where this validation should be displayed */
+    displayTarget?: Validation.DisplayTarget;
+    /** The blocking state of this validation */
+    blocking?: boolean | "once";
+}
+export interface WarningValidationResponse extends BaseValidationResponse<"warning"> {
+    /** Warning validations can be dismissed without correcting the error */
+    dismiss?: () => void;
+}
+export type ErrorValidationResponse = BaseValidationResponse<"error">;
+export type ValidationResponse = ErrorValidationResponse | WarningValidationResponse;
+type RequiredValidationKeys = "severity" | "trigger";
+export type ValidationObject = Validation.Reference & Required<Pick<Validation.Reference, RequiredValidationKeys>>;
+export type ValidationObjectWithHandler = ValidationObject & {
+    /** A predefined handler for this validation object */
+    handler?: ValidatorFunction;
+};
+export interface ValidationProvider {
+    getValidationsForBinding?(binding: BindingInstance): Array<ValidationObjectWithHandler> | undefined;
+    getValidationsForView?(): Array<ValidationObjectWithHandler> | undefined;
+}
+export interface ValidatorContext {
+    /** The data to set or get data from */
+    model: DataModelWithParser;
+    /** A means of parsing a binding */
+    parseBinding: BindingFactory;
+    /** Execute the expression and return it's result */
+    evaluate: ExpressionEvaluatorFunction;
+    /** Logger instance to use */
+    logger: Logger;
+    /** The validation object that triggered this function */
+    validation: ValidationObject;
+    /** The constants for messages */
+    constants: ConstantsProvider;
+    /** The type in the schema that triggered the validation if there is one */
+    schemaType: Schema.DataType | undefined;
+}
+export type ValidatorFunction<Options = unknown> = (context: ValidatorContext, value: any, options?: Options) => Omit<BaseValidationResponse, "severity"> | undefined;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/types/validator/validation-middleware.d.ts

@@ -0,0 +1,36 @@
+import type { BindingInstance } from "../binding";
+import type { BatchSetTransaction, DataModelImpl, DataModelOptions, DataModelMiddleware, Updates } from "../data";
+import type { Logger } from "../logger";
+import type { ValidationResponse } from "./types";
+/**
+ * A BindingInstance with an indicator of whether or not it's a strong binding
+ */
+export type StrongOrWeakBinding = {
+    /** BindingInstance in question */
+    binding: BindingInstance;
+    /** Boolean indicating whether the relevant BindingInstance is a strong binding */
+    isStrong: boolean;
+};
+/**
+ * Returns a validation object if the data is invalid or an set of BindingsInstances if the binding itself is a weak ref of another invalid validation
+ */
+export type MiddlewareChecker = (binding: BindingInstance, model: DataModelImpl) => ValidationResponse | Set<StrongOrWeakBinding> | undefined;
+/**
+ * Middleware for the data-model that caches the results of invalid data
+ */
+export declare class ValidationMiddleware implements DataModelMiddleware {
+    validator: MiddlewareChecker;
+    shadowModelPaths: Map<BindingInstance, any>;
+    private logger?;
+    private shouldIncludeInvalid?;
+    constructor(validator: MiddlewareChecker, options?: {
+        /** A logger instance */
+        logger?: Logger;
+        /** Optional function to include data staged in shadowModel */
+        shouldIncludeInvalid?: (options?: DataModelOptions) => boolean;
+    });
+    set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): any;
+    delete(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): void | undefined;
+}
+//# sourceMappingURL=validation-middleware.d.ts.map

package/types/view/builder/index.d.ts

@@ -0,0 +1,35 @@
+import type { Node, AnyAssetType } from "../parser";
+import { NodeType } from "../parser";
+/**
+ * Functions for building AST nodes (relatively) easily
+ */
+export declare class Builder {
+    /**
+     * Creates an asset node
+     *
+     * @param value - the value to put in the asset node
+     */
+    static asset<T extends AnyAssetType>(value: T): Node.Asset<T>;
+    /**
+     * Creates a value node
+     *
+     * @param v - The object to put in the value node
+     */
+    static value(v?: object): Node.Value;
+    /**
+     * Creates a multiNode and associates the multiNode as the parent
+     * of all the value nodes
+     *
+     * @param values - the value or applicability nodes to put in the multinode
+     */
+    static multiNode(...values: (Node.Value | Node.Applicability)[]): Node.MultiNode;
+    /**
+     * Adds a child node to a node
+     *
+     * @param node - The node to add a child to
+     * @param path - The path at which to add the child
+     * @param child - The child node
+     */
+    static addChild<N extends Node.BaseWithChildren<NT>, NT extends NodeType>(node: N, path: Node.PathSegment | Node.PathSegment[], child: Node.Node): N;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/view/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./view";
+export * from "./resolver";
+export * from "./parser";
+export * from "./builder";
+export * from "./plugins";
+//# sourceMappingURL=index.d.ts.map

package/types/view/parser/index.d.ts

@@ -0,0 +1,52 @@
+import { SyncBailHook, SyncWaterfallHook } from "tapable-ts";
+import type { AnyAssetType, Node } from "./types";
+import { NodeType } from "./types";
+export * from "./types";
+export * from "./utils";
+export declare const EMPTY_NODE: Node.Empty;
+export interface ParseObjectOptions {
+    /** how nested the templated is */
+    templateDepth?: number;
+}
+/**
+ * The Parser is the way to take an incoming view from the user and parse it into an AST.
+ * It provides a few ways to interact with the parsing, including mutating an object before and after creation of an AST node
+ */
+export declare class Parser {
+    readonly hooks: {
+        /**
+         * A hook to interact with an object _before_ parsing it into an AST
+         *
+         * @param value - The object we're are about to parse
+         * @returns - A new value to parse.
+         *  If undefined, the original value is used.
+         *  If null, we stop parsing this node.
+         */
+        onParseObject: SyncWaterfallHook<[object, NodeType], Record<string, any>>;
+        /**
+         * A callback to interact with an AST _after_ we parse it into the AST
+         *
+         * @param value - The object we parsed
+         * @param node - The AST node we generated
+         * @returns - A new AST node to use
+         *   If undefined, the original value is used.
+         *   If null, we ignore this node all together
+         */
+        onCreateASTNode: SyncWaterfallHook<[Node.Node | null | undefined, object], Record<string, any>>;
+        determineNodeType: SyncBailHook<[string | object], NodeType, Record<string, any>>;
+        parseNode: SyncBailHook<[obj: object, nodeType: Node.ChildrenTypes, parseOptions: ParseObjectOptions, determinedNodeType: NodeType | null], Node.Node, Record<string, any>>;
+    };
+    parseView(value: AnyAssetType): Node.View;
+    private parseAsync;
+    createASTNode(node: Node.Node | null, value: any): Node.Node | null;
+    /**
+     * Checks if there are templated values in the object
+     *
+     * @param obj - The Parsed Object to check to see if we have a template array type for
+     * @param localKey - The key being checked
+     */
+    private hasTemplateValues;
+    private hasSwitchKey;
+    parseObject(obj: object, type?: Node.ChildrenTypes, options?: ParseObjectOptions): Node.Node | null;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/view/parser/types.d.ts

@@ -0,0 +1,109 @@
+import type { Asset as AssetType, Expression, Binding } from "@player-ui/types";
+export type AnyAssetType = AssetType<string>;
+export declare enum NodeType {
+    Asset = "asset",
+    View = "view",
+    Applicability = "applicability",
+    Template = "template",
+    Value = "value",
+    MultiNode = "multi-node",
+    Switch = "switch",
+    Async = "async",
+    Unknown = "unknown",
+    Empty = "empty"
+}
+export declare namespace Node {
+    type ChildrenTypes = NodeType.Asset | NodeType.Value | NodeType.View;
+    interface Base<T extends NodeType> {
+        /** Every node contains a type to distinguish it from other nodes */
+        type: T;
+        /** Every node (outside of the root) contains a reference to it's parent */
+        parent?: Node;
+    }
+    type PathSegment = string | number;
+    interface Child {
+        /** The path of the child relative to the parent */
+        path: PathSegment[];
+        /** If true, the path points to an array, and the value will be appended to it result */
+        array?: boolean;
+        /** The child node */
+        value: Node;
+    }
+    interface BaseWithChildren<T extends NodeType> extends Base<T> {
+        /** Any node that contains a list of children underneath it */
+        children?: Child[];
+    }
+    interface Asset<T extends AnyAssetType = AnyAssetType> extends BaseWithChildren<NodeType.Asset>, PluginOptions {
+        /** Any asset nested within a view */
+        value: T;
+    }
+    interface View<T extends AnyAssetType = AnyAssetType> extends BaseWithChildren<NodeType.View>, PluginOptions {
+        /** The root of the parsed view */
+        value: T;
+    }
+    interface Applicability extends Base<NodeType.Applicability> {
+        /** The expression to execute that determines applicability of the target node */
+        expression: Expression;
+        /** The node to use if the expression is truthy */
+        value: Node;
+    }
+    interface Template extends Base<NodeType.Template> {
+        /** The location of an array in the model */
+        data: Binding;
+        /** The template to use when mapping over the data */
+        template: unknown;
+        /** The number of nested templates so far */
+        depth: number;
+        /** should the template recomputed when data changes */
+        dynamic?: boolean;
+    }
+    interface Value extends BaseWithChildren<NodeType.Value>, PluginOptions {
+        /** A simple node representing a value */
+        value: any;
+    }
+    interface MultiNode extends Base<NodeType.MultiNode> {
+        /**
+         * Should this list override the target node if they overlap?
+         * If not amend the existing list
+         */
+        override?: boolean;
+        /** A list of values that comprise this node */
+        values: Array<Node>;
+    }
+    interface Switch extends Base<NodeType.Switch> {
+        /** Should this list be re-computed when data changes */
+        dynamic?: boolean;
+        /** A list of cases to evaluate in order */
+        cases: SwitchCase[];
+    }
+    interface SwitchCase {
+        /** The expression to evaluate for a single case statement */
+        case: Expression | true;
+        /** The value to use if this case is true */
+        value: Value;
+    }
+    interface Async extends Base<NodeType.Async> {
+        /** The unique id of the node */
+        id: string;
+        /** The value representing the node */
+        value: Node;
+    }
+    interface PluginOptions {
+        /** A list of plugins */
+        plugins?: {
+            /** StringResolverPlugin options */
+            stringResolver?: {
+                /**
+                 * An optional array of node properties to skip during string resolution
+                 * Specified in the AssetTransformPlugin
+                 */
+                propertiesToSkip?: string[];
+            };
+        };
+    }
+    type Unknown = Base<NodeType.Unknown>;
+    type Empty = Base<NodeType.Empty>;
+    type ViewOrAsset = View | Asset;
+    type Node = Asset | Applicability | Template | Value | View | MultiNode | Switch | Async | Unknown | Empty;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/view/parser/utils.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from "./types";
+/** Check to see if the object contains async */
+export declare function hasAsync(obj: object): boolean;
+/** Get the ID of the Node if there is one */
+export declare function getNodeID(node?: Node.Node | null): string | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/types/view/plugins/applicability.d.ts

@@ -0,0 +1,10 @@
+import type { Resolver } from "../resolver";
+import type { Parser } from "../parser";
+import { ViewInstance, ViewPlugin } from "../view";
+/** A view plugin to remove inapplicable assets from the tree */
+export default class ApplicabilityPlugin implements ViewPlugin {
+    applyResolver(resolver: Resolver): void;
+    applyParser(parser: Parser): void;
+    apply(view: ViewInstance): void;
+}
+//# sourceMappingURL=applicability.d.ts.map

package/types/view/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { default as TemplatePlugin } from "./template-plugin";
+export { default as StringResolverPlugin } from "./string-resolver";
+export { default as ApplicabilityPlugin } from "./applicability";
+export { default as SwitchPlugin } from "./switch";
+//# sourceMappingURL=index.d.ts.map

package/types/view/plugins/options.d.ts

@@ -0,0 +1,4 @@
+import type { Resolve } from "../resolver";
+/** Config options that are required to resolve/update a view */
+export type Options = Resolve.NodeResolveOptions;
+//# sourceMappingURL=options.d.ts.map

package/types/view/plugins/string-resolver.d.ts

@@ -0,0 +1,13 @@
+import type { Options } from "./options";
+import type { Resolver } from "../resolver";
+import { ViewInstance, ViewPlugin } from "../view";
+/** Recursively resolve all string references in an object or array */
+export declare function resolveAllRefs(node: any, resolveOptions: Options, propertiesToSkip: Set<string | number>): any;
+/** A plugin that resolves all string references for each node */
+export default class StringResolverPlugin implements ViewPlugin {
+    private propertiesToSkipCache;
+    constructor();
+    applyResolver(resolver: Resolver): void;
+    apply(view: ViewInstance): void;
+}
+//# sourceMappingURL=string-resolver.d.ts.map

package/types/view/plugins/switch.d.ts

@@ -0,0 +1,14 @@
+import type { Options } from "./options";
+import type { Parser } from "../parser";
+import type { Resolver } from "../resolver";
+import { ViewInstance, ViewPlugin } from "../view";
+/** A view plugin to resolve switches */
+export default class SwitchPlugin implements ViewPlugin {
+    private readonly options;
+    constructor(options: Options);
+    private resolveSwitch;
+    applyParser(parser: Parser): void;
+    applyResolver(resolver: Resolver): void;
+    apply(view: ViewInstance): void;
+}
+//# sourceMappingURL=switch.d.ts.map

package/types/view/plugins/template-plugin.d.ts

@@ -0,0 +1,33 @@
+import { SyncWaterfallHook } from "tapable-ts";
+import type { Parser } from "../parser";
+import type { Options } from "./options";
+import type { Resolver } from "../resolver";
+import { ViewInstance, ViewPlugin } from "../view";
+export interface TemplateItemInfo {
+    /** The index of the data for the current iteration of the template */
+    index: number;
+    /** The data for the current iteration of the template */
+    data: any;
+    /** The depth of the template node */
+    depth: number;
+}
+export interface TemplateSubstitution {
+    /** Regular expression to find and replace. The global flag will be always be added to this expression. */
+    expression: string | RegExp;
+    /** The value to replace matches with. */
+    value: string;
+}
+export type TemplateSubstitutionsFunc = (baseSubstitutions: TemplateSubstitution[], templateItemInfo: TemplateItemInfo) => TemplateSubstitution[];
+/** A view plugin to resolve/manage templates */
+export default class TemplatePlugin implements ViewPlugin {
+    private readonly options;
+    hooks: {
+        resolveTemplateSubstitutions: SyncWaterfallHook<[TemplateSubstitution[], TemplateItemInfo], Record<string, any>>;
+    };
+    constructor(options: Options);
+    private parseTemplate;
+    applyParser(parser: Parser): void;
+    applyResolverHooks(resolver: Resolver): void;
+    apply(view: ViewInstance): void;
+}
+//# sourceMappingURL=template-plugin.d.ts.map