@react-typed-forms/schemas 13.3.0 → 13.4.0

package/lib/controlBuilder.d.ts

@@ -1,6 +1,8 @@
-import { AccordionAdornment, CheckListRenderOptions, ControlAdornmentType, ControlDefinition, DataControlDefinition, DataExpression, DataMatchExpression, DataRenderType, DateValidator, DisplayControlDefinition, DisplayOnlyRenderOptions, DynamicProperty, EntityExpression, GroupedControlsDefinition, JsonataExpression, JsonataRenderOptions, JsonataValidator, LengthValidator, RadioButtonRenderOptions, RenderOptions, SchemaField, SchemaMap, TextfieldRenderOptions, ValidatorType } from "./types";
+import { AccordionAdornment, ActionControlDefinition, CheckListRenderOptions, ControlAdornmentType, ControlDefinition, DataControlDefinition, DataRenderType, DisplayControlDefinition, DisplayOnlyRenderOptions, DynamicProperty, GroupedControlsDefinition, JsonataRenderOptions, RadioButtonRenderOptions, RenderOptions, TextfieldRenderOptions } from "./controlDefinition";
 import { ActionRendererProps } from "./controlRender";
-import { ActionControlDefinition } from "./types";
+import { DateValidator, JsonataValidator, LengthValidator, ValidatorType } from "./schemaValidator";
+import { SchemaField, SchemaMap } from "./schemaField";
+import { DataExpression, DataMatchExpression, EntityExpression, JsonataExpression } from "./entityExpression";
 export declare function dataControl(field: string, title?: string | null, options?: Partial<DataControlDefinition>): DataControlDefinition;
 export declare function validatorOptions<A extends {
     type: string;

package/lib/{types.d.ts → controlDefinition.d.ts}

@@ -1,75 +1,29 @@
-import { Control } from "@react-typed-forms/core";
-import { SchemaDataNode, SchemaNode } from "./treeNodes";
-import { ControlDataContext } from "./util";
-export interface SchemaField {
-    type: string;
-    field: string;
-    displayName?: string | null;
-    tags?: string[] | null;
-    system?: boolean | null;
-    collection?: boolean | null;
-    onlyForTypes?: string[] | null;
-    required?: boolean | null;
-    notNullable?: boolean | null;
-    defaultValue?: any;
-    isTypeField?: boolean | null;
-    searchable?: boolean | null;
-    options?: FieldOption[] | null;
-    validators?: SchemaValidator[] | null;
-}
-export type SchemaMap = Record<string, SchemaField[]>;
-export declare enum FieldType {
-    String = "String",
-    Bool = "Bool",
-    Int = "Int",
-    Date = "Date",
-    DateTime = "DateTime",
-    Time = "Time",
-    Double = "Double",
-    EntityRef = "EntityRef",
-    Compound = "Compound",
-    AutoId = "AutoId",
-    Image = "Image",
-    Any = "Any"
-}
-export interface EntityRefField extends SchemaField {
-    type: FieldType.EntityRef;
-    entityRefType: string;
-    parentField: string;
-}
-export interface FieldOption {
-    name: string;
-    value: any;
-    description?: string | null;
-    group?: string | null;
-    disabled?: boolean | null;
-}
-export interface CompoundField extends SchemaField {
-    type: FieldType.Compound;
-    children: SchemaField[];
-    treeChildren?: boolean;
-    schemaRef?: string;
-}
+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;
-export declare enum ValidationMessageType {
-    NotEmpty = "NotEmpty",
-    MinLength = "MinLength",
-    MaxLength = "MaxLength",
-    NotAfterDate = "NotAfterDate",
-    NotBeforeDate = "NotBeforeDate"
-}
-export interface SchemaInterface {
-    isEmptyValue(field: SchemaField, value: any): boolean;
-    textValue(field: SchemaField, value: any, element?: boolean): string | undefined;
-    controlLength(field: SchemaField, control: Control<any>): number;
-    valueLength(field: SchemaField, value: any): number;
-    getOptions(field: SchemaField): FieldOption[] | undefined | null;
-    getFilterOptions(array: SchemaDataNode, field: SchemaNode): FieldOption[] | undefined | null;
-    parseToMillis(field: SchemaField, v: string): number;
-    validationMessageText(field: SchemaField, messageType: ValidationMessageType, actual: any, expected: any): string;
-    compareValue(field: SchemaField, v1: unknown, v2: unknown): number;
-    searchText(field: SchemaField, value: any): string;
-}
+/**
+ * Represents a control definition.
+ */
 export interface ControlDefinition {
     type: string;
     title?: string | null;
@@ -102,38 +56,6 @@ export declare enum DynamicPropertyType {
     Label = "Label",
     ActionData = "ActionData"
 }
-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;
-}
 export interface ControlAdornment {
     type: string;
 }
@@ -370,33 +292,6 @@ export interface ActionControlDefinition extends ControlDefinition {
     actionId: string;
     actionData?: string | null;
 }
-export declare enum ValidatorType {
-    Jsonata = "Jsonata",
-    Date = "Date",
-    Length = "Length"
-}
-export interface SchemaValidator {
-    type: string;
-}
-export interface JsonataValidator extends SchemaValidator {
-    type: ValidatorType.Jsonata;
-    expression: string;
-}
-export interface LengthValidator extends SchemaValidator {
-    type: ValidatorType.Length;
-    min?: number | null;
-    max?: number | null;
-}
-export declare enum DateComparison {
-    NotBefore = "NotBefore",
-    NotAfter = "NotAfter"
-}
-export interface DateValidator extends SchemaValidator {
-    type: ValidatorType.Date;
-    comparison: DateComparison;
-    fixedDate?: string | null;
-    daysFromCurrent?: number | null;
-}
 export declare function isDataControlDefinition(x: ControlDefinition): x is DataControlDefinition;
 export declare function isGroupControlsDefinition(x: ControlDefinition): x is GroupedControlsDefinition;
 export declare function isDisplayControlsDefinition(x: ControlDefinition): x is DisplayControlDefinition;
@@ -415,10 +310,30 @@ export declare function isDisplayOnlyRenderer(options: RenderOptions): options i
 export declare function isTextfieldRenderer(options: RenderOptions): options is TextfieldRenderOptions;
 export declare function isDataGroupRenderer(options?: RenderOptions | null): options is DataGroupRenderOptions;
 export declare function isArrayRenderer(options: RenderOptions): options is ArrayRenderOptions;
-export declare function findField(fields: SchemaField[], field: string): SchemaField | undefined;
-export declare function isScalarField(sf: SchemaField): sf is SchemaField;
-export declare function isCompoundField(sf: SchemaField): sf is CompoundField;
 export declare function isDataControl(c: ControlDefinition): c is DataControlDefinition;
 export declare function isGroupControl(c: ControlDefinition): c is GroupedControlsDefinition;
 export type ControlActionHandler = (actionId: string, actionData: any, ctx: ControlDataContext) => (() => void) | undefined;
 export declare function isCheckEntryClasses(options?: RenderOptions | null): options is CheckEntryClasses & RenderOptions;
+export interface FormNode {
+    definition: ControlDefinition;
+    getChildNodes(): FormNode[];
+    parent?: FormNode;
+}
+export interface FormTreeLookup<A = string> {
+    getForm(formId: A): FormTreeNode | undefined;
+}
+export interface FormTreeNode extends FormTreeLookup {
+    rootNode: FormNode;
+}
+export declare function createFormLookup<A extends Record<string, ControlDefinition[]>>(formMap: A): FormTreeLookup<keyof A>;
+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[];
+export declare function visitControlDataArray<A>(controls: ControlDefinition[] | undefined | null, context: SchemaDataNode, cb: (definition: DataControlDefinition, node: SchemaDataNode) => A | undefined): A | undefined;
+export declare function visitControlData<A>(definition: ControlDefinition, ctx: SchemaDataNode, cb: (definition: DataControlDefinition, field: SchemaDataNode) => A | undefined): A | undefined;

package/lib/controlRender.d.ts

@@ -1,20 +1,76 @@
 import React, { FC, Key, ReactElement, ReactNode } from "react";
 import { Control } from "@react-typed-forms/core";
-import { AdornmentPlacement, ArrayActionOptions, ControlActionHandler, ControlAdornment, ControlDefinition, DataControlDefinition, DisplayData, FieldOption, GroupRenderOptions, RenderOptions, SchemaField, SchemaInterface, SchemaValidator } from "./types";
-import { ControlClasses, ControlDataContext, FormContextData, JsonPath } from "./util";
+import { AdornmentPlacement, ArrayActionOptions, ControlActionHandler, ControlAdornment, ControlDefinition, DataControlDefinition, DisplayData, GroupRenderOptions, RenderOptions, ControlDataContext, FormContextData } from "./controlDefinition";
+import { ControlClasses, JsonPath } from "./util";
 import { EvalExpressionHook, UseEvalExpressionHook } from "./hooks";
 import { ValidationContext } from "./validators";
-import { SchemaDataNode } from "./treeNodes";
+import { SchemaValidator } from "./schemaValidator";
+import { FieldOption, SchemaDataNode, SchemaField, SchemaInterface } from "./schemaField";
+/**
+ * Interface for rendering different types of form controls.
+ */
 export interface FormRenderer {
+    /**
+     * Renders data control.
+     * @param props - Properties for data renderer.
+     * @returns A function that takes layout properties and returns layout properties.
+     */
     renderData: (props: DataRendererProps) => (layout: ControlLayoutProps) => ControlLayoutProps;
+    /**
+     * Renders group control.
+     * @param props - Properties for group renderer.
+     * @returns A function that takes layout properties and returns layout properties.
+     */
     renderGroup: (props: GroupRendererProps) => (layout: ControlLayoutProps) => ControlLayoutProps;
+    /**
+     * Renders display control.
+     * @param props - Properties for display renderer.
+     * @returns A React node.
+     */
     renderDisplay: (props: DisplayRendererProps) => ReactNode;
+    /**
+     * Renders action control.
+     * @param props - Properties for action renderer.
+     * @returns A React node.
+     */
     renderAction: (props: ActionRendererProps) => ReactNode;
+    /**
+     * Renders array control.
+     * @param props - Properties for array renderer.
+     * @returns A React node.
+     */
     renderArray: (props: ArrayRendererProps) => ReactNode;
+    /**
+     * Renders adornment.
+     * @param props - Properties for adornment renderer.
+     * @returns An adornment renderer.
+     */
     renderAdornment: (props: AdornmentProps) => AdornmentRenderer;
+    /**
+     * Renders label.
+     * @param props - Properties for label renderer.
+     * @param labelStart - React node to render at the start of the label.
+     * @param labelEnd - React node to render at the end of the label.
+     * @returns A React node.
+     */
     renderLabel: (props: LabelRendererProps, labelStart: ReactNode, labelEnd: ReactNode) => ReactNode;
+    /**
+     * Renders layout.
+     * @param props - Properties for control layout.
+     * @returns A rendered control.
+     */
     renderLayout: (props: ControlLayoutProps) => RenderedControl;
+    /**
+     * Renders visibility control.
+     * @param props - Properties for visibility renderer.
+     * @returns A React node.
+     */
     renderVisibility: (props: VisibilityRendererProps) => ReactNode;
+    /**
+     * Renders label text.
+     * @param props - React node for label text.
+     * @returns A React node.
+     */
     renderLabelText: (props: ReactNode) => ReactNode;
 }
 export interface AdornmentProps {
@@ -76,24 +132,76 @@ export interface ControlLayoutProps {
     className?: string | null;
     style?: React.CSSProperties;
 }
+/**
+ * Enum representing the types of labels that can be rendered.
+ */
 export declare enum LabelType {
+    /**
+     * Label for a control.
+     */
     Control = 0,
+    /**
+     * Label for a group.
+     */
     Group = 1,
+    /**
+     * Label for text.
+     */
     Text = 2
 }
+/**
+ * Properties for label renderers.
+ */
 export interface LabelRendererProps {
+    /**
+     * The type of the label.
+     */
     type: LabelType;
+    /**
+     * Whether to hide the label.
+     */
     hide?: boolean | null;
+    /**
+     * The content of the label.
+     */
     label: ReactNode;
+    /**
+     * Whether to show the label as being required.
+     * E.g. show an asterisk next to the label.
+     */
     required?: boolean | null;
+    /**
+     * The ID of the element the label is for.
+     */
     forId?: string;
+    /**
+     * The CSS class name for the label.
+     */
     className?: string;
 }
+/**
+ * Properties for display renderers.
+ */
 export interface DisplayRendererProps {
+    /**
+     * The data to be displayed.
+     */
     data: DisplayData;
+    /**
+     * A control with dynamic value for display.
+     */
     display?: Control<string | undefined>;
+    /**
+     * The context for the control data.
+     */
     dataContext: ControlDataContext;
+    /**
+     * The CSS class name for the display renderer.
+     */
     className?: string;
+    /**
+     * The CSS styles for the display renderer.
+     */
     style?: React.CSSProperties;
 }
 export type ChildVisibilityFunc = (child: ControlDefinition, parentNode?: SchemaDataNode, dontOverride?: boolean) => EvalExpressionHook<boolean>;

package/lib/{schemaInterface.d.ts → defaultSchemaInterface.d.ts}

@@ -1,6 +1,5 @@
-import { FieldOption, SchemaField, SchemaInterface, ValidationMessageType } from "./types";
 import { Control } from "@react-typed-forms/core";
-import { SchemaDataNode, SchemaNode } from "./treeNodes";
+import { FieldOption, SchemaDataNode, SchemaField, SchemaInterface, SchemaNode, ValidationMessageType } from "./schemaField";
 export declare class DefaultSchemaInterface implements SchemaInterface {
     protected boolStrings: [string, string];
     protected parseDateTime: (s: string) => number;

package/lib/dynamicHooks.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,32 @@
+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,8 +1,10 @@
-import { ControlDefinition, DynamicPropertyType, EntityExpression, SchemaInterface } from "./types";
+import { ControlDefinition, DynamicPropertyType, ControlDataContext } from "./controlDefinition";
 import React from "react";
 import { Control } from "@react-typed-forms/core";
-import { ControlDataContext, DynamicHookGenerator, JsonPath } from "./util";
-import { SchemaDataNode } from "./treeNodes";
+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 useEvalVisibilityHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, overrideDataNode?: SchemaDataNode): EvalExpressionHook<boolean>;