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

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

@@ -0,0 +1,16 @@
+import type { Asset } from "@player-ui/types";
+import type { Registry } from "@player-ui/partial-match-registry";
+import type { Resolve, Node } from "../../view";
+import type { Store } from "./store";
+/** Transform function that is ran on the Asset before it's resolved */
+export type BeforeTransformFunction<AuthoredAsset extends Asset = Asset> = (asset: Node.Asset<AuthoredAsset> | Node.View<AuthoredAsset>, options: Resolve.NodeResolveOptions, store: Store) => Node.Node;
+/** Transform function that is ran on the Asset after it's resolved */
+export type TransformFunction<AuthoredAsset extends Asset = Asset, TransformedAsset extends Asset = AuthoredAsset> = (asset: AuthoredAsset, options: Resolve.NodeResolveOptions, store: Store) => TransformedAsset;
+export interface TransformFunctions {
+    /** A function that is executed as an AST -> AST transform before resolving the node to a value */
+    beforeResolve?: BeforeTransformFunction<any>;
+    /** A function to resolve an AST to a value */
+    resolve?: TransformFunction<any>;
+}
+export type TransformRegistry = Registry<TransformFunctions>;
+//# sourceMappingURL=types.d.ts.map

package/types/data/dependency-tracker.d.ts

@@ -0,0 +1,49 @@
+import type { BindingInstance } from "../binding";
+import type { BatchSetTransaction, DataModelImpl, DataModelMiddleware, DataModelOptions, Updates } from "./model";
+export type DependencySets = "core" | "children";
+/** A class to track usage of read/writes to/from a data model */
+export declare class DependencyTracker {
+    protected readDeps: Set<BindingInstance>;
+    protected writeDeps: Set<BindingInstance>;
+    protected namedSet: DependencySets;
+    private namedDependencySets;
+    constructor();
+    protected createSubset(name: DependencySets, force?: boolean): void;
+    /** Grab all of the bindings that this depended on */
+    getDependencies(name?: DependencySets): Set<BindingInstance>;
+    trackSubset(name: DependencySets): void;
+    trackDefault(): void;
+    /** Grab all of the bindings this wrote to */
+    getModified(name?: DependencySets): Set<BindingInstance>;
+    /**
+     * Check to see if the dataModel has read the value at the given binding
+     *
+     * @param binding - The binding you want to check for
+     */
+    readsBinding(binding: BindingInstance): boolean;
+    /**
+     * Check to see if the dataModel has written to the binding
+     */
+    writesBinding(binding: BindingInstance): boolean;
+    /** Reset all tracking of dependencies */
+    reset(): void;
+    protected addReadDep(binding: BindingInstance, namedSet?: DependencySets): void;
+    protected addWriteDep(binding: BindingInstance, namedSet?: DependencySets): void;
+    addChildReadDep(binding: BindingInstance): void;
+}
+/** Middleware that tracks dependencies of read/written data */
+export declare class DependencyMiddleware extends DependencyTracker implements DataModelMiddleware {
+    constructor();
+    set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl | undefined): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl | undefined): any;
+    delete(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl | undefined): void | undefined;
+}
+/** A data-model that tracks dependencies of read/written data */
+export declare class DependencyModel<Options = DataModelOptions> extends DependencyTracker implements DataModelImpl<Options> {
+    private readonly rootModel;
+    constructor(rootModel: DataModelImpl<Options>);
+    set(transaction: BatchSetTransaction, options?: Options): Updates;
+    get(binding: BindingInstance, options?: Options): any;
+    delete(binding: BindingInstance, options?: Options): void;
+}
+//# sourceMappingURL=dependency-tracker.d.ts.map

package/types/data/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./dependency-tracker";
+export * from "./model";
+export * from "./noop-model";
+export * from "./local-model";
+//# sourceMappingURL=index.d.ts.map

package/types/data/local-model.d.ts

