@react-typed-forms/schemas 15.2.0 → 16.0.0

package/lib/controlDefinition.d.ts

@@ -1,398 +0,0 @@
-import { SchemaValidator } from "./schemaValidator";
-import { FieldOption, SchemaDataNode, SchemaField, SchemaInterface, SchemaNode } from "./schemaField";
-import { EntityExpression } from "./entityExpression";
-/**
- * Interface representing the form context data.
- */
-export interface FormContextData {
-    option?: FieldOption;
-    optionSelected?: boolean;
-}
-/**
- * Interface representing the control data context.
- */
-export interface ControlDataContext {
-    schemaInterface: SchemaInterface;
-    dataNode: SchemaDataNode | undefined;
-    parentNode: SchemaDataNode;
-    formData: FormContextData;
-}
-/**
- * Represents any control definition.
- */
-export type AnyControlDefinition = DataControlDefinition | GroupedControlsDefinition | ActionControlDefinition | DisplayControlDefinition;
-/**
- * Represents a control definition.
- */
-export interface ControlDefinition {
-    type: string;
-    id?: string | null;
-    childRefId?: string | null;
-    title?: string | null;
-    styleClass?: string | null;
-    layoutClass?: string | null;
-    labelClass?: string | null;
-    dynamic?: DynamicProperty[] | null;
-    adornments?: ControlAdornment[] | null;
-    children?: ControlDefinition[] | null;
-}
-export declare enum ControlDefinitionType {
-    Data = "Data",
-    Group = "Group",
-    Display = "Display",
-    Action = "Action"
-}
-export interface DynamicProperty {
-    type: string;
-    expr: EntityExpression;
-}
-export declare enum DynamicPropertyType {
-    Visible = "Visible",
-    DefaultValue = "DefaultValue",
-    Readonly = "Readonly",
-    Disabled = "Disabled",
-    Display = "Display",
-    Style = "Style",
-    LayoutStyle = "LayoutStyle",
-    AllowedOptions = "AllowedOptions",
-    Label = "Label",
-    ActionData = "ActionData"
-}
-export interface ControlAdornment {
-    type: string;
-}
-export declare enum AdornmentPlacement {
-    ControlStart = "ControlStart",
-    ControlEnd = "ControlEnd",
-    LabelStart = "LabelStart",
-    LabelEnd = "LabelEnd"
-}
-export declare enum ControlAdornmentType {
-    Tooltip = "Tooltip",
-    Accordion = "Accordion",
-    HelpText = "HelpText",
-    Icon = "Icon",
-    SetField = "SetField",
-    Optional = "Optional"
-}
-export interface IconAdornment extends ControlAdornment {
-    type: ControlAdornmentType.Icon;
-    iconClass: string;
-    placement?: AdornmentPlacement | null;
-}
-export interface TooltipAdornment extends ControlAdornment {
-    type: ControlAdornmentType.Tooltip;
-    tooltip: string;
-}
-export interface AccordionAdornment extends ControlAdornment {
-    type: ControlAdornmentType.Accordion;
-    title: string;
-    defaultExpanded?: boolean | null;
-}
-export interface HelpTextAdornment extends ControlAdornment {
-    type: ControlAdornmentType.HelpText;
-    helpText: string;
-    placement?: AdornmentPlacement | null;
-}
-export interface SetFieldAdornment extends ControlAdornment {
-    type: ControlAdornmentType.SetField;
-    field: string;
-    defaultOnly?: boolean | null;
-    expression?: EntityExpression;
-}
-export interface OptionalAdornment extends ControlAdornment {
-    type: ControlAdornmentType.Optional;
-    placement?: AdornmentPlacement | null;
-    allowNull?: boolean;
-    editSelectable?: boolean;
-}
-export interface DataControlDefinition extends ControlDefinition {
-    type: ControlDefinitionType.Data;
-    field: string;
-    required?: boolean | null;
-    renderOptions?: RenderOptions | null;
-    defaultValue?: any;
-    readonly?: boolean | null;
-    disabled?: boolean | null;
-    validators?: SchemaValidator[] | null;
-    hideTitle?: boolean | null;
-    dontClearHidden?: boolean | null;
-}
-export interface RenderOptions {
-    type: string;
-}
-export declare enum DataRenderType {
-    Standard = "Standard",
-    Textfield = "Textfield",
-    Radio = "Radio",
-    HtmlEditor = "HtmlEditor",
-    IconList = "IconList",
-    CheckList = "CheckList",
-    UserSelection = "UserSelection",
-    Synchronised = "Synchronised",
-    IconSelector = "IconSelector",
-    DateTime = "DateTime",
-    Checkbox = "Checkbox",
-    Dropdown = "Dropdown",
-    DisplayOnly = "DisplayOnly",
-    Group = "Group",
-    NullToggle = "NullToggle",
-    Autocomplete = "Autocomplete",
-    Jsonata = "Jsonata",
-    Array = "Array",
-    ArrayElement = "ArrayElement"
-}
-export interface TextfieldRenderOptions extends RenderOptions {
-    type: DataRenderType.Textfield;
-    placeholder?: string | null;
-    multiline?: boolean | null;
-}
-export interface AutocompleteRenderOptions extends RenderOptions, AutocompleteClasses {
-    type: DataRenderType.Autocomplete;
-}
-export interface AutocompleteClasses {
-    listContainerClass?: string | null;
-    listEntryClass?: string | null;
-    chipContainerClass?: string | null;
-    chipCloseButtonClass?: string | null;
-    placeholder?: string | null;
-}
-export interface CheckEntryClasses {
-    entryWrapperClass?: string | null;
-    selectedClass?: string | null;
-    notSelectedClass?: string | null;
-}
-export interface RadioButtonRenderOptions extends RenderOptions, CheckEntryClasses {
-    type: DataRenderType.Radio;
-}
-export interface StandardRenderer extends RenderOptions {
-    type: DataRenderType.Standard;
-}
-export interface DataGroupRenderOptions extends RenderOptions {
-    type: DataRenderType.Group;
-    groupOptions?: GroupRenderOptions;
-}
-export interface HtmlEditorRenderOptions extends RenderOptions {
-    type: DataRenderType.HtmlEditor;
-    allowImages: boolean;
-}
-export interface DateTimeRenderOptions extends RenderOptions {
-    type: DataRenderType.DateTime;
-    format?: string | null;
-    forceMidnight?: boolean;
-    forceStandard?: boolean;
-}
-export interface IconListRenderOptions extends RenderOptions {
-    type: DataRenderType.IconList;
-    iconMappings: IconMapping[];
-}
-export interface DisplayOnlyRenderOptions extends RenderOptions {
-    type: DataRenderType.DisplayOnly;
-    emptyText?: string | null;
-    sampleText?: string | null;
-}
-export interface IconMapping {
-    value: string;
-    materialIcon?: string | null;
-}
-export interface JsonataRenderOptions extends RenderOptions {
-    type: DataRenderType.Jsonata;
-    expression: string;
-}
-export interface JsonataRenderOptions extends RenderOptions {
-    type: DataRenderType.Jsonata;
-    expression: string;
-}
-export interface ArrayRenderOptions extends RenderOptions {
-    type: DataRenderType.Array;
-    addText?: string | null;
-    addActionId?: string | null;
-    removeText?: string | null;
-    removeActionId?: string | null;
-    editText?: string | null;
-    editActionId?: string | null;
-    noAdd?: boolean | null;
-    noRemove?: boolean | null;
-    noReorder?: boolean | null;
-    childOptions?: RenderOptions | null;
-    editExternal?: boolean | null;
-}
-export interface ArrayElementRenderOptions extends RenderOptions {
-    type: DataRenderType.ArrayElement;
-    showInline?: boolean | null;
-}
-export type ArrayActionOptions = Pick<ArrayRenderOptions, "addText" | "addActionId" | "removeText" | "removeActionId" | "noAdd" | "noRemove" | "noReorder" | "editExternal" | "editActionId" | "editText"> & {
-    readonly?: boolean;
-    disabled?: boolean;
-    designMode?: boolean;
-};
-export interface CheckListRenderOptions extends RenderOptions, CheckEntryClasses {
-    type: DataRenderType.CheckList;
-}
-export interface SynchronisedRenderOptions extends RenderOptions {
-    type: DataRenderType.Synchronised;
-    fieldToSync: string;
-    syncType: SyncTextType;
-}
-export declare enum SyncTextType {
-    Camel = "Camel",
-    Snake = "Snake",
-    Pascal = "Pascal"
-}
-export interface UserSelectionRenderOptions extends RenderOptions {
-    type: DataRenderType.UserSelection;
-    noGroups: boolean;
-    noUsers: boolean;
-}
-export interface IconSelectionRenderOptions extends RenderOptions {
-    type: DataRenderType.IconSelector;
-}
-export interface GroupedControlsDefinition extends ControlDefinition {
-    type: ControlDefinitionType.Group;
-    compoundField?: string | null;
-    groupOptions?: GroupRenderOptions;
-}
-export interface GroupRenderOptions {
-    type: string;
-    hideTitle?: boolean | null;
-    childStyleClass?: string | null;
-    childLayoutClass?: string | null;
-    childLabelClass?: string | null;
-    displayOnly?: boolean | null;
-}
-export declare enum GroupRenderType {
-    Standard = "Standard",
-    Grid = "Grid",
-    Flex = "Flex",
-    Tabs = "Tabs",
-    GroupElement = "GroupElement",
-    SelectChild = "SelectChild"
-}
-export interface StandardGroupRenderer extends GroupRenderOptions {
-    type: GroupRenderType.Standard;
-}
-export interface FlexRenderer extends GroupRenderOptions {
-    type: GroupRenderType.Flex;
-    direction?: string | null;
-    gap?: string | null;
-}
-export interface GroupElementRenderer extends GroupRenderOptions {
-    type: GroupRenderType.GroupElement;
-    value: any;
-}
-export interface GridRenderer extends GroupRenderOptions {
-    type: GroupRenderType.Grid;
-    columns?: number | null;
-}
-export interface TabsRenderOptions extends GroupRenderOptions {
-    type: GroupRenderType.Tabs;
-    contentClass?: string;
-}
-export interface SelectChildRenderer extends GroupRenderOptions {
-    type: GroupRenderType.SelectChild;
-    childIndexExpression?: EntityExpression | null;
-}
-export interface DisplayControlDefinition extends ControlDefinition {
-    type: ControlDefinitionType.Display;
-    displayData: DisplayData;
-}
-export interface DisplayData {
-    type: string;
-}
-export declare enum DisplayDataType {
-    Text = "Text",
-    Html = "Html",
-    Icon = "Icon",
-    Custom = "Custom"
-}
-export interface TextDisplay extends DisplayData {
-    type: DisplayDataType.Text;
-    text: string;
-}
-export interface IconDisplay extends DisplayData {
-    type: DisplayDataType.Icon;
-    iconClass: string;
-}
-export interface HtmlDisplay extends DisplayData {
-    type: DisplayDataType.Html;
-    html: string;
-}
-export interface CustomDisplay extends DisplayData {
-    type: DisplayDataType.Custom;
-    customId: string;
-}
-export interface ActionControlDefinition extends ControlDefinition {
-    type: ControlDefinitionType.Action;
-    actionId: string;
-    actionData?: string | null;
-}
-export interface ControlVisitor<A> {
-    data(d: DataControlDefinition): A;
-    group(d: GroupedControlsDefinition): A;
-    display(d: DisplayControlDefinition): A;
-    action(d: ActionControlDefinition): A;
-}
-export declare function visitControlDefinition<A>(x: ControlDefinition, visitor: ControlVisitor<A>, defaultValue: (c: ControlDefinition) => A): A;
-export declare function isGridRenderer(options: GroupRenderOptions): options is GridRenderer;
-export declare function isSelectChildRenderer(options: GroupRenderOptions): options is SelectChildRenderer;
-export declare function isTabsRenderer(options: GroupRenderOptions): options is TabsRenderOptions;
-export declare function isFlexRenderer(options: GroupRenderOptions): options is FlexRenderer;
-export declare function isDisplayOnlyRenderer(options: RenderOptions): options is DisplayOnlyRenderOptions;
-export declare function isTextfieldRenderer(options: RenderOptions): options is TextfieldRenderOptions;
-export declare function isDateTimeRenderer(options: RenderOptions): options is DateTimeRenderOptions;
-export declare function isAutocompleteRenderer(options: RenderOptions): options is AutocompleteRenderOptions;
-export declare function isAutoCompleteClasses(options?: RenderOptions | null): options is AutocompleteClasses & RenderOptions;
-export declare function isDataGroupRenderer(options?: RenderOptions | null): options is DataGroupRenderOptions;
-export declare function isArrayRenderer(options: RenderOptions): options is ArrayRenderOptions;
-export declare function isDataControl(c: ControlDefinition): c is DataControlDefinition;
-export declare function isGroupControl(c: ControlDefinition): c is GroupedControlsDefinition;
-export declare function isActionControl(c: ControlDefinition): c is ActionControlDefinition;
-export declare function isDisplayControl(c: ControlDefinition): c is DisplayControlDefinition;
-export type ControlActionHandler = (actionId: string, actionData: any, ctx: ControlDataContext) => (() => void) | undefined;
-export declare function isCheckEntryClasses(options?: RenderOptions | null): options is CheckEntryClasses & RenderOptions;
-export type ControlMap = {
-    [k: string]: ControlDefinition;
-};
-export interface FormNode {
-    id: string;
-    definition: ControlDefinition;
-    tree: FormTree;
-    parent?: FormNode;
-    getChildNodes(): FormNode[];
-}
-export interface FormTreeLookup {
-    getForm(formId: string): FormTree | undefined;
-}
-export declare abstract class FormTree implements FormTreeLookup {
-    abstract rootNode: FormNode;
-    abstract getByRefId(id: string): FormNode | undefined;
-    abstract addChild(parent: FormNode, control: ControlDefinition): FormNode;
-    abstract getForm(formId: string): FormTree | undefined;
-    createTempNode(id: string, definition: ControlDefinition, children?: FormNode[], parent?: FormNode): FormNode;
-    createChildNodes(parent: FormNode, definitions: ControlDefinition[] | undefined | null): FormNode[];
-}
-export declare function legacyFormNode(definition: ControlDefinition): FormNode;
-export declare function createFormTree(controls: ControlDefinition[], getForm?: FormTreeLookup): FormTree;
-export declare function createFormLookup<A extends Record<string, ControlDefinition[]>>(formMap: A): {
-    getForm(formId: keyof A): FormTree;
-};
-export declare function fieldPathForDefinition(c: ControlDefinition): string[] | undefined;
-export declare function lookupDataNode(c: ControlDefinition, parentNode: SchemaDataNode): SchemaDataNode | undefined;
-export declare function traverseParents<A, B extends {
-    parent?: B | undefined;
-}>(current: B | undefined, get: (b: B) => A, until?: (b: B) => boolean): A[];
-export declare function getRootDataNode(dataNode: SchemaDataNode): SchemaDataNode;
-export declare function getJsonPath(dataNode: SchemaDataNode): (string | number)[];
-export declare function getSchemaPath(schemaNode: SchemaNode): SchemaField[];
-export declare function getSchemaFieldList(schema: SchemaNode): SchemaField[];
-/**
- * @deprecated use visitFormNodeData instead
- */
-export declare function visitControlDataArray<A>(controls: ControlDefinition[] | undefined | null, context: SchemaDataNode, cb: (definition: DataControlDefinition, node: SchemaDataNode) => A | undefined): A | undefined;
-/**
- * @deprecated use visitFormDataInContext instead
- */
-export declare function visitControlData<A>(definition: ControlDefinition, ctx: SchemaDataNode, cb: (definition: DataControlDefinition, field: SchemaDataNode) => A | undefined): A | undefined;
-export type ControlDataVisitor<A> = (dataNode: SchemaDataNode, definition: DataControlDefinition) => A | undefined;
-export declare function visitFormData<A>(node: FormNode, dataNode: SchemaDataNode, cb: ControlDataVisitor<A>, notSelf?: boolean): A | undefined;
-export declare function visitFormDataInContext<A>(parentContext: SchemaDataNode, node: FormNode, cb: ControlDataVisitor<A>): A | undefined;

