@react-typed-forms/schemas 15.2.0 → 16.0.1

package/lib/RenderForm.d.ts

@@ -0,0 +1,39 @@
+import { ControlRenderOptions, ControlRenderProps, FormRenderer } from "./controlRender";
+import React, { FC } from "react";
+import { ControlDefinition, FormNode, JsonPath, SchemaDataNode, SchemaField } from "@astroapps/forms-core";
+import { Control } from "@react-typed-forms/core";
+export interface RenderFormProps {
+    data: SchemaDataNode;
+    form: FormNode;
+    renderer: FormRenderer;
+    options?: ControlRenderOptions;
+}
+export declare function RenderForm({ data, form, renderer, options, }: RenderFormProps): React.ReactNode;
+/**
+ * @deprecated Use RenderForm instead.
+ */
+export declare function useControlRendererComponent(controlOrFormNode: ControlDefinition | FormNode, renderer: FormRenderer, options: ControlRenderOptions | undefined, parentDataNode: SchemaDataNode): FC<{}>;
+/**
+ * @deprecated Use RenderForm instead.
+ */
+export declare function ControlRenderer({ definition, fields, renderer, options, control, parentPath, }: {
+    definition: ControlDefinition;
+    fields: SchemaField[];
+    renderer: FormRenderer;
+    options?: ControlRenderOptions;
+    control: Control<any>;
+    parentPath?: JsonPath[];
+}): JSX.Element;
+/**
+ * @deprecated Use RenderForm instead.
+ */
+export declare function NewControlRenderer({ definition, renderer, options, parentDataNode, }: {
+    definition: ControlDefinition | FormNode;
+    renderer: FormRenderer;
+    options?: ControlRenderOptions;
+    parentDataNode: SchemaDataNode;
+}): JSX.Element;
+/**
+ * @deprecated Use RenderForm instead.
+ */
+export declare function useControlRenderer(definition: ControlDefinition, fields: SchemaField[], renderer: FormRenderer, options?: ControlRenderOptions): FC<ControlRenderProps>;

package/lib/controlBuilder.d.ts