@@ -0,0 +1,16 @@
+import type { BindingInstance } from "../binding";
+import type { BatchSetTransaction, DataModelImpl, Updates } from "./model";
+/**
+ * A data model that stores data in an in-memory JS object
+ */
+export declare class LocalModel implements DataModelImpl {
+    model: {
+        [key: string]: any;
+    };
+    constructor(model?: {});
+    reset(model?: {}): void;
+    get(binding?: BindingInstance): any;
+    set(transaction: BatchSetTransaction): Updates;
+    delete(binding: BindingInstance): void;
+}
+//# sourceMappingURL=local-model.d.ts.map

package/types/data/model.d.ts

@@ -0,0 +1,86 @@
+import { SyncHook } from "tapable-ts";
+import type { BindingLike, BindingFactory } from "../binding";
+import { BindingInstance } from "../binding";
+export declare const ROOT_BINDING: BindingInstance;
+export type BatchSetTransaction = [BindingInstance, any][];
+export type Updates = Array<{
+    /** The updated binding */
+    binding: BindingInstance;
+    /** The old value */
+    oldValue: any;
+    /** The new value */
+    newValue: any;
+    /** Force the Update to be included even if no data changed */
+    force?: boolean;
+}>;
+/** Options to use when getting or setting data */
+export interface DataModelOptions {
+    /**
+     * The data (either to set or get) should represent a formatted value
+     * For setting data, the data will be de-formatted before continuing in the pipeline
+     * For getting data, the data will be formatted before returning
+     */
+    formatted?: boolean;
+    /**
+     * By default, fetching data will ignore any invalid data.
+     * You can choose to grab the queued invalid data if you'd like
+     * This is usually the case for user-inputs
+     */
+    includeInvalid?: boolean;
+    /**
+     * A flag to set to ignore any default value in the schema, and just use the raw value
+     */
+    ignoreDefaultValue?: boolean;
+    /**
+     * A flag to indicate that this update should happen silently
+     */
+    silent?: boolean;
+    /** Other context associated with this request */
+    context?: {
+        /** The data model to use when getting other data from the context of this request */
+        model: DataModelWithParser;
+    };
+}
+export interface DataModelWithParser<Options = DataModelOptions> {
+    get(binding: BindingLike, options?: Options): any;
+    set(transaction: [BindingLike, any][], options?: Options): Updates;
+    delete(binding: BindingLike, options?: Options): void;
+}
+export interface DataModelImpl<Options = DataModelOptions> {
+    get(binding: BindingInstance, options?: Options): any;
+    set(transaction: BatchSetTransaction, options?: Options): Updates;
+    delete(binding: BindingInstance, options?: Options): void;
+}
+export interface DataModelMiddleware {
+    /** The name of the middleware */
+    name?: string;
+    set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): any;
+    delete?(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): void;
+    reset?(): void;
+}
+/** Wrap the inputs of the DataModel with calls to parse raw binding inputs */
+export declare function withParser<Options = unknown>(model: DataModelImpl<Options>, parseBinding: BindingFactory): DataModelWithParser<Options>;
+/** Wrap a middleware instance in a DataModel compliant API */
+export declare function toModel(middleware: DataModelMiddleware, defaultOptions?: DataModelOptions, next?: DataModelImpl): DataModelImpl;
+export type DataPipeline = Array<DataModelMiddleware | DataModelImpl>;
+/**
+ * Given a set of steps in a pipeline, create the effective data-model
+ */
+export declare function constructModelForPipeline(pipeline: DataPipeline): DataModelImpl;
+/** A DataModel that manages middleware data handlers  */
+export declare class PipelinedDataModel implements DataModelImpl {
+    private pipeline;
+    private effectiveDataModel;
+    readonly hooks: {
+        onSet: SyncHook<[BatchSetTransaction], Record<string, any>>;
+    };
+    constructor(pipeline?: DataPipeline);
+    setMiddleware(handlers: DataPipeline): void;
+    addMiddleware(handler: DataModelMiddleware): void;
+    reset(model?: {}): void;
+    set(transaction: BatchSetTransaction, options?: DataModelOptions): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions): any;
+    delete(binding: BindingInstance, options?: DataModelOptions): void;
+}
+//# sourceMappingURL=model.d.ts.map

package/types/data/noop-model.d.ts

