@react-typed-forms/schemas 9.1.1 → 10.0.0

package/lib/components/ControlInput.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { Control } from "@react-typed-forms/core";
+export declare function ControlInput({ control, convert, ...props }: React.InputHTMLAttributes<HTMLInputElement> & {
+    control: Control<any>;
+    convert: InputConversion;
+}): React.JSX.Element;
+type InputConversion = [string, (s: any) => any, (a: any) => string | number];
+export declare function createInputConversion(ft: string): InputConversion;
+export {};

package/lib/components/DefaultArrayRenderer.d.ts

@@ -0,0 +1,16 @@
+import { ArrayRendererRegistration } from "../renderers";
+import { ActionRendererProps, ArrayRendererProps } from "../controlRender";
+import React, { ReactNode } from "react";
+export interface DefaultArrayRendererOptions {
+    className?: string;
+    removableClass?: string;
+    childClass?: string;
+    removableChildClass?: string;
+    removeActionClass?: string;
+    addActionClass?: string;
+}
+export declare function createDefaultArrayRenderer(options?: DefaultArrayRendererOptions): ArrayRendererRegistration;
+export interface DefaultArrayRendererProps extends DefaultArrayRendererOptions, ArrayRendererProps {
+    renderAction: (props: ActionRendererProps) => ReactNode;
+}
+export declare function DefaultArrayRenderer(props: DefaultArrayRendererProps): React.JSX.Element;

package/lib/components/DefaultDisplay.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { DisplayRendererProps } from "../controlRender";
+import { DisplayRendererRegistration } from "../renderers";
+export interface DefaultDisplayRendererOptions {
+    textClassName?: string;
+    htmlClassName?: string;
+}
+export declare function createDefaultDisplayRenderer(options?: DefaultDisplayRendererOptions): DisplayRendererRegistration;
+export declare function DefaultDisplay({ data, display, className, style, ...options }: DefaultDisplayRendererOptions & DisplayRendererProps): React.JSX.Element;

package/lib/components/DefaultDisplayOnly.d.ts

@@ -0,0 +1,11 @@
+import { Control } from "@react-typed-forms/core";
+import { SchemaField, SchemaInterface } from "../types";
+import React from "react";
+export declare function DefaultDisplayOnly({ control, className, emptyText, schemaInterface, field, style, }: {
+    control: Control<any>;
+    field: SchemaField;
+    schemaInterface: SchemaInterface;
+    className?: string;
+    style?: React.CSSProperties;
+    emptyText?: string | null;
+}): React.JSX.Element;

package/lib/components/DefaultLayout.d.ts

@@ -0,0 +1,9 @@
+import { RenderedLayout } from "../controlRender";
+import React from "react";
+export interface DefaultLayoutRendererOptions {
+    className?: string;
+    errorClass?: string;
+}
+export declare function DefaultLayout({ errorClass, layout: { controlEnd, controlStart, label, children, errorControl }, }: DefaultLayoutRendererOptions & {
+    layout: RenderedLayout;
+}): React.JSX.Element;

package/lib/components/DefaultVisibility.d.ts

@@ -0,0 +1,4 @@
+import { VisibilityRendererProps } from "../controlRender";
+import React from "react";
+export declare function createDefaultVisibilityRenderer(): import("../renderers").VisibilityRendererRegistration;
+export declare function DefaultVisibility({ visibility, children, className, style, divRef, }: VisibilityRendererProps): React.JSX.Element;

package/lib/components/RadioRenderer.d.ts

@@ -0,0 +1,20 @@
+import { Control } from "@react-typed-forms/core";
+import React from "react";
+import { FieldOption } from "../types";
+export interface RadioRendererOptions {
+    className?: string;
+    entryClass?: string;
+    radioClass?: string;
+    labelClass?: string;
+}
+export declare function createRadioRenderer(options?: RadioRendererOptions): import("../renderers").DataRendererRegistration;
+export declare function RadioButtons({ control, options, labelClass, radioClass, readonly, entryClass, className, id, }: {
+    id?: string;
+    className?: string;
+    options?: FieldOption[] | null;
+    control: Control<any>;
+    entryClass?: string;
+    radioClass?: string;
+    labelClass?: string;
+    readonly?: boolean;
+}): React.JSX.Element;