@@ -1,8 +1,5 @@
-import { AccordionAdornment, ActionControlDefinition, AutocompleteRenderOptions, CheckListRenderOptions, ControlAdornmentType, ControlDefinition, DataControlDefinition, DataRenderType, DisplayControlDefinition, DisplayOnlyRenderOptions, DynamicProperty, GroupedControlsDefinition, JsonataRenderOptions, RadioButtonRenderOptions, RenderOptions, TextfieldRenderOptions } from "./controlDefinition";
-import { ActionRendererProps } from "./controlRender";
-import { DateValidator, JsonataValidator, LengthValidator, ValidatorType } from "./schemaValidator";
-import { SchemaField, SchemaMap, SchemaNode } from "./schemaField";
-import { DataExpression, DataMatchExpression, EntityExpression, JsonataExpression } from "./entityExpression";
+import { AccordionAdornment, ActionControlDefinition, AutocompleteRenderOptions, CheckListRenderOptions, ControlAdornmentType, ControlDefinition, DataControlDefinition, DataExpression, DataMatchExpression, DataRenderType, DateValidator, DisplayControlDefinition, DisplayOnlyRenderOptions, DynamicProperty, EntityExpression, GroupedControlsDefinition, JsonataExpression, JsonataRenderOptions, JsonataValidator, LengthValidator, RadioButtonRenderOptions, RenderOptions, SchemaField, SchemaMap, SchemaNode, TextfieldRenderOptions, ValidatorType } from "@astroapps/forms-core";
+import { ActionRendererProps } from "./types";
 export declare function dataControl(field: string, title?: string | null, options?: Partial<DataControlDefinition>): DataControlDefinition;
 export declare function validatorOptions<A extends {
     type: string;
@@ -47,7 +44,7 @@ export declare function jsonataExpr(expression: string): JsonataExpression;
 export declare function groupedControl(children: ControlDefinition[], title?: string, options?: Partial<GroupedControlsDefinition>): GroupedControlsDefinition;
 export declare function compoundControl(field: string, title: string | undefined, children: ControlDefinition[], options?: Partial<DataControlDefinition>): DataControlDefinition;
 export declare function actionControl(actionText: string, actionId: string, options?: Partial<ActionControlDefinition>): ActionControlDefinition;
-export declare function createAction(actionId: string, onClick: () => void, actionText?: string, options?: Partial<ActionRendererProps>): ActionRendererProps;
+export declare function createAction(actionId: string, onClick: () => void, actionText?: string | null, options?: Partial<ActionRendererProps>): ActionRendererProps;
 export declare const emptyGroupDefinition: GroupedControlsDefinition;
 export declare function useControlDefinitionForSchema(sf: SchemaField[], definition?: GroupedControlsDefinition): GroupedControlsDefinition;
 export interface EditorGroup {

package/lib/controlRender.d.ts

@@ -1,20 +1,70 @@
-import React, { ButtonHTMLAttributes, ElementType, FC, HTMLAttributes, InputHTMLAttributes, Key, LabelHTMLAttributes, ReactElement, ReactNode } from "react";
+import React, { ComponentType, ElementType, HTMLAttributes, Key, ReactElement, ReactNode } from "react";
 import { Control } from "@react-typed-forms/core";
-import { AdornmentPlacement, ArrayActionOptions, ControlActionHandler, ControlAdornment, ControlDataContext, ControlDefinition, DataControlDefinition, DisplayData, FormContextData, FormNode, GroupRenderOptions, RenderOptions } from "./controlDefinition";
-import { ControlClasses, JsonPath } from "./util";
-import { EvalExpressionHook, UseEvalExpressionHook } from "./hooks";
-import { ValidationContext } from "./validators";
-import { SchemaValidator } from "./schemaValidator";
-import { FieldOption, SchemaDataNode, SchemaField, SchemaInterface } from "./schemaField";
+import { AdornmentPlacement, ArrayActionOptions, ControlAdornment, ControlDefinition, ControlState, DataControlDefinition, DisplayData, FieldOption, FormContextOptions, FormNode, FormState, GroupRenderOptions, JsonPath, RenderOptions, SchemaDataNode, SchemaField, SchemaInterface } from "@astroapps/forms-core";
+import { ControlClasses } from "./util";
+import { ActionRendererProps, ControlActionHandler, ControlDataContext, RunExpression } from "./types";
+export interface HtmlIconProperties {
+    className?: string;
+    style?: React.CSSProperties;
+    iconLibrary?: string;
+    iconName?: string;
+}
+export interface HtmlLabelProperties {
+    htmlFor?: string;
+    className?: string;
+    textClass?: string;
+    children?: ReactNode;
+}
+export interface HtmlDivProperties {
+    id?: string;
+    className?: string;
+    textClass?: string;
+    style?: React.CSSProperties;
+    children?: ReactNode;
+    text?: string;
+    html?: string;
+    nativeRef?: (e: HTMLElement | null) => void;
+    inline?: boolean;
+}
+export interface HtmlInputProperties {
+    id?: string;
+    className?: string;
+    textClass?: string;
+    name?: string;
+    type?: string;
+    checked?: boolean;
+    style?: React.CSSProperties;
+    readOnly?: boolean;
+    placeholder?: string;
+    value?: string | number;
+    onBlur?: () => void;
+    disabled?: boolean;
+    inputRef?: (e: HTMLElement | null) => void;
+    onChangeValue?: (value: string) => void;
+    onChangeChecked?: (checked: boolean) => void;
+}
+export interface HtmlButtonProperties {
+    className?: string;
+    textClass?: string;
+    disabled?: boolean;
+    style?: React.CSSProperties;
+    onClick?: () => void;
+    inline?: boolean;
+    children?: ReactNode;
+    title?: string;
+    notWrapInText?: boolean;
+    androidRippleColor?: string;
+    nonTextContent?: boolean;
+}
 export interface HtmlComponents {
-    Div: ElementType<HTMLAttributes<HTMLDivElement>, "div">;
+    Div: ComponentType<HtmlDivProperties>;
     Span: ElementType<HTMLAttributes<HTMLSpanElement>>;
-    Button: ElementType<ButtonHTMLAttributes<HTMLButtonElement>>;
-    I: ElementType<HTMLAttributes<HTMLElement>>;
-    Label: ElementType<LabelHTMLAttributes<HTMLLabelElement>>;
+    Button: ComponentType<HtmlButtonProperties>;
+    I: ComponentType<HtmlIconProperties>;
+    Label: ComponentType<HtmlLabelProperties>;
     B: ElementType<HTMLAttributes<HTMLElement>>;
     H1: ElementType<HTMLAttributes<HTMLElement>>;
-    Input: ElementType<InputHTMLAttributes<HTMLInputElement>, "input">;
+    Input: ComponentType<HtmlInputProperties>;
 }
 /**
  * Interface for rendering different types of form controls.
@@ -82,13 +132,12 @@ export interface FormRenderer {
      * @returns A React node.
      */
     renderLabelText: (props: ReactNode) => ReactNode;
-    renderText: (props: ReactNode, className?: string) => ReactNode;
     html: HtmlComponents;
 }
 export interface AdornmentProps {
     adornment: ControlAdornment;
     dataContext: ControlDataContext;
-    useExpr?: UseEvalExpressionHook;
+    runExpression?: RunExpression;
     designMode?: boolean;
     formOptions: FormContextOptions;
 }
@@ -127,12 +176,14 @@ export interface RenderedLayout {
     className?: string;
     style?: React.CSSProperties;
     wrapLayout: (layout: ReactElement) => ReactElement;
+    inline?: boolean;
 }
 export interface RenderedControl {
     children: ReactNode;
     className?: string;
     style?: React.CSSProperties;
     divRef?: (cb: HTMLElement | null) => void;
+    inline?: boolean;
 }
 export interface VisibilityRendererProps extends RenderedControl {
     visibility: Control<Visibility | undefined>;
@@ -145,6 +196,7 @@ export interface ControlLayoutProps {
     processLayout?: (props: ControlLayoutProps) => ControlLayoutProps;
     className?: string | null;
     style?: React.CSSProperties;
+    inline?: boolean;
 }
 /**
  * Enum representing the types of labels that can be rendered.
@@ -192,6 +244,10 @@ export interface LabelRendererProps {
      * The CSS class name for the label.
      */
     className?: string;
+    /**
+     * The CSS class name for the label text.
+     */
+    textClass?: string;
 }
 /**
  * Properties for display renderers.
@@ -213,21 +269,25 @@ export interface DisplayRendererProps {
      * The CSS class name for the display renderer.
      */
     className?: string;
+    textClass?: string;
     /**
      * The CSS styles for the display renderer.
      */
     style?: React.CSSProperties;
+    inline?: boolean;
 }