@@ -0,0 +1,13 @@
+import type { DataModelImpl } from "./model";
+/**
+ * A model that does nothing
+ * Helpful for testing and other default DataModel applications
+ */
+export declare class NOOPDataModel implements DataModelImpl {
+    get(): undefined;
+    set(): never[];
+    delete(): void;
+}
+/** You only really need 1 instance of the NOOP model */
+export declare const NOOP_MODEL: NOOPDataModel;
+//# sourceMappingURL=noop-model.d.ts.map

package/types/expressions/evaluator-functions.d.ts

@@ -0,0 +1,15 @@
+import type { Binding } from "@player-ui/types";
+import type { ExpressionHandler, ExpressionNode } from "./types";
+/** Sets a value to the data-model */
+export declare const setDataVal: ExpressionHandler<[Binding, any], any>;
+/** Fetches a valid from the data-model */
+export declare const getDataVal: ExpressionHandler<[Binding], unknown>;
+/** Deletes a value from the model */
+export declare const deleteDataVal: ExpressionHandler<[Binding], void>;
+/** Conditional expression handler */
+export declare const conditional: ExpressionHandler<[
+    ExpressionNode,
+    ExpressionNode,
+    ExpressionNode?
+]>;
+//# sourceMappingURL=evaluator-functions.d.ts.map

package/types/expressions/evaluator.d.ts

@@ -0,0 +1,52 @@
+import { SyncWaterfallHook, SyncBailHook } from "tapable-ts";
+import type { ExpressionNode, BinaryOperator, UnaryOperator, ExpressionType, ExpressionContext, ExpressionHandler } from "./types";
+export interface HookOptions extends ExpressionContext {
+    /** Given an expression node  */
+    resolveNode: (node: ExpressionNode) => any;
+    /** Enabling this flag skips calling the onError hook, and just throws errors back to the caller.
+     * The caller is responsible for handling the error.
+     */
+    throwErrors?: boolean;
+    /** Whether expressions should be parsed strictly or not */
+    strict?: boolean;
+}
+export type ExpressionEvaluatorOptions = Omit<HookOptions, "resolveNode" | "evaluate">;
+export type ExpressionEvaluatorFunction = (exp: ExpressionType, options?: ExpressionEvaluatorOptions) => any;
+/**
+ * The expression evaluator is responsible for parsing and executing anything in the custom expression language
+ * */
+export declare class ExpressionEvaluator {
+    private readonly vars;
+    readonly hooks: {
+        /** Resolve an AST node for an expression to a value */
+        resolve: SyncWaterfallHook<[any, ExpressionNode, HookOptions], Record<string, any>>;
+        /** Gets the options that will be passed in calls to the resolve hook */
+        resolveOptions: SyncWaterfallHook<[HookOptions], Record<string, any>>;
+        /** Allows users to change the expression to be evaluated before processing */
+        beforeEvaluate: SyncWaterfallHook<[ExpressionType, HookOptions], Record<string, any>>;
+        /**
+         * An optional means of handling an error in the expression execution
+         * Return true if handled, to stop propagation of the error
+         */
+        onError: SyncBailHook<[Error], true, Record<string, any>>;
+    };
+    private readonly expressionsCache;
+    private readonly defaultHookOptions;
+    readonly operators: {
+        binary: Map<string, BinaryOperator>;
+        unary: Map<string, UnaryOperator>;
+        expressions: Map<string, ExpressionHandler<any, any>>;
+    };
+    reset(): void;
+    constructor(defaultOptions: ExpressionEvaluatorOptions);
+    evaluate(expr: ExpressionType, options?: ExpressionEvaluatorOptions): any;
+    addExpressionFunction<T extends readonly unknown[], R>(name: string, handler: ExpressionHandler<T, R>): void;
+    addBinaryOperator(operator: string, handler: BinaryOperator): void;
+    addUnaryOperator(operator: string, handler: UnaryOperator): void;
+    setExpressionVariable(name: string, value: unknown): void;
+    getExpressionVariable(name: string): unknown;
+    private _execAST;
+    private _execString;
+    private _resolveNode;
+}
+//# sourceMappingURL=evaluator.d.ts.map

package/types/expressions/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./evaluator";
+export * from "./types";
+export * from "./utils";
+export * from "./parser";
+//# sourceMappingURL=index.d.ts.map

