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

package/types/binding-grammar/ast.d.ts

@@ -0,0 +1,67 @@
+export interface Node<T extends string> {
+    /** The basic node type */
+    name: T;
+}
+/**
+ * An AST node that represents a nested path in the model
+ * foo.{{bar}}.baz (this is {{bar}})
+ */
+export interface PathNode extends Node<"PathNode"> {
+    /** The path in the model that this node represents */
+    path: Array<AnyNode>;
+}
+/**
+ * A segment representing a query
+ * [foo=bar]
+ */
+export interface QueryNode extends Node<"Query"> {
+    /** The key to query */
+    key: AnyNode;
+    /** The target value */
+    value?: AnyNode;
+}
+/** A simple segment */
+export interface ValueNode extends Node<"Value"> {
+    /** The segment value */
+    value: string | number;
+}
+/** A nested expression */
+export interface ExpressionNode extends Node<"Expression"> {
+    /** The expression */
+    value: string;
+}
+/** Helper to create a value node */
+export declare const toValue: (value: string | number) => ValueNode;
+/** Helper to create an expression node */
+export declare const toExpression: (value: string) => ExpressionNode;
+/** Helper to create a nested path node */
+export declare const toPath: (path: Array<AnyNode>) => PathNode;
+/** Helper to create a query node */
+export declare const toQuery: (key: AnyNode, value?: AnyNode) => QueryNode;
+/** Create a concat node */
+export declare const toConcatenatedNode: (values: Array<PathNode | ValueNode | ExpressionNode>) => PathNode | ValueNode | ConcatenatedNode | ExpressionNode;
+/**
+ * A binding segment that's multiple smaller ones
+ * {{foo}}_bar_{{baz}}
+ */
+export interface ConcatenatedNode extends Node<"Concatenated"> {
+    /** A list of nested paths, or value nodes to concat together to form a segment */
+    value: Array<PathNode | ValueNode | ExpressionNode>;
+}
+export type AnyNode = PathNode | QueryNode | ValueNode | ConcatenatedNode | ExpressionNode;
+export type Path = Array<AnyNode>;
+export interface ParserSuccessResult {
+    /** A successful parse result */
+    status: true;
+    /** The path the binding represents */
+    path: PathNode;
+}
+export interface ParserFailureResult {
+    /** A failed parse result */
+    status: false;
+    /** The message representing the reason the parse result failed */
+    error: string;
+}
+export type ParserResult = ParserSuccessResult | ParserFailureResult;
+export type Parser = (raw: string) => ParserResult;
+//# sourceMappingURL=ast.d.ts.map

package/types/binding-grammar/custom/index.d.ts

@@ -0,0 +1,4 @@
+import type { Parser } from "../ast";
+/** Parse out a binding AST from a path */
+export declare const parse: Parser;
+//# sourceMappingURL=index.d.ts.map

package/types/binding-grammar/ebnf/index.d.ts

@@ -0,0 +1,4 @@
+import type { Parser } from "../ast";
+/** Parse a binding using ebnf */
+export declare const parse: Parser;
+//# sourceMappingURL=index.d.ts.map

package/types/binding-grammar/ebnf/types.d.ts

