@player-ui/player/types/view/resolver/types.d.ts

import type { Schema, Formatting, Validation as ValidationTypes } from "@player-ui/types";
import type { BindingInstance, BindingLike, BindingFactory } from "../../binding";
import type { DataModelWithParser, DataModelImpl, DataModelOptions } from "../../data";
import type { ConstantsProvider } from "../../controllers/constants";
import type { TransitionFunction } from "../../controllers";
import type { ExpressionEvaluator, ExpressionType } from "../../expressions";
import type { ValidationResponse } from "../../validator";
import type { Logger } from "../../logger";
import type { SchemaController } from "../../schema";
import type { Node } from "../parser";
export interface ValidationGetResolveOptions {
    /**
     * If we should ignore any non-blocking validations in the return
     * @default true
     */
    ignoreNonBlocking?: boolean;
}
export interface PlayerUtils {
    findPlugin<Plugin = unknown>(symbol: symbol): Plugin | undefined;
}
export declare namespace Resolve {
    interface Validation {
        /** Fetch the data-type for the given binding */
        type(binding: BindingLike): Schema.DataType | undefined;
        /** Get all currently applicable validation errors */
        getAll(options?: ValidationGetResolveOptions): Map<BindingInstance, ValidationResponse> | undefined;
        /** Internal Method to lookup if there is a validation for the given binding */
        _getValidationForBinding(binding: BindingLike): {
            /** Get the validation for the given binding */
            get: (options?: ValidationGetResolveOptions) => ValidationResponse | undefined;
            /** Get all validations for the given binding */
            getAll: (options?: ValidationGetResolveOptions) => Array<ValidationResponse>;
        } | undefined;
        /** Get field level error for the specific binding */
        get(binding: BindingLike, options?: {
            /** If this binding should also be tracked for validations */
            track?: boolean;
        } & ValidationGetResolveOptions): ValidationResponse | undefined;
        getValidationsForBinding(binding: BindingLike, options?: {
            /** If this binding should also be tracked for validations */
            track?: boolean;
        } & ValidationGetResolveOptions): Array<ValidationResponse>;
        /** Get errors for all children regardless of section */
        getChildren(type?: ValidationTypes.DisplayTarget): Array<ValidationResponse>;
        /** Get errors for all children solely in this section */
        getValidationsForSection(): Array<ValidationResponse>;
        /** Track errors for this binding, and notify the node of changes */
        track: (binding: BindingLike) => void;
        /** Register node as a section */
        register: (options?: {
            /** While type of Display Target group it should register as */
            type: Exclude<ValidationTypes.DisplayTarget, "field">;
        }) => void;
    }
    interface BaseOptions {
        /** A logger to use */
        logger?: Logger;
        /** Utils for various useful operations */
        utils?: PlayerUtils;
        /** An optional set of validation features */
        validation?: Validation;
        /** Parse a raw valy into an AST node */
        parseNode?: (node: any) => Node.Node | null;
        /** A function to move the state to a new place */
        transition?: TransitionFunction;
        /** The hub for data invariants and metaData associated with the data model */
        schema: SchemaController;
        /** The constants for messages */
        constants?: ConstantsProvider;
    }
    interface NodeDataOptions {
        /** The data to set or get data from */
        model: DataModelWithParser<DataModelOptions>;
        /**
         * A function to format a given a value (given a binding) for display to the user
         * Note: this doesn't persist any changes in the model.
         */
        format: (binding: BindingLike, value: any) => any;
        /**
         * A function to format a given value using a formatting reference.
         * The default behavior is the identity function.
         */
        formatValue: (formatReference: Formatting.Reference, value: any) => any;
    }
    type NodeResolveOptions = BaseOptions & {
        /** Execute the expression and return it's result */
        evaluate: (exp: ExpressionType) => any;
        /** All parameters for how to process data */
        data: NodeDataOptions;
        /** The data dependencies that were requested during the resolution */
        getDependencies?(scope?: "core" | "children"): Set<BindingInstance>;
        /** original node */
        node?: Node.Node;
    };
    type ResolverOptions = BaseOptions & {
        /** The data model to set or get data from */
        model: DataModelImpl<DataModelOptions>;
        /** A formatter function to call */
        format?: (binding: BindingInstance, value: any) => any;
        /**
         * A function to format a given value using a formatting reference.
         * The default behavior is the identity function.
         */
        formatValue?: (formatReference: Formatting.Reference, value: any) => any;
        /** An evaluator to execute an expression */
        evaluator: ExpressionEvaluator;
        /** A fn to parse a raw binding into a binding object */
        parseBinding: BindingFactory;
    };
    interface ResolvedNode {
        /** The original node */
        node: Node.Node;
        /** The data dependencies that were requested during the resolution */
        dependencies: Set<BindingInstance>;
        /** The final value */
        value: any;
    }
    type NodeTransformFunction = (node: Node.Node, options: NodeResolveOptions) => Node.Node | null;
    type NodeResolveFunction = (value: any, node: Node.Node, options: NodeResolveOptions) => any;
    interface Plugin {
        /** A transform function to migrate an AST to another AST */
        beforeResolve?: NodeTransformFunction;
        /** A function to transform an AST to a resolved value */
        resolve?: NodeResolveFunction;
        /** A function to process a resolved value before completing the node */
        afterResolve?: NodeResolveFunction;
    }
}
//# sourceMappingURL=types.d.ts.map