package/types/expressions/parser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An expression to AST parser based on JSEP: http://jsep.from.so/
+ */
+import type { ExpressionNode } from "./types";
+/** Parse out an expression from the string */
+export declare function parseExpression(expr: string, options?: {
+    /** If true (the default), will throw on invalid expressions */
+    strict?: boolean;
+}): ExpressionNode;
+//# sourceMappingURL=parser.d.ts.map

package/types/expressions/types.d.ts

@@ -0,0 +1,144 @@
+import type { DataModelWithParser } from "../data";
+import type { Logger } from "../logger";
+export type ExpressionObjectType = {
+    /** The expression to eval */
+    value: BasicExpressionTypes;
+};
+export type ExpressionLiteralType = string | number | boolean | undefined | null;
+export type BasicExpressionTypes = ExpressionLiteralType | ExpressionObjectType | Array<ExpressionLiteralType | ExpressionObjectType>;
+export type ExpressionType = BasicExpressionTypes | ExpressionNode;
+export interface OperatorProcessingOptions {
+    /**
+     * When set to a falsy value, the arguments passed to the handler will be raw AST Nodes
+     * This enables lazy evaluation of arguments
+     */
+    resolveParams: boolean;
+}
+export type BinaryOperatorBasic = (left: any, right: any) => unknown;
+export type BinaryOperatorAdvanced = OperatorProcessingOptions & ((ctx: ExpressionContext, left: any, right: any) => unknown);
+export type BinaryOperator = BinaryOperatorAdvanced | BinaryOperatorBasic;
+export type UnaryOperator = ((arg: any) => unknown) | (((ctx: ExpressionContext, arg: any) => unknown) & OperatorProcessingOptions);
+export interface ExpressionContext {
+    /** A means of executing an expression */
+    evaluate: (expr: ExpressionType) => unknown;
+    /** The data model that expression handlers can use when fetching data */
+    model: DataModelWithParser;
+    /** A logger to use */
+    logger?: Logger;
+}
+export type ExpressionHandler<T extends readonly unknown[] = unknown[], R = void> = ((context: ExpressionContext, ...args: T) => R) & Partial<OperatorProcessingOptions>;
+export declare const ExpNodeOpaqueIdentifier: unique symbol;
+/** Checks if the input is an already processed Expression node */
+export declare function isExpressionNode(x: any): x is ExpressionNode;
+export interface NodePosition {
+    /** The character location */
+    character: number;
+}
+export interface NodeLocation {
+    /** The start of the node */
+    start: NodePosition;
+    /** The end of the node */
+    end: NodePosition;
+}
+export interface BaseNode<T> {
+    /** The thing to discriminate the AST type on */
+    type: T;
+    /** How to tell this apart from other objects */
+    __id: typeof ExpNodeOpaqueIdentifier;
+    /** The location of the node in the source expression string */
+    location?: NodeLocation;
+    /**
+     * The error that occurred while parsing this node
+     * This is only set if the parsing mode is set to non-strict
+     */
+    error?: Error;
+}
+/** A helper interface for nodes that container left and right children */
+export interface DirectionalNode {
+    /** The left node. Often for the left hand side of an expression */
+    left: ExpressionNode;
+    /** The right child. Often for the right hand side of an expression */
+    right: ExpressionNode;
+}
+export interface LiteralNode extends BaseNode<"Literal"> {
+    /** A node that holds a literal value */
+    value: string | number;
+    /** The unprocessed value */
+    raw?: any;
+}
+export interface BinaryNode extends BaseNode<"BinaryExpression">, DirectionalNode {
+    /** The operation to perform on the nodes */
+    operator: string;
+}
+export interface LogicalNode extends BaseNode<"LogicalExpression">, DirectionalNode {
+    /** The logical operation to perform on the nodes */
+    operator: string;
+}
+export interface UnaryNode extends BaseNode<"UnaryExpression"> {
+    /** The operation to perform on the node */
+    operator: string;
+    /** The single argument that the operation should be performed on */
+    argument: ExpressionNode;
+}
+export type ThisNode = BaseNode<"ThisExpression">;
+export interface ModelRefNode extends BaseNode<"ModelRef"> {
+    /** The binding that the model reference points to */
+    ref: string;
+}
+export interface ObjectNode extends BaseNode<"Object"> {
+    /**  */
+    attributes: Array<{
+        /** The property name of the object */
+        key: ExpressionNode;
+        /** the associated value */
+        value: ExpressionNode;
+    }>;
+}
+export interface MemberExpressionNode extends BaseNode<"MemberExpression"> {
+    /** The object to be introspected */
+    object: ExpressionNode;
+    /** If the property uses . or open-bracket */
+    computed: boolean;
+    /** The property to access on the object */
+    property: ExpressionNode;
+}
+export interface ConditionalExpressionNode extends BaseNode<"ConditionalExpression"> {
+    /** The test for the ternary */
+    test: ExpressionNode;
+    /** The truthy case for the ternary */
+    consequent: ExpressionNode;
+    /** The falsy case for the ternary */
+    alternate: ExpressionNode;
+}
+export interface CompoundNode extends BaseNode<"Compound"> {
+    /** The contents of the compound expression */
+    body: ExpressionNode[];
+}
+export interface CallExpressionNode extends BaseNode<"CallExpression"> {
+    /** The arguments to the function */
+    args: ExpressionNode[];
+    /** The function name */
+    callTarget: IdentifierNode;
+}
+export interface ArrayExpressionNode extends BaseNode<"ArrayExpression"> {
+    /** The items in an array */
+    elements: ExpressionNode[];
+}
+export interface IdentifierNode extends BaseNode<"Identifier"> {
+    /** The variable name */
+    name: string;
+}
+export type AssignmentNode = BaseNode<"Assignment"> & DirectionalNode;
+export interface ModificationNode extends BaseNode<"Modification">, DirectionalNode {
+    /** The operator for the modification */
+    operator: string;
+}
+export type ExpressionNode = LiteralNode | BinaryNode | LogicalNode | UnaryNode | ThisNode | ModelRefNode | MemberExpressionNode | ConditionalExpressionNode | CompoundNode | CallExpressionNode | ArrayExpressionNode | IdentifierNode | AssignmentNode | ModificationNode | ObjectNode;
+export type ExpressionNodeType = ExpressionNode["type"];
+export interface ErrorWithLocation extends Error {
+    /** The place in the string where the error occurs */
+    index: number;
+    /** a helpful description */
+    description: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/expressions/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ErrorWithLocation, ExpressionHandler, ExpressionNode, ExpressionObjectType, ExpressionType, NodePosition } from "./types";
+/** Generates a function by removing the first context argument */
+export declare function withoutContext<T extends unknown[], Return>(fn: (...args: T) => Return): ExpressionHandler<T, Return>;
+/** Get the node in the expression that's closest to the desired position */
+export declare function findClosestNodeAtPosition(node: ExpressionNode, position: NodePosition): ExpressionNode | undefined;
+/** Checks if the expression is a simple type */
+export declare function isObjectExpression(expr: ExpressionType): expr is ExpressionObjectType;
+/**
+ * Type guard for ErrorWithLocation
+ */
+export declare function isErrorWithLocation(error: Error): error is ErrorWithLocation;
+//# sourceMappingURL=utils.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,14 @@
+export * from "@player-ui/types";
+export * from "./binding/index";
+export * from "./data/index";
+export * from "./expressions/index";
+export * from "./logger/index";
+export * from "./schema/index";
+export * from "./string-resolver/index";
+export * from "./validator/index";
+export * from "./view/index";
+export * from "./player";
+export * from "./controllers/index";
+export * from "./types";
+export * from "./plugins/flow-exp-plugin";
+//# sourceMappingURL=index.d.ts.map