package/lib/defaultSchemaInterface.d.ts

@@ -1,24 +0,0 @@
-import { Control, ControlSetup } from "@react-typed-forms/core";
-import { EqualityFunc, FieldOption, SchemaDataNode, SchemaField, SchemaInterface, SchemaNode, ValidationMessageType } from "./schemaField";
-export declare class DefaultSchemaInterface implements SchemaInterface {
-    protected boolStrings: [string, string];
-    protected parseDateTime: (s: string) => number;
-    constructor(boolStrings?: [string, string], parseDateTime?: (s: string) => number);
-    parseToMillis(field: SchemaField, v: string): number;
-    validationMessageText(field: SchemaField, messageType: ValidationMessageType, actual: any, expected: any): string;
-    getDataOptions(node: SchemaDataNode): FieldOption[] | null | undefined;
-    getNodeOptions(node: SchemaNode): FieldOption[] | null | undefined;
-    getOptions({ options }: SchemaField): FieldOption[] | null | undefined;
-    getFilterOptions(array: SchemaDataNode, field: SchemaNode): FieldOption[] | undefined | null;
-    isEmptyValue(f: SchemaField, value: any): boolean;
-    searchText(field: SchemaField, value: any): string;
-    textValue(field: SchemaField, value: any, element?: boolean | undefined): string | undefined;
-    controlLength(f: SchemaField, control: Control<any>): number;
-    valueLength(field: SchemaField, value: any): number;
-    compareValue(field: SchemaField, v1: unknown, v2: unknown): number;
-    compoundFieldSetup(f: SchemaNode): [string, ControlSetup<any>][];
-    compoundFieldEquality(f: SchemaNode): [string, EqualityFunc][];
-    makeEqualityFunc(field: SchemaNode, element?: boolean): EqualityFunc;
-    makeControlSetup(field: SchemaNode, element?: boolean): ControlSetup<any>;
-}
-export declare const defaultSchemaInterface: SchemaInterface;