-export type ChildVisibilityFunc = (child: ControlDefinition, parentNode?: SchemaDataNode, dontOverride?: boolean) => EvalExpressionHook<boolean>;
 export interface ParentRendererProps {
     formNode: FormNode;
+    state: ControlState;
     renderChild: ChildRenderer;
     className?: string;
+    textClass?: string;
     style?: React.CSSProperties;
     dataContext: ControlDataContext;
-    useChildVisibility: ChildVisibilityFunc;
-    useEvalExpression: UseEvalExpressionHook;
+    getChildState(node: FormNode, parent?: SchemaDataNode): ControlState;
+    runExpression: RunExpression;
     designMode?: boolean;
+    actionOnClick?: ControlActionHandler;
 }
 export interface GroupRendererProps extends ParentRendererProps {
     definition: ControlDefinition;
@@ -237,7 +297,6 @@ export interface DataRendererProps extends ParentRendererProps {
     renderOptions: RenderOptions;
     definition: DataControlDefinition;
     field: SchemaField;
-    elementIndex?: number;
     id: string;
     control: Control<any>;
     readonly: boolean;
@@ -246,109 +305,69 @@ export interface DataRendererProps extends ParentRendererProps {
     hidden: boolean;
     dataNode: SchemaDataNode;
     displayOnly: boolean;
-}
-export interface ActionRendererProps {
-    actionId: string;
-    actionText: string;
-    actionData?: any;
-    onClick: () => void;
-    className?: string | null;
-    style?: React.CSSProperties;
-    disabled?: boolean;
+    inline: boolean;
 }
 export interface ControlRenderProps {
     control: Control<any>;
     parentPath?: JsonPath[];
 }
-export interface FormContextOptions {
-    readonly?: boolean | null;
-    hidden?: boolean | null;
-    disabled?: boolean | null;
-    displayOnly?: boolean;
-}
-export interface DataControlProps {
-    formNode: FormNode;
-    definition: DataControlDefinition;
-    dataContext: ControlDataContext;
-    control: Control<any>;
-    formOptions: FormContextOptions;
-    style?: React.CSSProperties | undefined;
-    renderChild: ChildRenderer;
-    elementIndex?: number;
-    allowedOptions?: Control<any[] | undefined>;
-    useChildVisibility: ChildVisibilityFunc;
-    useEvalExpression: UseEvalExpressionHook;
-    schemaInterface?: SchemaInterface;
-    designMode?: boolean;
-    styleClass?: string;
-    layoutClass?: string;
-}
-export type CreateDataProps = (controlProps: DataControlProps) => DataRendererProps;
-export interface ControlRenderOptions extends FormContextOptions, ControlClasses {
+export type CreateDataProps = (controlProps: RenderLayoutProps, definition: DataControlDefinition, control: Control<any>) => DataRendererProps;
+export interface ControlRenderOptions extends ControlClasses {
+    formState?: FormState;
     useDataHook?: (c: ControlDefinition) => CreateDataProps;
     actionOnClick?: ControlActionHandler;
     customDisplay?: (customId: string, displayProps: DisplayRendererProps) => ReactNode;
-    useValidationHook?: (validator: SchemaValidator, ctx: ValidationContext) => void;
-    useEvalExpressionHook?: UseEvalExpressionHook;
     adjustLayout?: (context: ControlDataContext, layout: ControlLayoutProps) => ControlLayoutProps;
+    readonly?: boolean | null;
+    hidden?: boolean | null;
+    disabled?: boolean | null;
+    displayOnly?: boolean;
+    inline?: boolean;
     clearHidden?: boolean;
+    stateKey?: string;
     schemaInterface?: SchemaInterface;
-    elementIndex?: number;
-    formData?: FormContextData;
+    variables?: Record<string, any>;
 }
-export declare function useControlRenderer(definition: ControlDefinition, fields: SchemaField[], renderer: FormRenderer, options?: ControlRenderOptions): FC<ControlRenderProps>;
-export declare function useControlRendererComponent(controlOrFormNode: ControlDefinition | FormNode, renderer: FormRenderer, options: ControlRenderOptions | undefined, parentDataNode: SchemaDataNode): FC<{}>;
-export declare function ControlRenderer({ definition, fields, renderer, options, control, parentPath, }: {
-    definition: ControlDefinition;
-    fields: SchemaField[];
-    renderer: FormRenderer;
-    options?: ControlRenderOptions;
-    control: Control<any>;
-    parentPath?: JsonPath[];
-}): JSX.Element;
-export declare function NewControlRenderer({ definition, renderer, options, parentDataNode, }: {
-    definition: ControlDefinition | FormNode;
-    renderer: FormRenderer;
-    options?: ControlRenderOptions;
-    parentDataNode: SchemaDataNode;
-}): JSX.Element;
-export declare function defaultDataProps({ definition, control, formOptions, style, allowedOptions, schemaInterface, styleClass, ...props }: DataControlProps): DataRendererProps;
+export declare function defaultDataProps({ formOptions, style, allowedOptions, schemaInterface, styleClass, textClass: tc, displayOnly, inline, ...props }: RenderLayoutProps, definition: DataControlDefinition, control: Control<any>): DataRendererProps;
 export interface ChildRendererOptions {
-    elementIndex?: number;
     parentDataNode?: SchemaDataNode;
-    formData?: FormContextData;
+    inline?: boolean;
     displayOnly?: boolean;
     styleClass?: string;
     layoutClass?: string;
     labelClass?: string;
+    labelTextClass?: string;
+    actionOnClick?: ControlActionHandler;
+    stateKey?: string;
+    variables?: Record<string, any>;
 }
 export type ChildRenderer = (k: Key, child: FormNode, options?: ChildRendererOptions) => ReactNode;
-export interface RenderControlProps {
-    definition: ControlDefinition;
+export interface RenderLayoutProps {
     formNode: FormNode;
     renderer: FormRenderer;
+    state: ControlState;
     renderChild: ChildRenderer;
     createDataProps: CreateDataProps;
     formOptions: FormContextOptions;
     dataContext: ControlDataContext;
     control?: Control<any>;
-    labelText?: Control<string | null | undefined>;
-    elementIndex?: number;
-    displayControl?: Control<string | undefined>;
     style?: React.CSSProperties;
-    allowedOptions?: Control<any[] | undefined>;
-    actionDataControl?: Control<any | undefined | null>;
-    useChildVisibility: ChildVisibilityFunc;
-    useEvalExpression: UseEvalExpressionHook;
+    allowedOptions?: any[];
+    getChildState(node: FormNode, parent?: SchemaDataNode): ControlState;
+    runExpression: RunExpression;
     actionOnClick?: ControlActionHandler;
     schemaInterface?: SchemaInterface;
     designMode?: boolean;
     customDisplay?: (customId: string, displayProps: DisplayRendererProps) => ReactNode;
     labelClass?: string;
+    labelTextClass?: string;
     styleClass?: string;
+    textClass?: string;
+    inline?: boolean;
+    displayOnly?: boolean;
 }
-export declare function renderControlLayout(props: RenderControlProps): ControlLayoutProps;
-type MarkupKeys = keyof Omit<RenderedLayout, "errorControl" | "style" | "className" | "wrapLayout" | "readonly" | "disabled">;
+export declare function renderControlLayout(props: RenderLayoutProps): ControlLayoutProps;
+type MarkupKeys = keyof Omit<RenderedLayout, "errorControl" | "style" | "className" | "wrapLayout" | "readonly" | "disabled" | "inline">;
 export declare function appendMarkup(k: MarkupKeys, markup: ReactNode): (layout: RenderedLayout) => void;
 export declare function wrapMarkup(k: MarkupKeys, wrap: (ex: ReactNode) => ReactNode): (layout: RenderedLayout) => void;
 export declare function layoutKeyForPlacement(pos: AdornmentPlacement): MarkupKeys;
@@ -366,5 +385,6 @@ export declare function applyArrayLengthRestrictions({ arrayControl, min, max, e
     addDisabled: boolean;
     removeDisabled: boolean;
 };
-export declare function fieldOptionAdornment(p: DataRendererProps): (o: FieldOption, i: number, selected: boolean) => JSX.Element;
+export declare function fieldOptionAdornment(p: DataRendererProps): (o: FieldOption, fieldIndex: number, selected: boolean) => JSX.Element;
+export declare function lookupChildDataContext(dataContext: ControlDataContext, c: ControlDefinition): ControlDataContext;
 export {};