@player-tools/dsl 0.0.2-next.0

package/dist/index.d.ts

@@ -0,0 +1,324 @@
+import React$1, { PropsWithChildren } from 'react';
+import { PropertyNode, ObjectNode, JsonNode, JsonType } from 'react-json-reconciler';
+export * from 'react-json-reconciler';
+import { Asset as Asset$1, Navigation as Navigation$1, Expression, Schema, Flow } from '@player-ui/types';
+import { SyncWaterfallHook, SyncHook } from 'tapable-ts';
+
+declare type TemplateInstanceRefStringContext = 'binding' | 'expression';
+interface TemplateRefStringOptions {
+    /** If this template string is inside of another binding or expression */
+    nestedContext?: TemplateInstanceRefStringContext;
+}
+interface TemplateInstanceRefStringOptions {
+    /** The array of strings for the template */
+    strings: TemplateStringsArray;
+    /** the other data that's present in the template */
+    other: Array<string | TemplateStringType>;
+    /** If this template string is inside of another binding or expression */
+    nestedContext?: TemplateInstanceRefStringContext;
+    /** Convert the value to a reference nested in the given context */
+    toRefString: (options: TemplateRefStringOptions | undefined, value: string) => string;
+}
+declare const OpaqueIdentifier: unique symbol;
+declare type TemplateStringType = React$1.ReactElement & {
+    /** An identifier to show that this is a template type */
+    [OpaqueIdentifier]: true;
+    /** The value of the template string when in another string */
+    toString: () => string;
+    /** the raw value of the template string */
+    toValue: () => string;
+    /** the dereferenced value when used in another */
+    toRefString: (options?: TemplateRefStringOptions) => string;
+};
+declare type BindingTemplateInstance = TemplateStringType & {
+    /** An identifier for a binding instance */
+    __type: 'binding';
+};
+declare type ExpressionTemplateInstance = TemplateStringType & {
+    /** The identifier for an expression instance */
+    __type: 'expression';
+};
+/** A react component for rendering a template string type */
+declare const TemplateStringComponent: (props: {
+    /** The string value of the child template string */
+    value: string;
+}) => React$1.ReactElement<{
+    value: string;
+}, string | React$1.JSXElementConstructor<any>>;
+/** A tagged-template constructor for a binding  */
+declare const binding: (strings: TemplateStringsArray, ...nested: Array<TemplateStringType | string>) => BindingTemplateInstance;
+/** A tagged-template constructor for an expression */
+declare const expression: (strings: TemplateStringsArray, ...nested: Array<ExpressionTemplateInstance | BindingTemplateInstance | string>) => ExpressionTemplateInstance;
+/** Check if a value is a template string */
+declare const isTemplateStringInstance: (val: unknown) => val is BindingTemplateInstance | ExpressionTemplateInstance;
+
+declare type WithChildren<T = Record<string, unknown>> = T & {
+    /** child nodes */
+    children?: React.ReactNode;
+};
+declare type RemoveUnknownIndex<T> = {
+    [P in keyof T as T[P] extends unknown ? unknown extends T[P] ? never : P : P]: T[P];
+};
+declare type AddUnknownIndex<T> = T & {
+    [key: string]: unknown;
+};
+/** Make an ID prop optional an a type */
+declare type OmitProp<T, K extends string> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+};
+interface PlayerApplicability {
+    /** An expression to evaluate to determine if this node should appear in a view or not */
+    applicability?: BindingTemplateInstance | ExpressionTemplateInstance | boolean;
+}
+declare type AssetPropsWithChildren<T extends Asset$1> = WithChildren<WithTemplateTypes<OmitProp<RemoveUnknownIndex<T>, 'id' | 'type'> & Partial<Pick<Asset$1, 'id'>>> & PlayerApplicability>;
+declare type SwapKeysToType<T, K extends keyof T, NewType> = {
+    [P in keyof T]: P extends K ? NewType : T[P];
+};
+declare type WithTemplateTypes<T> = T extends Record<any, any> ? {
+    [P in keyof T]: WithTemplateTypes<T[P]>;
+} : T | BindingTemplateInstance | ExpressionTemplateInstance;
+declare type ValidKeys = 'exp' | 'onStart' | 'onEnd';
+declare type DeepReplace<T, Old, New> = {
+    [P in keyof T]: T[P] extends Old ? P extends ValidKeys ? New : DeepReplace<T[P], Old, New> : T[P] extends (infer R)[] ? DeepReplace<R, Old, New>[] : T[P] extends object ? DeepReplace<T[P], Old, New> : Extract<T[P], Old> extends Old ? DeepReplace<Extract<T[P], object>, Old, New> | Exclude<T[P], Old | object> | New : T[P];
+};
+declare type Navigation = DeepReplace<Navigation$1, Expression, ExpressionTemplateInstance | ExpressionTemplateInstance[] | Expression>;
+
+declare const SlotContext: React$1.Context<{
+    /** The property name for the slot */
+    propertyName: string;
+    /** If the slot represents an array */
+    isArray: boolean;
+    /** If the items in the slot should be wrapped in an "asset" object */
+    wrapInAsset: boolean;
+    /** Other props to add to the slot */
+    additionalProperties?: any;
+    /** The ref to the property node */
+    ref: React$1.RefObject<PropertyNode>;
+    /** A text component if we hit a string but expect an asset */
+    TextComp?: React$1.ComponentType<{}> | undefined;
+    /** A component to create a collection asset is we get an array but need a single element */
+    CollectionComp?: React$1.ComponentType<{}> | undefined;
+} | undefined>;
+/**
+ * Wraps the children in an `asset` object.
+ * Additional props are added to the top level object
+ */
+declare const AssetWrapper: React$1.ForwardRefExoticComponent<Pick<WithChildren<{
+    [key: string]: any;
+}>, string | number> & React$1.RefAttributes<ObjectNode>>;
+/** Create a ID property for a node */
+declare const GeneratedIDProperty: (props: {
+    /** the id to use if supplied by the user */
+    id?: string;
+}) => JSX.Element;
+/** An asset */
+declare const Asset: React$1.ForwardRefExoticComponent<Pick<{
+    [key: string]: unknown;
+    /** id of the asset */
+    id?: string | undefined;
+    /** the asset type */
+    type: string;
+    /** Any other properties on the asset */
+    children?: React$1.ReactNode;
+} & PlayerApplicability, string | number> & React$1.RefAttributes<ObjectNode>>;
+/** A component to generate a named property slot */
+declare const Slot: (props: {
+    /** The name of the slot */
+    name: string;
+    /** if the slot is an array or single object */
+    isArray?: boolean;
+    /** if each item should be wrapped in an asset */
+    wrapInAsset?: boolean;
+    /** Any children to render in the slot */
+    children?: React$1.ReactNode;
+    /** Other properties to add to the slot */
+    additionalProperties?: any;
+    /** A text component if we hit a string but expect an asset */
+    TextComp?: React$1.ComponentType;
+    /** A component to create a collection asset is we get an array but need a single element */
+    CollectionComp?: React$1.ComponentType;
+}) => JSX.Element;
+/** Create a slot for a given property */
+declare function createSlot<SlotProps = unknown>(options: {
+    /** The name of the slot */
+    name: string;
+    /** if the slot is an array or single object */
+    isArray?: boolean;
+    /** if each item should be wrapped in an asset */
+    wrapInAsset?: boolean;
+    /** Any children to render in the slot */
+    children?: React$1.ReactNode;
+    /** A text component if we hit a string but expect an asset */
+    TextComp?: React$1.ComponentType;
+    /** A component to create a collection asset is we get an array but need a single element */
+    CollectionComp?: React$1.ComponentType;
+}): (props: {
+    /** An object to include in this property */
+    children?: React$1.ReactNode;
+} & SlotProps) => JSX.Element;
+
+declare const IndexSuffixStopContext: React$1.Context<boolean>;
+/** Get the generated id */
+declare const useGetIdPrefix: () => string;
+/** Add a suffix to a generated id */
+declare const IDSuffixProvider: (props: WithChildren<{
+    /** The suffix to append */
+    suffix: string;
+}>) => JSX.Element;
+/** Override the generated id with the supplied one */
+declare const IDProvider: (props: WithChildren<{
+    /** The new id to use  */
+    id?: string;
+}>) => JSX.Element;
+/** Get the index of an item in a slot */
+declare const useIndexInSlot: (ref: React$1.RefObject<JsonNode>) => number;
+/** Add the index to the id path when in an array slot */
+declare const IDSuffixIndexProvider: (props: WithChildren<{
+    /** The ref to use */
+    wrapperRef: React$1.RefObject<JsonNode>;
+    /** if the suffix is in a template, the id to use */
+    templateIndex?: string;
+}>) => JSX.Element;
+/** Wrap a slot with the index if in an array slot */
+declare const OptionalIDSuffixProvider: (props: WithChildren<{
+    /** The ref to walk upwards and use as an index */
+    wrapperRef: React$1.RefObject<JsonNode>;
+    /** if the suffix is in a template, the id to use */
+    templateIndex?: string;
+}>) => JSX.Element;
+
+/** Get an array version of the value */
+declare function toArray<T>(val: T | Array<T>): Array<T>;
+/** Create a component version  */
+declare function toJsonElement(value: any, index?: number): React$1.ReactElement;
+/** Create a fragment for the properties */
+declare function toJsonProperties(value: Record<string, any>): JSX.Element[];
+/** Create a text asset if needed */
+declare function normalizeText(options: {
+    /** The current node */
+    node: React$1.ReactNode;
+    /** A component to render a text asset */
+    TextComp?: React$1.ComponentType;
+}): React$1.ReactNode;
+/** Create a collection if needed */
+declare function normalizeToCollection(options: {
+    /** the node to look at */
+    node: React$1.ReactNode;
+    /** A Text asset */
+    TextComp?: React$1.ComponentType;
+    /** A collection asset */
+    CollectionComp?: React$1.ComponentType;
+}): React$1.ReactNode;
+
+interface SwitchProps {
+    /** defaults to a staticSwitch */
+    isDynamic?: boolean;
+}
+/**
+ * Switches allow users to fork content between 1 or more assets
+ */
+declare const Switch: {
+    (props: PropsWithChildren<SwitchProps>): JSX.Element;
+    Case: (props: PropsWithChildren<CaseProps>) => JSX.Element;
+};
+interface CaseProps {
+    /** the test for this case statement */
+    exp?: ExpressionTemplateInstance | BindingTemplateInstance | boolean;
+}
+
+interface TemplateContextType {
+    /** The number of nested templates */
+    depth: number;
+}
+declare const TemplateContext: React$1.Context<TemplateContextType>;
+interface TemplateProps {
+    /** The source binding */
+    data: BindingTemplateInstance;
+    /** The target property */
+    output?: string;
+    /** The template value */
+    children: React$1.ReactNode;
+}
+/** A template allows users to dynamically map over an array of data */
+declare const Template: (props: TemplateProps) => JSX.Element;
+
+declare const SchemaTypeName: unique symbol;
+/**
+ * Generator for `Schema.Schema` Objects
+ */
+declare class SchemaGenerator {
+    private children;
+    private generatedDataTypeNames;
+    hooks: {
+        createSchemaNode: SyncWaterfallHook<[node: Schema.DataType<unknown>, originalProperty: Record<string | symbol, unknown>], Record<string, any>>;
+    };
+    constructor();
+    /**
+     * Converts an object to a `Schema.Schema` representation
+     * Note: uses iteration to prevent potentially very deep recursion on large objects
+     */
+    toSchema: (schema: any) => Schema.Schema;
+    /**
+     * Processes the children of an object Node
+     * Newly discovered children get added to the provided array
+     */
+    private processChildren;
+    /**
+     * Make an intermediate `Schema.DataType` object given a name
+     */
+    private makePlaceholderType;
+    /**
+     * Make an intermediate `Schema.DataType` object with array support given a name
+     */
+    private makePlaceholderArrayType;
+}
+declare type MakeArrayIntoIndexRef<T extends any[]> = {
+    [key: number]: MakeBindingRefable<T[0]>;
+    /** Used when referencing bindings from within a template */
+    _index_: MakeBindingRefable<T[0]>;
+} & BindingTemplateInstance;
+declare type MakeBindingRefable<T> = {
+    [P in keyof T]: T[P] extends any[] ? MakeArrayIntoIndexRef<T[P]> : MakeBindingRefable<T[P]>;
+} & BindingTemplateInstance;
+/**
+ * Adds bindings to an object so that the object can be directly used in JSX
+ */
+declare function makeBindingsForObject<Type>(obj: Type, arrayAccessorKeys?: string[]): MakeBindingRefable<Type>;
+/**
+ * Generates binding for an object property
+ */
+declare const getBindingFromObject: (obj: any) => BindingTemplateInstance;
+/**
+ * Returns the binding string from an object path
+ */
+declare const getBindingStringFromObject: (obj: any) => string;
+/**
+ * Returns the ref string from an object path
+ */
+declare const getRefStringFromObject: (obj: any) => string;
+
+declare type FlowWithoutUnknown = RemoveUnknownIndex<Flow>;
+declare type FlowWithReactViews = AddUnknownIndex<Omit<FlowWithoutUnknown, 'views'> & {
+    /** An array of JSX view elements */
+    views?: Array<React.ReactElement>;
+}>;
+declare type SerializeType = 'view' | 'flow' | 'schema' | 'navigation';
+declare type SerializablePlayerExportTypes = React.ReactElement | FlowWithReactViews | Schema.Schema | Navigation$1;
+
+/** A compiler for transforming DSL content into JSON */
+declare class DSLCompiler {
+    hooks: {
+        schemaGenerator: SyncHook<[SchemaGenerator], Record<string, any>>;
+    };
+    /** Convert an object (flow, view, schema, etc) into it's JSON representation */
+    serialize(value: unknown): Promise<{
+        /** the JSON value of the source */
+        value: JsonType | undefined;
+        /** the fingerprinted content type of the source */
+        contentType: SerializeType;
+        /** The sourcemap of the content */
+        sourceMap?: string;
+    }>;
+}
+
+export { AddUnknownIndex, Asset, AssetPropsWithChildren, AssetWrapper, BindingTemplateInstance, CaseProps, DSLCompiler, ExpressionTemplateInstance, FlowWithReactViews, FlowWithoutUnknown, GeneratedIDProperty, IDProvider, IDSuffixIndexProvider, IDSuffixProvider, IndexSuffixStopContext, MakeArrayIntoIndexRef, MakeBindingRefable, Navigation, OmitProp, OptionalIDSuffixProvider, PlayerApplicability, RemoveUnknownIndex, SchemaGenerator, SchemaTypeName, SerializablePlayerExportTypes, SerializeType, Slot, SlotContext, SwapKeysToType, Switch, SwitchProps, Template, TemplateContext, TemplateContextType, TemplateInstanceRefStringContext, TemplateInstanceRefStringOptions, TemplateProps, TemplateRefStringOptions, TemplateStringComponent, TemplateStringType, WithChildren, WithTemplateTypes, binding, createSlot, expression, getBindingFromObject, getBindingStringFromObject, getRefStringFromObject, isTemplateStringInstance, makeBindingsForObject, normalizeText, normalizeToCollection, toArray, toJsonElement, toJsonProperties, useGetIdPrefix, useIndexInSlot };