package/lib/components/SelectDataRenderer.d.ts

@@ -0,0 +1,24 @@
+import { Control } from "@react-typed-forms/core";
+import React from "react";
+import { FieldOption } from "../types";
+export interface SelectRendererOptions {
+    className?: string;
+    emptyText?: string;
+    requiredText?: string;
+}
+export declare function createSelectRenderer(options?: SelectRendererOptions): import("../renderers").DataRendererRegistration;
+type SelectConversion = (a: any) => string | number;
+export interface SelectDataRendererProps {
+    id?: string;
+    className?: string;
+    options: FieldOption[];
+    emptyText?: string;
+    requiredText?: string;
+    readonly: boolean;
+    required: boolean;
+    state: Control<any>;
+    convert: SelectConversion;
+}
+export declare function SelectDataRenderer({ state, options, className, convert, required, emptyText, requiredText, readonly, ...props }: SelectDataRendererProps): React.JSX.Element;
+export declare function createSelectConversion(ft: string): SelectConversion;
+export {};

package/lib/controlRender.d.ts

@@ -1,7 +1,7 @@
 import React, { CSSProperties, FC, Key, ReactNode } from "react";
 import { Control } from "@react-typed-forms/core";
 import { AdornmentPlacement, ControlAdornment, ControlDefinition, DataControlDefinition, DisplayData, FieldOption, GroupRenderOptions, RenderOptions, SchemaField, SchemaInterface } from "./types";