package/lib/dynamicHooks.d.ts

@@ -1,54 +0,0 @@
-/**
- * Type representing a hook dependency, which can be a string, number, undefined, or null.
- */
-export type HookDep = string | number | undefined | null;
-/**
- * Interface representing a dynamic hook generator.
- * @template A - The type of the hook result.
- * @template P - The type of the hook context.
- */
-export interface DynamicHookGenerator<A, P> {
-    deps: HookDep;
-    state: any;
-    runHook(ctx: P, state: any): A;
-}
-/**
- * Creates a dynamic hook generator.
- * @template A - The type of the hook result.
- * @template P - The type of the hook context.
- * @template S - The type of the hook state.
- * @param runHook - The function to run the hook.
- * @param state - The initial state of the hook.
- * @param deps - The dependencies of the hook.
- * @returns The dynamic hook generator.
- */
-export declare function makeHook<A, P, S = undefined>(runHook: (ctx: P, state: S) => A, state: S, deps?: HookDep): DynamicHookGenerator<A, P>;
-/**
- * Type representing the value of a dynamic hook.
- * @template A - The type of the dynamic hook generator.
- */
-export type DynamicHookValue<A> = A extends DynamicHookGenerator<infer V, any> ? V : never;
-/**
- * Converts an array of dependencies to a dependency string.
- * @template A - The type of the dependencies.
- * @param deps - The array of dependencies.
- * @param asHookDep - The function to convert a dependency to a hook dependency.
- * @returns The dependency string.
- */
-export declare function makeHookDepString<A>(deps: A[], asHookDep: (a: A) => HookDep): string;
-/**
- * Custom hook to use dynamic hooks.
- * @template P - The type of the hook context.
- * @template Hooks - The type of the hooks.
- * @param hooks - The hooks to use.
- * @returns A function that takes the hook context and returns the hook values.
- */
-export declare function useDynamicHooks<P, Hooks extends Record<string, DynamicHookGenerator<any, P>>>(hooks: Hooks): (p: P) => {
-    [K in keyof Hooks]: DynamicHookValue<Hooks[K]>;
-};
-/**
- * Converts a value to a dependency string.
- * @param x - The value to convert.
- * @returns The dependency string.
- */
-export declare function toDepString(x: any): string;