package/types/logger/consoleLogger.d.ts

@@ -0,0 +1,17 @@
+import type { Logger, Severity } from "./types";
+export type ConsoleHandler = Pick<typeof console, "log" | "warn" | "error">;
+/** A Logger implementation that uses console */
+export default class ConsoleLogger implements Logger {
+    private severity;
+    private _console;
+    constructor(severity?: Severity, _console?: ConsoleHandler);
+    setSeverity(severity: Severity): void;
+    private getConsoleFn;
+    private createHandler;
+    readonly trace: (...args: any[]) => void;
+    readonly debug: (...args: any[]) => void;
+    readonly info: (...args: any[]) => void;
+    readonly warn: (...args: any[]) => void;
+    readonly error: (...args: any[]) => void;
+}
+//# sourceMappingURL=consoleLogger.d.ts.map

package/types/logger/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export { default as ConsoleLogger } from "./consoleLogger";
+export { default as NoopLogger } from "./noopLogger";
+export { default as TapableLogger } from "./tapableLogger";
+export { default as ProxyLogger } from "./proxyLogger";
+//# sourceMappingURL=index.d.ts.map

package/types/logger/noopLogger.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "./types";
+/** A logger implementation that goes nowhere */
+export default class NoopLogger implements Logger {
+    readonly trace: () => void;
+    readonly debug: () => void;
+    readonly info: () => void;
+    readonly warn: () => void;
+    readonly error: () => void;
+}
+//# sourceMappingURL=noopLogger.d.ts.map