@@ -0,0 +1,75 @@
+import type { IToken } from "ebnf";
+export interface ValueToken extends IToken {
+    /** A value type  */
+    type: "value";
+    /** Any children of the value */
+    children: Array<SegmentAndBracketToken>;
+}
+export interface SegmentAndBracketToken extends IToken {
+    /** A token for a segment + brackets */
+    type: "segment_and_bracket";
+    /** The segment + brackets */
+    children: [SegmentToken, ...Array<BracketToken>];
+}
+export interface SegmentToken extends IToken {
+    /** A segment token */
+    type: "segment";
+    /** Any children of the token */
+    children: [ConcatenatedToken | IdentifierToken];
+}
+export interface BracketToken extends IToken {
+    /** A bracket token */
+    type: "bracket";
+    /** Any children of the token */
+    children: [OptionallyQuotedSegment | QueryToken];
+}
+export interface ExpressionValueToken extends IToken {
+    /** Expression value token */
+    type: "expression_value";
+    /** No children here */
+    children: [];
+}
+export interface ExpressionToken extends IToken {
+    /** Expression token */
+    type: "expression";
+    /** Children is the expression value */
+    children: [ExpressionValueToken];
+}
+export interface QuotedValueToken extends IToken {
+    /** A quoted value */
+    type: "quoted_value";
+    /** Any children of the token */
+    children: [];
+}
+export interface IdentifierToken extends IToken {
+    /** Any identifier */
+    type: "identifier";
+    /** Any children of the token */
+    children: [];
+}
+export interface ConcatenatedToken extends IToken {
+    /** A node of more than 1 identifier */
+    type: "concatenated";
+    /** Any children of the token */
+    children: Array<IdentifierToken | ModelRefToken | ExpressionToken>;
+}
+export interface ModelRefToken extends IToken {
+    /** A nested model reference */
+    type: "modelRef";
+    /** Any children of the token */
+    children: [ValueToken];
+}
+export interface OptionallyQuotedSegment extends IToken {
+    /** Any optionally quoted segment */
+    type: "optionally_quoted_segment";
+    /** Any children of the token */
+    children: [QuotedValueToken | SegmentToken];
+}
+export interface QueryToken extends IToken {
+    /** A query */
+    type: "query";
+    /** Any children of the token */
+    children: [OptionallyQuotedSegment, OptionallyQuotedSegment];
+}
+export type Token = ValueToken | QueryToken | QuotedValueToken | OptionallyQuotedSegment | SegmentAndBracketToken | SegmentToken | BracketToken | IdentifierToken | ConcatenatedToken | ModelRefToken | ExpressionValueToken | ExpressionToken;
+//# sourceMappingURL=types.d.ts.map

package/types/binding-grammar/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ast";
+export { parse as parseParsimmon } from "./parsimmon";
+export { parse as parseEBNF } from "./ebnf";
+export { parse as parseCustom } from "./custom";
+//# sourceMappingURL=index.d.ts.map

package/types/binding-grammar/parsimmon/index.d.ts

@@ -0,0 +1,4 @@
+import type { Parser as BindingParser } from "../ast";
+/** Parse a binding using parsimmon */
+export declare const parse: BindingParser;
+//# sourceMappingURL=index.d.ts.map

package/types/controllers/constants/index.d.ts