package/lib/entityExpression.d.ts

@@ -1,32 +0,0 @@
-export interface EntityExpression {
-    type: string;
-}
-export declare enum ExpressionType {
-    Jsonata = "Jsonata",
-    Data = "Data",
-    DataMatch = "FieldValue",
-    UserMatch = "UserMatch",
-    NotEmpty = "NotEmpty",
-    UUID = "UUID"
-}
-export interface JsonataExpression extends EntityExpression {
-    type: ExpressionType.Jsonata;
-    expression: string;
-}
-export interface DataExpression extends EntityExpression {
-    type: ExpressionType.Data;
-    field: string;
-}
-export interface DataMatchExpression extends EntityExpression {
-    type: ExpressionType.DataMatch;
-    field: string;
-    value: any;
-}
-export interface NotEmptyExpression extends EntityExpression {
-    type: ExpressionType.DataMatch;
-    field: string;
-}
-export interface UserMatchExpression extends EntityExpression {
-    type: ExpressionType.UserMatch;
-    userMatch: string;
-}

package/lib/hooks.d.ts

@@ -1,28 +0,0 @@
-import { ControlDefinition, DynamicPropertyType, ControlDataContext } from "./controlDefinition";
-import React from "react";
-import { Control } from "@react-typed-forms/core";
-import { JsonPath } from "./util";
-import { DynamicHookGenerator } from "./dynamicHooks";
-import { SchemaDataNode, SchemaInterface } from "./schemaField";
-import { EntityExpression } from "./entityExpression";
-export type EvalExpressionHook<A = any> = DynamicHookGenerator<Control<A | undefined>, ControlDataContext>;
-export type UseEvalExpressionHook = (expr: EntityExpression | undefined | null, coerce: (v: any) => any) => DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
-export declare function optionalHook(expr: EntityExpression | undefined | null, useHook: UseEvalExpressionHook, coerce: (v: any) => any): DynamicHookGenerator<Control<any> | undefined, ControlDataContext> | undefined;
-export declare function useEvalVisibilityHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, overrideDataNode?: SchemaDataNode): EvalExpressionHook<boolean>;
-export declare function useEvalReadonlyHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<boolean>;
-export declare function useEvalStyleHook(useEvalExpressionHook: UseEvalExpressionHook, property: DynamicPropertyType, definition: ControlDefinition): EvalExpressionHook<React.CSSProperties>;
-export declare function useEvalAllowedOptionsHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<any[]>;
-export declare function useEvalDisabledHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<boolean>;
-export declare function useEvalDisplayHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): DynamicHookGenerator<Control<string | undefined> | undefined, ControlDataContext>;
-export declare function useEvalDefaultValueHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook;
-export declare function defaultEvalHooks(expr: EntityExpression, context: ControlDataContext, coerce: (v: any) => any): Control<any>;
-export declare const defaultUseEvalExpressionHook: UseEvalExpressionHook;
-export declare function makeEvalExpressionHook(f: (expr: EntityExpression, context: ControlDataContext, coerce: (v: any) => any) => Control<any>): UseEvalExpressionHook;
-export declare function useEvalDynamicBoolHook(definition: ControlDefinition, type: DynamicPropertyType, useEvalExpressionHook: UseEvalExpressionHook): DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
-export declare function useEvalDynamicHook<V>(definition: ControlDefinition, type: DynamicPropertyType, useEvalExpressionHook: UseEvalExpressionHook, coerce?: (v: any) => any): DynamicHookGenerator<Control<V> | undefined, ControlDataContext>;
-export declare function matchesType(context: SchemaDataNode): boolean;
-export declare function hideDisplayOnly(context: SchemaDataNode, schemaInterface: SchemaInterface, definition: ControlDefinition): boolean | undefined;
-export declare function useUuidExpression(coerce?: (v: any) => any): Control<any>;
-export declare function useJsonataExpression(jExpr: string, data: Control<any>, path: JsonPath[], bindings?: Control<Record<string, any>>, coerce?: (v: any) => any): Control<any>;
-export declare function useEvalActionHook(useExpr: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<string | null>;
-export declare function useEvalLabelText(useExpr: UseEvalExpressionHook, definition: ControlDefinition): EvalExpressionHook<string | null>;

package/lib/schemaBuilder.d.ts

@@ -1,67 +0,0 @@
-import { CompoundField, FieldOption, FieldType, SchemaField, SchemaMap } from "./schemaField";
-export type AllowedSchema<T> = T extends string ? SchemaField & {
-    type: FieldType.String | FieldType.Date | FieldType.DateTime | FieldType.Time;
-} : T extends number ? SchemaField & {
-    type: FieldType.Int | FieldType.Double;
-} : T extends boolean ? SchemaField & {
-    type: FieldType.Bool;
-} : T extends Array<infer E> ? AllowedSchema<E> & {
-    collection: true;
-} : T extends {
-    [key: string]: any;
-} ? CompoundField & {
-    type: FieldType.Compound;
-} : SchemaField & {
-    type: FieldType.Any;
-};
-type AllowedField<T, K> = (name: string) => (SchemaField & {
-    type: K;
-}) | AllowedSchema<T>;
-export declare function buildSchema<T, Custom = "">(def: {
-    [K in keyof T]-?: AllowedField<T[K], Custom>;
-}): SchemaField[];
-export type FieldBuilder<T extends FieldType, K> = (name: string) => Omit<SchemaField, "type"> & {
-    type: T;
-} & K;
-export declare function stringField(displayName: string): FieldBuilder<FieldType.String, {}>;
-export declare function stringField<S extends Partial<SchemaField>>(displayName: string, options: S): FieldBuilder<FieldType.String, S>;
-export declare function stringOptionsField(displayName: string, ...options: FieldOption[]): (name: string) => SchemaField & {
-    type: FieldType.String;
-    displayName: string;
-    options: FieldOption[];
-};
-export declare function withScalarOptions<S extends SchemaField, S2 extends Partial<SchemaField>>(options: S2, v: (name: string) => S): (name: string) => S & S2;
-export declare function makeScalarField<S extends Partial<SchemaField>>(options: S): (name: string) => SchemaField & S;
-export declare function makeCompoundField<S extends Partial<CompoundField>>(options: S): (name: string) => CompoundField & {
-    type: FieldType.Compound;
-} & S;
-export declare function intField(displayName: string): FieldBuilder<FieldType.Int, {}>;
-export declare function intField<S extends Partial<SchemaField>>(displayName: string, options: S): FieldBuilder<FieldType.Int, S>;
-export declare function doubleField(displayName: string): FieldBuilder<FieldType.Double, {}>;
-export declare function doubleField<S extends Partial<SchemaField>>(displayName: string, options: S): FieldBuilder<FieldType.Double, S>;
-export declare function dateField(displayName: string): FieldBuilder<FieldType.Date, {}>;
-export declare function dateField<S extends Partial<SchemaField>>(displayName: string, options: S): FieldBuilder<FieldType.Date, S>;
-export declare function timeField<S extends Partial<SchemaField>>(displayName: string, options?: S): (name: string) => SchemaField & {
-    type: FieldType.Time;
-    displayName: string;
-} & S;
-export declare function dateTimeField<S extends Partial<SchemaField>>(displayName: string, options?: S): (name: string) => SchemaField & {
-    type: FieldType.DateTime;
-    displayName: string;
-} & S;
-export declare function boolField(displayName: string): FieldBuilder<FieldType.Bool, {}>;
-export declare function boolField<S extends Partial<SchemaField>>(displayName: string, options: S): FieldBuilder<FieldType.Bool, S>;
-export declare function compoundField<Other extends Partial<Omit<CompoundField, "type" | "schemaType">>>(displayName: string, fields: SchemaField[], other?: Other): (name: string) => CompoundField & {
-    collection: Other["collection"];
-};
-export declare function defaultScalarField(field: string, displayName: string): Omit<SchemaField, "type"> & {
-    type: FieldType.String;
-};
-export declare function defaultCompoundField(field: string, displayName: string, collection: boolean): CompoundField & {
-    type: FieldType.Compound;
-};
-export declare function mergeField(field: SchemaField, mergeInto: SchemaField[]): SchemaField[];
-export declare function mergeFields(fields: SchemaField[], name: string, value: any, newFields: SchemaField[]): SchemaField[];
-export declare function addFieldOption(typeField: SchemaField, name: string, value: any): SchemaField;
-export declare function resolveSchemas<A extends SchemaMap>(schemaMap: A): A;
-export {};