package/types/logger/proxyLogger.d.ts

@@ -0,0 +1,15 @@
+import type { Logger, LoggerProvider } from "./types";
+/**
+ * The ProxyLogger allows a user to log to another Logger instance that may not exist yet
+ */
+export default class ProxyLogger implements Logger {
+    private proxiedLoggerProvider;
+    constructor(loggerProvider: LoggerProvider);
+    private createHandler;
+    readonly trace: (...args: any[]) => void;
+    readonly debug: (...args: any[]) => void;
+    readonly info: (...args: any[]) => void;
+    readonly warn: (...args: any[]) => void;
+    readonly error: (...args: any[]) => void;
+}
+//# sourceMappingURL=proxyLogger.d.ts.map

package/types/logger/tapableLogger.d.ts

@@ -0,0 +1,23 @@
+import { SyncHook } from "tapable-ts";
+import type { Logger } from "./types";
+/** A logger that has a tapable subscriptions to callbacks */
+export default class TapableLogger implements Logger {
+    readonly hooks: {
+        trace: SyncHook<[any[]], Record<string, any>>;
+        debug: SyncHook<[any[]], Record<string, any>>;
+        info: SyncHook<[any[]], Record<string, any>>;
+        warn: SyncHook<[any[]], Record<string, any>>;
+        error: SyncHook<[any[]], Record<string, any>>;
+        log: SyncHook<["error" | "trace" | "debug" | "info" | "warn", any[]], Record<string, any>>;
+    };
+    private logHandlers;
+    private createHandler;
+    addHandler(logHandler: Logger): void;
+    removeHandler(logHandler: Logger): void;
+    readonly trace: (...args: any[]) => void;
+    readonly debug: (...args: any[]) => void;
+    readonly info: (...args: any[]) => void;
+    readonly warn: (...args: any[]) => void;
+    readonly error: (...args: any[]) => void;
+}
+//# sourceMappingURL=tapableLogger.d.ts.map

package/types/logger/types.d.ts

@@ -0,0 +1,6 @@
+export type LogFn = (...args: Array<any>) => void;
+export declare const severities: readonly ["trace", "debug", "info", "warn", "error"];
+export type Severity = (typeof severities)[number];
+export type Logger = Record<Severity, LogFn>;
+export type LoggerProvider = () => Logger | undefined;
+//# sourceMappingURL=types.d.ts.map

package/types/player.d.ts