-import { ControlDataContext } from "./util";
+import { ControlDataContext, JsonPath } from "./util";
 import { EvalExpressionHook, UseEvalExpressionHook } from "./hooks";
 export interface FormRenderer {
     renderData: (props: DataRendererProps) => (layout: ControlLayoutProps) => ControlLayoutProps;
@@ -28,12 +28,12 @@ export interface ArrayRendererProps {
     addAction?: ActionRendererProps;
     required: boolean;
     removeAction?: (elemIndex: number) => ActionRendererProps;
-    elementCount: number;
     renderElement: (elemIndex: number) => ReactNode;
-    elementKey: (elemIndex: number) => Key;
     arrayControl: Control<any[] | undefined | null>;
     className?: string;
     style?: React.CSSProperties;
+    min?: number | null;
+    max?: number | null;
 }
 export interface Visibility {
     visible: boolean;
@@ -87,20 +87,25 @@ export interface DisplayRendererProps {
     className?: string;
     style?: React.CSSProperties;
 }
+export type ChildVisibilityFunc = (child: ControlDefinition, context?: ControlDataContext) => EvalExpressionHook<boolean>;
 export interface ParentRendererProps {
     childDefinitions: ControlDefinition[];
     renderChild: ChildRenderer;
     className?: string;
     style?: React.CSSProperties;
     dataContext: ControlDataContext;
-    useChildVisibility: (child: number | number[]) => EvalExpressionHook<boolean>;
+    parentContext: ControlDataContext;
+    useChildVisibility: ChildVisibilityFunc;
 }
 export interface GroupRendererProps extends ParentRendererProps {
+    definition: ControlDefinition;
     renderOptions: GroupRenderOptions;
 }
 export interface DataRendererProps extends ParentRendererProps {
     renderOptions: RenderOptions;
+    definition: DataControlDefinition;
     field: SchemaField;
+    elementIndex?: number;
     id: string;
     control: Control<any>;
     readonly: boolean;
@@ -129,29 +134,26 @@ export interface DataControlProps {
     definition: DataControlDefinition;
     field: SchemaField;
     dataContext: ControlDataContext;
+    parentContext: ControlDataContext;
     control: Control<any>;
-    options: FormContextOptions;
-    style: React.CSSProperties | undefined;
+    formOptions: FormContextOptions;
+    style?: React.CSSProperties | undefined;
     renderChild: ChildRenderer;
+    elementIndex?: number;
     allowedOptions?: Control<any[] | undefined>;
-    elementRenderer?: (elemIndex: number) => ReactNode;
-    useChildVisibility: (child: number | number[]) => EvalExpressionHook<boolean>;
+    useChildVisibility: ChildVisibilityFunc;
 }
 export type CreateDataProps = (controlProps: DataControlProps) => DataRendererProps;
-export type JsonPath = string | number;
-export interface DataContext {
-    data: Control<any>;
-    path: JsonPath[];
-}
 export interface ControlRenderOptions extends FormContextOptions {
     useDataHook?: (c: ControlDefinition) => CreateDataProps;
     useEvalExpressionHook?: UseEvalExpressionHook;
     clearHidden?: boolean;
     schemaInterface?: SchemaInterface;
+    elementIndex?: number;
 }
 export declare function useControlRenderer(definition: ControlDefinition, fields: SchemaField[], renderer: FormRenderer, options?: ControlRenderOptions): FC<ControlRenderProps>;
 export declare function lookupSchemaField(c: ControlDefinition, fields: SchemaField[]): SchemaField | undefined;
-export declare function getControlData(schemaField: SchemaField | undefined, parentContext: ControlDataContext): [Control<any> | undefined, Control<any> | undefined, ControlDataContext];
+export declare function getControlData(schemaField: SchemaField | undefined, parentContext: ControlDataContext, elementIndex: number | undefined): [Control<any> | undefined, Control<any> | undefined, ControlDataContext];
 export declare function ControlRenderer({ definition, fields, renderer, options, control, parentPath, }: {
     definition: ControlDefinition;
     fields: SchemaField[];
@@ -160,9 +162,13 @@ export declare function ControlRenderer({ definition, fields, renderer, options,
     control: Control<any>;
     parentPath?: JsonPath[];
 }): React.JSX.Element;
-export declare function defaultDataProps({ definition, field, control, options, elementRenderer, style, allowedOptions, ...props }: DataControlProps): DataRendererProps;
-export declare function defaultArrayProps(arrayControl: Control<any[] | undefined | null>, field: SchemaField, required: boolean, style: CSSProperties | undefined, className: string | undefined, renderElement: (elemIndex: number) => ReactNode): ArrayRendererProps;
-export type ChildRenderer = (k: Key, child: number | number[], parentPath?: JsonPath[]) => ReactNode;
+export declare function defaultDataProps({ definition, field, control, formOptions, style, allowedOptions, ...props }: DataControlProps): DataRendererProps;
+export declare function defaultArrayProps(arrayControl: Control<any[] | undefined | null>, field: SchemaField, required: boolean, style: CSSProperties | undefined, className: string | undefined, renderElement: (elemIndex: number) => ReactNode, min: number | undefined | null, max: number | undefined | null): ArrayRendererProps;
+export interface ChildRendererOptions {
+    elementIndex?: number;
+    dataContext?: ControlDataContext;
+}
+export type ChildRenderer = (k: Key, child: ControlDefinition, options?: ChildRendererOptions) => ReactNode;
 export interface RenderControlProps {
     definition: ControlDefinition;
     renderer: FormRenderer;
@@ -170,15 +176,17 @@ export interface RenderControlProps {
     createDataProps: CreateDataProps;
     formOptions: FormContextOptions;
     dataContext: ControlDataContext;
+    parentContext: ControlDataContext;
     control?: Control<any>;
     labelText?: Control<string | null | undefined>;
-    schemaField?: SchemaField;
+    field?: SchemaField;
+    elementIndex?: number;
     displayControl?: Control<string | undefined>;
     style?: React.CSSProperties;
     allowedOptions?: Control<any[] | undefined>;
-    useChildVisibility: (child: number | number[]) => EvalExpressionHook<boolean>;
+    useChildVisibility: ChildVisibilityFunc;
 }
-export declare function renderControlLayout({ definition: c, renderer, renderChild: childRenderer, control: childControl, schemaField, dataContext, formOptions: dataOptions, createDataProps: dataProps, displayControl, style, labelText, allowedOptions, useChildVisibility, }: RenderControlProps): ControlLayoutProps;
+export declare function renderControlLayout(props: RenderControlProps): ControlLayoutProps;
 export declare function appendMarkup(k: keyof Omit<RenderedLayout, "errorControl" | "style" | "className">, markup: ReactNode): (layout: RenderedLayout) => void;
 export declare function wrapMarkup(k: keyof Omit<RenderedLayout, "errorControl" | "style" | "className">, wrap: (ex: ReactNode) => ReactNode): (layout: RenderedLayout) => void;
 export declare function layoutKeyForPlacement(pos: AdornmentPlacement): keyof Omit<RenderedLayout, "errorControl" | "style" | "className">;
@@ -186,3 +194,7 @@ export declare function appendMarkupAt(pos: AdornmentPlacement, markup: ReactNod
 export declare function wrapMarkupAt(pos: AdornmentPlacement, wrap: (ex: ReactNode) => ReactNode): (layout: RenderedLayout) => void;
 export declare function renderLayoutParts(props: ControlLayoutProps, renderer: FormRenderer): RenderedLayout;
 export declare function controlTitle(title: string | undefined | null, field: SchemaField): string;
+export declare function applyArrayLengthRestrictions({ arrayControl, min, max, addAction: aa, removeAction: ra, required, }: Pick<ArrayRendererProps, "addAction" | "removeAction" | "arrayControl" | "min" | "max" | "required">, disable?: boolean): Pick<ArrayRendererProps, "addAction" | "removeAction"> & {
+    addDisabled: boolean;
+    removeDisabled: boolean;
+};

package/lib/createDefaultRenderers.d.ts

@@ -0,0 +1,59 @@
+import { DefaultDisplayRendererOptions } from "./components/DefaultDisplay";
+import { DefaultLayoutRendererOptions } from "./components/DefaultLayout";
+import { ActionRendererRegistration, AdornmentRendererRegistration, DataRendererRegistration, DefaultRenderers, GroupRendererRegistration, LabelRendererRegistration } from "./renderers";
+import { CSSProperties, ReactElement, ReactNode } from "react";
+import { FieldOption, GridRenderer } from "./types";
+import { SelectRendererOptions } from "./components/SelectDataRenderer";
+import { RadioRendererOptions } from "./components/RadioRenderer";
+import { DefaultArrayRendererOptions } from "./components/DefaultArrayRenderer";
+export interface DefaultRendererOptions {
+    data?: DefaultDataRendererOptions;
+    display?: DefaultDisplayRendererOptions;
+    action?: DefaultActionRendererOptions;
+    array?: DefaultArrayRendererOptions;
+    group?: DefaultGroupRendererOptions;
+    label?: DefaultLabelRendererOptions;
+    adornment?: DefaultAdornmentRendererOptions;
+    layout?: DefaultLayoutRendererOptions;
+}
+interface StyleProps {
+    className?: string;
+    style?: CSSProperties;
+}
+interface DefaultActionRendererOptions {
+    className?: string;
+}
+export declare function createDefaultActionRenderer(options?: DefaultActionRendererOptions): ActionRendererRegistration;
+interface DefaultGroupRendererOptions {
+    className?: string;
+    standardClassName?: string;
+    gridStyles?: (columns: GridRenderer) => StyleProps;
+    gridClassName?: string;
+    defaultGridColumns?: number;
+    flexClassName?: string;
+    defaultFlexGap?: string;
+}
+export declare function createDefaultGroupRenderer(options?: DefaultGroupRendererOptions): GroupRendererRegistration;
+export declare const DefaultBoolOptions: FieldOption[];
+interface DefaultDataRendererOptions {
+    inputClass?: string;
+    displayOnlyClass?: string;
+    selectOptions?: SelectRendererOptions;
+    radioOptions?: RadioRendererOptions;
+    booleanOptions?: FieldOption[];
+    optionRenderer?: DataRendererRegistration;
+}
+export declare function createDefaultDataRenderer(options?: DefaultDataRendererOptions): DataRendererRegistration;
+export interface DefaultAdornmentRendererOptions {
+}
+export declare function createDefaultAdornmentRenderer(options?: DefaultAdornmentRendererOptions): AdornmentRendererRegistration;
+interface DefaultLabelRendererOptions {
+    className?: string;
+    groupLabelClass?: string;
+    controlLabelClass?: string;
+    requiredElement?: ReactNode;
+    labelContainer?: (children: ReactElement) => ReactElement;
+}
+export declare function createDefaultLabelRenderer(options?: DefaultLabelRendererOptions): LabelRendererRegistration;
+export declare function createDefaultRenderers(options?: DefaultRendererOptions): DefaultRenderers;
+export {};

package/lib/createFormRenderer.d.ts

@@ -0,0 +1,3 @@
+import { FormRenderer } from "./controlRender";
+import { DefaultRenderers, RendererRegistration } from "./renderers";
+export declare function createFormRenderer(customRenderers?: RendererRegistration[], defaultRenderers?: DefaultRenderers): FormRenderer;

package/lib/hooks.d.ts

@@ -1,8 +1,7 @@
 import { ControlDefinition, DynamicPropertyType, EntityExpression, SchemaField, SchemaInterface } from "./types";
 import React from "react";
 import { Control } from "@react-typed-forms/core";
-import { ControlDataContext, DynamicHookGenerator } from "./util";
-import { DataContext } from "./controlRender";
+import { ControlDataContext, DataContext, DynamicHookGenerator } from "./util";
 export type EvalExpressionHook<A = any> = DynamicHookGenerator<Control<A | undefined>, ControlDataContext>;
 export type UseEvalExpressionHook = (expr: EntityExpression | undefined) => DynamicHookGenerator<Control<any> | undefined, ControlDataContext>;
 export declare function useEvalVisibilityHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, schemaField?: SchemaField): EvalExpressionHook<boolean>;
@@ -11,7 +10,7 @@ export declare function useEvalStyleHook(useEvalExpressionHook: UseEvalExpressio
 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, schemaField?: SchemaField): EvalExpressionHook;
+export declare function useEvalDefaultValueHook(useEvalExpressionHook: UseEvalExpressionHook, definition: ControlDefinition, schemaField: SchemaField | undefined, element: boolean): EvalExpressionHook;
 export declare function defaultEvalHooks(expr: EntityExpression, context: ControlDataContext): Control<any>;
 export declare const defaultUseEvalExpressionHook: UseEvalExpressionHook;
 export declare function makeEvalExpressionHook(f: (expr: EntityExpression, context: ControlDataContext) => Control<any>): UseEvalExpressionHook;

package/lib/index.d.ts

@@ -8,3 +8,12 @@ export * from "./tailwind";
 export * from "./validators";
 export * from "./hooks";
 export * from "./schemaInterface";
+export * from "./createDefaultRenderers";
+export * from "./createFormRenderer";
+export * from "./components/DefaultDisplay";
+export * from "./components/ControlInput";
+export * from "./components/SelectDataRenderer";
+export * from "./components/RadioRenderer";
+export * from "./components/DefaultLayout";
+export * from "./components/DefaultDisplayOnly";
+export * from "./components/DefaultVisibility";