@@ -0,0 +1,45 @@
+export interface ConstantsProvider {
+    /**
+     * Function to add constants to the providers store
+     * - @param data values to add to the constants store
+     */
+    addConstants(data: Record<string, any>, namespace: string): void;
+    /**
+     * Function to retrieve constants from the providers store
+     *  - @param key Key used for the store access
+     *  - @param namespace namespace values were loaded under (defined in the plugin)
+     *  - @param fallback Optional - if key doesn't exist in namespace what to return (will return unknown if not provided)
+     */
+    getConstants(key: any, namespace: string, fallback?: any): any;
+    /**
+     * Function to set values to temporarily override certain keys in the perminant store
+     * - @param data values to override store with
+     * - @param namespace namespace to override
+     */
+    setTemporaryValues(data: any, namespace: string): void;
+    /**
+     * Clears any temporary values that were previously set
+     */
+    clearTemporaryValues(): void;
+}
+/**
+ * Key/Value store for constants and context for Player
+ */
+export declare class ConstantsController implements ConstantsProvider {
+    /**
+     * Data store is basically a map of namespaces to DataModels to provide some data isolation
+     */
+    private store;
+    /**
+     * Separate store for temporary flow specific overrides.
+     * They are kept in a separate data model to make clearing it easier between flows
+     * and so there is no confusion on what is static and what is temporary
+     */
+    private tempStore;
+    constructor();
+    addConstants(data: any, namespace: string): void;
+    getConstants(key: string, namespace: string, fallback?: any): any;
+    setTemporaryValues(data: any, namespace: string): void;
+    clearTemporaryValues(namespace?: string): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/controllers/constants/utils.d.ts

@@ -0,0 +1,6 @@
+import { BindingInstance } from "../../binding";
+/** Recursively flattens a nested object to be an object of depth 1 with keys being the full path in the orginal object */
+export declare function flatten(obj: any, roots?: [string][], sep?: string): any;
+/** Converts an object into a list of binding/value tuples to use with a LocalModel object */
+export declare function objectToBatchSet(obj: any): [BindingInstance, any][];
+//# sourceMappingURL=utils.d.ts.map

package/types/controllers/data/controller.d.ts

@@ -0,0 +1,45 @@
+import { SyncHook, SyncWaterfallHook, SyncBailHook } from "tapable-ts";
+import type { Logger } from "../../logger";
+import type { BindingParser, BindingLike } from "../../binding";
+import { BindingInstance } from "../../binding";
+import type { BatchSetTransaction, Updates, DataModelOptions, DataModelWithParser, DataPipeline, DataModelMiddleware } from "../../data";
+import { PipelinedDataModel } from "../../data";
+import type { RawSetTransaction } from "../../types";
+import { ReadOnlyDataController } from "./utils";
+/** The orchestrator for player data */
+export declare class DataController implements DataModelWithParser<DataModelOptions> {
+    hooks: {
+        resolve: SyncWaterfallHook<any[], Record<string, any>>;
+        resolveDataStages: SyncWaterfallHook<[DataPipeline], Record<string, any>>;
+        resolveDefaultValue: SyncBailHook<[BindingInstance], any, Record<string, any>>;
+        onDelete: SyncHook<[any], Record<string, any>>;
+        onSet: SyncHook<[BatchSetTransaction], Record<string, any>>;
+        onGet: SyncHook<[any, any], Record<string, any>>;
+        onUpdate: SyncHook<[Updates, DataModelOptions | undefined], Record<string, any>>;
+        format: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
+        deformat: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
+        serialize: SyncWaterfallHook<[any], Record<string, any>>;
+    };
+    private model?;
+    private trash;
+    private pathResolver;
+    private baseMiddleware;
+    private logger?;
+    constructor(model: Record<any, unknown> | undefined, options: {
+        /** A means of parsing a raw binding to a Binding object */
+        pathResolver: BindingParser;
+        /** middleware to use. typically for validation */
+        middleware?: Array<DataModelMiddleware>;
+        /** A logger to use  */
+        logger?: Logger;
+    });
+    getModel(): PipelinedDataModel;
+    private resolveDataValue;
+    set(transaction: RawSetTransaction, options?: DataModelOptions): Updates;
+    private resolve;
+    get(binding: BindingLike, options?: DataModelOptions): any;
+    delete(binding: BindingLike, options?: DataModelOptions): void;
+    serialize(): object;
+    makeReadOnly(): ReadOnlyDataController;
+}
+//# sourceMappingURL=controller.d.ts.map

package/types/controllers/data/index.d.ts

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

package/types/controllers/data/utils.d.ts

@@ -0,0 +1,14 @@
+import type { DataController } from ".";
+import type { Logger } from "../../logger";
+import type { BindingLike } from "../../binding";
+import type { DataModelWithParser, DataModelOptions, Updates } from "../../data";
+/** Wrapper for the Data Controller Class that prevents writes */
+export declare class ReadOnlyDataController implements DataModelWithParser<DataModelOptions> {
+    private controller;
+    private logger?;
+    constructor(controller: DataController, logger?: Logger);
+    get(binding: BindingLike, options?: DataModelOptions | undefined): any;
+    set(transaction: [BindingLike, any][], options?: DataModelOptions | undefined): Updates;
+    delete(binding: BindingLike, options?: DataModelOptions | undefined): void;
+}
+//# sourceMappingURL=utils.d.ts.map

package/types/controllers/flow/controller.d.ts

@@ -0,0 +1,25 @@
+import { SyncHook } from "tapable-ts";
+import type { Navigation, NavigationFlowEndState } from "@player-ui/types";
+import type { Logger } from "../../logger";
+import type { TransitionOptions } from "./flow";
+import { FlowInstance } from "./flow";
+/** A manager for the navigation section of a Content blob */
+export declare class FlowController {
+    readonly hooks: {
+        flow: SyncHook<[FlowInstance], Record<string, any>>;
+    };
+    private readonly log?;
+    private navigation;
+    private navStack;
+    current?: FlowInstance;
+    constructor(navigation: Navigation, options?: {
+        /** A logger instance to use */
+        logger?: Logger;
+    });
+    /** Navigate to another state in the state-machine */
+    transition(stateTransition: string, options?: TransitionOptions): void;
+    private addNewFlow;
+    private run;
+    start(): Promise<NavigationFlowEndState>;
+}
+//# sourceMappingURL=controller.d.ts.map

package/types/controllers/flow/flow.d.ts

@@ -0,0 +1,50 @@
+import { SyncBailHook, SyncHook, SyncWaterfallHook } from "tapable-ts";
+import type { NavigationFlow, NavigationFlowState, NavigationFlowEndState } from "@player-ui/types";
+import type { Logger } from "../../logger";
+export interface NamedState {
+    /** The name of the navigation node */
+    name: string;
+    /** The nav node */
+    value: NavigationFlowState;
+}
+export interface TransitionOptions {
+    /** Ignore any validations or other signals preventing the transition from taking place  */
+    force?: boolean;
+}
+export type TransitionFunction = (name: string, options?: TransitionOptions) => void;
+/** The Content navigation state machine */
+export declare class FlowInstance {
+    private flow;
+    private log?;
+    private history;
+    private isTransitioning;
+    private flowPromise?;
+    readonly id: string;
+    currentState?: NamedState;
+    readonly hooks: {
+        beforeStart: SyncBailHook<[NavigationFlow], NavigationFlow, Record<string, any>>;
+        /** A callback when the onStart node was present */
+        onStart: SyncHook<[any], Record<string, any>>;
+        /** A callback when the onEnd node was present */
+        onEnd: SyncHook<[any], Record<string, any>>;
+        /** A hook to intercept and block a transition */
+        skipTransition: SyncBailHook<[NamedState | undefined], boolean | undefined, Record<string, any>>;
+        /** A chance to manipulate the flow-node used to calculate the given transition used  */
+        beforeTransition: SyncWaterfallHook<[import("@player-ui/types").NavigationFlowViewState | import("@player-ui/types").NavigationFlowFlowState | import("@player-ui/types").NavigationFlowActionState | import("@player-ui/types").NavigationFlowExternalState, string], Record<string, any>>;
+        /** A chance to manipulate the flow-node calculated after a transition */
+        resolveTransitionNode: SyncWaterfallHook<[NavigationFlowState], Record<string, any>>;
+        /** A callback when a transition from 1 state to another was made */
+        transition: SyncHook<[NamedState | undefined, NamedState], Record<string, any>>;
+        /** A callback to run actions after a transition occurs */
+        afterTransition: SyncHook<[FlowInstance], Record<string, any>>;
+    };
+    constructor(id: string, flow: NavigationFlow, options?: {
+        /** Logger instance to use */
+        logger?: Logger;
+    });
+    /** Start the state machine */
+    start(): Promise<NavigationFlowEndState>;
+    transition(transitionValue: string, options?: TransitionOptions): void;
+    private pushHistory;
+}
+//# sourceMappingURL=flow.d.ts.map

package/types/controllers/flow/index.d.ts

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

package/types/controllers/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./flow";
+export * from "./validation";
+export * from "./view";
+export * from "./data/controller";
+export * from "./constants";
+//# sourceMappingURL=index.d.ts.map

package/types/controllers/validation/binding-tracker.d.ts

@@ -0,0 +1,32 @@
+import type { ViewPlugin, Resolver, ViewInstance } from "../../view";
+import type { BindingInstance, BindingFactory } from "../../binding";
+export interface BindingTracker {
+    /** Get the bindings currently being tracked for validation */
+    getBindings(): Set<BindingInstance>;
+    /** Add a binding to the tracked set */
+    trackBinding(binding: BindingInstance): void;
+}
+interface Options {
+    /** Parse a binding from a view */
+    parseBinding: BindingFactory;
+    /** Callbacks when events happen */
+    callbacks?: {
+        /** Called when a binding is encountered for the first time in a view */
+        onAdd?: (binding: BindingInstance) => void;
+    };
+}
+/** A view plugin that manages bindings tracked across updates */
+export declare class ValidationBindingTrackerViewPlugin implements ViewPlugin, BindingTracker {
+    private options;
+    private trackedBindings;
+    constructor(options: Options);
+    /** Fetch the tracked bindings in the current view */
+    getBindings(): Set<BindingInstance>;
+    /** Add a binding to the tracked set */
+    trackBinding(binding: BindingInstance): void;
+    /** Attach hooks to the given resolver */
+    applyResolver(resolver: Resolver): void;
+    apply(view: ViewInstance): void;
+}
+export {};
+//# sourceMappingURL=binding-tracker.d.ts.map

package/types/controllers/validation/controller.d.ts

@@ -0,0 +1,151 @@
+import type { Validation } from "@player-ui/types";
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
+import type { BindingInstance, BindingFactory } from "../../binding";
+import type { DataModelMiddleware } from "../../data";
+import type { SchemaController } from "../../schema";
+import type { ErrorValidationResponse, ValidationObjectWithHandler, ValidatorContext, ValidationProvider, ValidationResponse, WarningValidationResponse } from "../../validator";
+import { ValidatorRegistry } from "../../validator";
+import type { Logger } from "../../logger";
+import type { Resolve, ViewInstance } from "../../view";
+import type { BindingTracker } from "./binding-tracker";
+export declare const SCHEMA_VALIDATION_PROVIDER_NAME = "schema";
+export declare const VIEW_VALIDATION_PROVIDER_NAME = "view";
+export declare const VALIDATION_PROVIDER_NAME_SYMBOL: unique symbol;
+export type ValidationObjectWithSource = ValidationObjectWithHandler & {
+    /** The name of the validation */
+    [VALIDATION_PROVIDER_NAME_SYMBOL]: string;
+};
+type SimpleValidatorContext = Omit<ValidatorContext, "validation" | "schemaType">;
+interface BaseActiveValidation<T> {
+    /** The validation is being actively shown */
+    state: "active";
+    /** The validation response */
+    response: T;
+}
+type ActiveWarning = BaseActiveValidation<WarningValidationResponse> & {
+    /** Warnings track if they can be dismissed automatically (by navigating) */
+    dismissable: boolean;
+};
+type ActiveError = BaseActiveValidation<ErrorValidationResponse>;
+/**
+ * warnings that keep track of their active state
+ */
+type StatefulWarning = {
+    /** A common key to differentiate between errors and warnings */
+    type: "warning";
+    /** The underlying validation this tracks */
+    value: ValidationObjectWithSource;
+    /** If this is currently preventing navigation from continuing */
+    isBlockingNavigation: boolean;
+} & ({
+    /** warnings start with no state, but can active or dismissed */
+    state: "none" | "dismissed";
+} | ActiveWarning);
+/** Errors that keep track of their state */
+type StatefulError = {
+    /** A common key to differentiate between errors and warnings */
+    type: "error";
+    /** The underlying validation this tracks */
+    value: ValidationObjectWithSource;
+    /** If this is currently preventing navigation from continuing */
+    isBlockingNavigation: boolean;
+} & ({
+    /** Errors start with no state an can be activated */
+    state: "none";
+} | ActiveError);
+export type StatefulValidationObject = StatefulWarning | StatefulError;
+type ValidationRunner = (obj: ValidationObjectWithHandler) => {
+    /** A validation message */
+    message: string;
+} | undefined;
+/** A class that manages validating bindings across phases */
+declare class ValidatedBinding {
+    currentPhase?: Validation.Trigger;
+    private applicableValidations;
+    private validationsByState;
+    get allValidations(): Array<StatefulValidationObject>;
+    weakBindings: Set<BindingInstance>;
+    private onDismiss?;
+    constructor(possibleValidations: Array<ValidationObjectWithSource>, onDismiss?: () => void, log?: Logger, weakBindings?: Set<BindingInstance>);
+    private checkIfBlocking;
+    getAll(): Array<ValidationResponse>;
+    get(): ValidationResponse | undefined;
+    private runApplicableValidations;
+    update(phase: Validation.Trigger, canDismiss: boolean, runner: ValidationRunner): void;
+}
+/**
+ * A controller for orchestrating validation within a running player
+ *
+ * The current validation flow is as follows:
+ *
+ *   - When a binding is first seen, gather all of the possible validations for it from the providers
+ *     - Schema and Crossfield (view) are both providers of possible validations
+ *     - Run all of the applicable validations for that binding for the `load` trigger
+ *
+ *   - When a change occurs, set the phase of the binding to `change`.
+ *     - Run all of the `change` triggered validations for that binding.
+ *
+ *   - When a navigation event occurs, set the phase of the binding to `navigate`.
+ *     - Run all `change` and `navigate` validations for each tracked binding.
+ *     - For any warnings, also keep a state of `shown` or `dismissed`.
+ *       - Set all non-dismissed warnings to `shown`.
+ *       - Set all `shown` warnings to `dismissed`.
+ *     - Allow navigation forward if there are no non-dismissed warnings and no valid errors.
+ */
+export declare class ValidationController implements BindingTracker {
+    readonly hooks: {
+        /** A hook called to tap into the validator registry for adding more validators */
+        createValidatorRegistry: SyncHook<[ValidatorRegistry], Record<string, any>>;
+        /** A callback/event when a new validation is added to the view */
+        onAddValidation: SyncWaterfallHook<[ValidationResponse, BindingInstance], Record<string, any>>;
+        /** The inverse of onAddValidation, this is called when a validation is removed from the list */
+        onRemoveValidation: SyncWaterfallHook<[ValidationResponse, BindingInstance], Record<string, any>>;
+        resolveValidationProviders: SyncWaterfallHook<[{
+            /** The name of the provider */
+            source: string;
+            /** The provider itself */
+            provider: ValidationProvider;
+        }[]], {
+            /** The view this is triggered for  */
+            view?: ViewInstance | undefined;
+        }>;
+        /** A hook called when a binding is added to the tracker */
+        onTrackBinding: SyncHook<[BindingInstance], Record<string, any>>;
+    };
+    private tracker;
+    private validations;
+    private validatorRegistry?;
+    private schema;
+    private providers;
+    private viewValidationProvider?;
+    private options?;
+    private weakBindingTracker;
+    constructor(schema: SchemaController, options?: SimpleValidatorContext);
+    setOptions(options: SimpleValidatorContext): void;
+    /** Return the middleware for the data-model to stop propagation of invalid data */
+    getDataMiddleware(): Array<DataModelMiddleware>;
+    private getValidationProviders;
+    reset(): void;
+    onView(view: ViewInstance): void;
+    updateValidationsForBinding(binding: BindingInstance, trigger: Validation.Trigger, validationContext?: SimpleValidatorContext, onDismiss?: () => void): void;
+    validationRunner(validationObj: ValidationObjectWithHandler, binding: BindingInstance, context?: SimpleValidatorContext | undefined): {
+        message: string;
+    } | undefined;
+    private updateValidationsForView;
+    private get activeBindings();
+    getValidator(type: string): import("../../validator").ValidatorFunction | undefined;
+    getBindings(): Set<BindingInstance>;
+    trackBinding(binding: BindingInstance): void;
+    /** Executes all known validations for the tracked bindings using the given model */
+    validateView(trigger?: Validation.Trigger): {
+        /** Indicating if the view can proceed without error */
+        canTransition: boolean;
+        /** the validations that are preventing the view from continuing */
+        validations?: Map<BindingInstance, ValidationResponse>;
+    };
+    /** Get the current tracked validation for the given binding */
+    getValidationForBinding(binding: BindingInstance): ValidatedBinding | undefined;
+    forView(parser: BindingFactory): Resolve.Validation;
+}
+export {};
+//# sourceMappingURL=controller.d.ts.map

package/types/controllers/validation/index.d.ts

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

package/types/controllers/view/asset-transform.d.ts

@@ -0,0 +1,19 @@
+import type { Node } from "../../view";
+import { LocalStateStore } from "./store";
+import type { TransformRegistry } from "./types";
+import type { ViewController } from "./controller";
+/**
+ * A plugin to register custom transforms on certain asset types
+ * This allows users to embed stateful data into transforms.
+ */
+export declare class AssetTransformCorePlugin {
+    readonly stateStore: Map<Node.Node, LocalStateStore>;
+    private readonly registry;
+    private beforeResolveSymbol;
+    private resolveSymbol;
+    private beforeResolveCountSymbol;
+    private resolveCountSymbol;
+    constructor(registry: TransformRegistry);
+    apply(viewController: ViewController): void;
+}
+//# sourceMappingURL=asset-transform.d.ts.map

package/types/controllers/view/controller.d.ts

@@ -0,0 +1,37 @@
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
+import type { View, NavigationFlowViewState } from "@player-ui/types";
+import type { Resolve } from "../../view";
+import { ViewInstance } from "../../view";
+import type { Logger } from "../../logger";
+import type { FlowController } from "../flow";
+import type { DataController } from "../data/controller";
+import type { TransformRegistry } from "./types";
+export interface ViewControllerOptions {
+    /** Where to get data from */
+    model: DataController;
+    /** Where to log data */
+    logger?: Logger;
+    /** A flow-controller instance to listen for view changes */
+    flowController: FlowController;
+}
+/** A controller to manage updating/switching views */
+export declare class ViewController {
+    readonly hooks: {
+        /** Do any processing before the `View` instance is created */
+        resolveView: SyncWaterfallHook<[(import("@player-ui/types").Asset<string> & {
+            validation?: import("@player-ui/types").Validation.CrossfieldReference[] | undefined;
+        }) | undefined, string, NavigationFlowViewState], Record<string, any>>;
+        view: SyncHook<[ViewInstance], Record<string, any>>;
+    };
+    private readonly viewMap;
+    private readonly viewOptions;
+    private pendingUpdate?;
+    currentView?: ViewInstance;
+    transformRegistry: TransformRegistry;
+    optimizeUpdates: boolean;
+    constructor(initialViews: View[], options: Resolve.ResolverOptions & ViewControllerOptions);
+    private queueUpdate;
+    private getViewForRef;
+    onView(state: NavigationFlowViewState): void;
+}
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from "./asset-transform";
+export * from "./controller";
+export * from "./store";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/types/controllers/view/store.d.ts

@@ -0,0 +1,20 @@
+export interface Store {
+    useLocalState<T>(initialState: T): readonly [T, (value: T) => void];
+    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (value: T) => void];
+}
+interface SharedStore {
+    getLocalStateFunction<T>(key: string | symbol, countKey: symbol): (initialState: T) => readonly [T, (value: T) => void];
+    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (value: T) => void];
+}
+/** A store that holds on to state for a transform */
+export declare class LocalStateStore implements SharedStore {
+    private state;
+    private updateCallback?;
+    constructor(onUpdate?: () => void);
+    removeKey(key: symbol | string): void;
+    reset(): void;
+    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (newState: T) => void];
+    getLocalStateFunction<T>(key: symbol, countKey: symbol): (initialState: T) => readonly [T, (newState: T) => void];
+}
+export {};
+//# sourceMappingURL=store.d.ts.map