@@ -0,0 +1,101 @@
+import type { Flow as FlowType } from "@player-ui/types";
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
+import type { Logger } from "./logger";
+import { TapableLogger } from "./logger";
+import { ExpressionEvaluator } from "./expressions";
+import { SchemaController } from "./schema";
+import { BindingParser } from "./binding";
+import type { ViewInstance } from "./view";
+import { ConstantsController, ViewController, DataController, ValidationController, FlowController } from "./controllers";
+import type { PlayerFlowState, CompletedState } from "./types";
+export interface PlayerPlugin {
+    /**
+     * Unique identifier of the plugin.
+     * Enables the plugin to be retrievable from Player.
+     */
+    symbol?: symbol;
+    /** The name of the plugin */
+    name: string;
+    /**
+     * Use this to tap into Player hooks
+     */
+    apply: (player: Player) => void;
+}
+export interface ExtendedPlayerPlugin<Assets = void, Views = void, Expressions = void, DataTypes = void> {
+}
+export interface PlayerConfigOptions {
+    /** A set of plugins to load  */
+    plugins?: PlayerPlugin[];
+    /** A logger to use */
+    logger?: Logger;
+}
+export interface PlayerInfo {
+    /** Version of the running player */
+    version: string;
+    /** Hash of the HEAD commit used to build the current version */
+    commit: string;
+}
+/**
+ * This is it.
+ */
+export declare class Player {
+    static readonly info: PlayerInfo;
+    readonly logger: TapableLogger;
+    readonly constantsController: ConstantsController;
+    private config;
+    private state;
+    readonly hooks: {
+        /** The hook that fires every time we create a new flowController (a new Content blob is passed in) */
+        flowController: SyncHook<[FlowController], Record<string, any>>;
+        /** The hook that updates/handles views */
+        viewController: SyncHook<[ViewController], Record<string, any>>;
+        /** A hook called every-time there's a new view. This is equivalent to the view hook on the view-controller */
+        view: SyncHook<[ViewInstance], Record<string, any>>;
+        /** Called when an expression evaluator was created */
+        expressionEvaluator: SyncHook<[ExpressionEvaluator], Record<string, any>>;
+        /** The hook that creates and manages data */
+        dataController: SyncHook<[DataController], Record<string, any>>;
+        /** Called after the schema is created for a flow */
+        schema: SyncHook<[SchemaController], Record<string, any>>;
+        /** Manages validations (schema and x-field ) */
+        validationController: SyncHook<[ValidationController], Record<string, any>>;
+        /** Manages parsing binding */
+        bindingParser: SyncHook<[BindingParser], Record<string, any>>;
+        /** A that's called for state changes in the flow execution */
+        state: SyncHook<[PlayerFlowState], Record<string, any>>;
+        /** A hook to access the current flow */
+        onStart: SyncHook<[FlowType<import("@player-ui/types").Asset<string>>], Record<string, any>>;
+        /** A hook for when the flow ends either in success or failure */
+        onEnd: SyncHook<[], Record<string, any>>;
+        /** Mutate the Content flow before starting */
+        resolveFlowContent: SyncWaterfallHook<[FlowType<import("@player-ui/types").Asset<string>>], Record<string, any>>;
+    };
+    constructor(config?: PlayerConfigOptions);
+    /**  Returns currently registered plugins */
+    getPlugins(): PlayerPlugin[];
+    /** Find instance of [Plugin] that has been registered to Player */
+    findPlugin<Plugin extends PlayerPlugin>(symbol: symbol): Plugin | undefined;
+    /** Retrieve an instance of [Plugin] and conditionally invoke [apply] if it exists */
+    applyTo<Plugin extends PlayerPlugin>(symbol: symbol, apply: (plugin: Plugin) => void): void;
+    /** Register and apply [Plugin] if one with the same symbol is not already registered. */
+    registerPlugin(plugin: PlayerPlugin): void;
+    /** Returns the current version of the running player */
+    getVersion(): string;
+    /** Returns the git commit used to build Player version */
+    getCommit(): string;
+    /**
+     * Fetch the current state of Player.
+     * It will return either `not-started`, `in-progress`, `completed`
+     * with some extra data in each
+     */
+    getState(): PlayerFlowState;
+    /**
+     * A private means of setting the state of Player
+     * Calls the hooks for subscribers to listen for this event
+     */
+    private setState;
+    /** Start Player with the given flow */
+    private setupFlow;
+    start(payload: FlowType): Promise<CompletedState>;
+}
+//# sourceMappingURL=player.d.ts.map

package/types/plugins/default-exp-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 DefaultExpPlugin implements PlayerPlugin {
+    name: string;
+    apply(player: Player): void;
+}
+//# sourceMappingURL=default-exp-plugin.d.ts.map