@react-typed-forms/schemas 3.0.0-dev.99 → 4.1.0

package/lib/schemaBuilder.d.ts

@@ -1,107 +1,90 @@
-import { CompoundField, FieldOption, FieldType, ScalarField, SchemaField, SchemaFieldType } from "./types";
-type AllowedSchema<T> = T extends string ? ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
+import { CompoundField, FieldOption, FieldType, SchemaField } from "./types";
+type AllowedSchema<T> = T extends string ? SchemaField & {
     type: FieldType.String | FieldType.Date | FieldType.DateTime;
-} : T extends number ? ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
+} : T extends number ? SchemaField & {
     type: FieldType.Int | FieldType.Double;
-} : T extends boolean ? ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
+} : T extends boolean ? SchemaField & {
     type: FieldType.Bool;
 } : T extends Array<infer E> ? AllowedSchema<E> & {
     collection: true;
 } : T extends {
     [key: string]: any;
 } ? CompoundField & {
-    schemaType: SchemaFieldType.Compound;
     type: FieldType.Compound;
-} : never;
-type AllowedField<T> = (name: string) => AllowedSchema<T>;
-export declare function buildSchema<T>(def: {
-    [K in keyof T]-?: AllowedField<T[K]>;
+} : 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 declare function stringField(displayName: string, options?: Partial<Omit<ScalarField, "schemaType" | "type">>): (name: string) => ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
-} & {
+export declare function stringField(displayName: string, options?: Partial<Omit<SchemaField, "type">>): (name: string) => SchemaField & {
     field?: string | undefined;
-    displayName: string;
-    tags?: string[] | undefined;
-    system?: boolean | undefined;
-    collection?: boolean | undefined;
-    onlyForTypes?: string[] | undefined;
-    required?: boolean | undefined;
-    entityRefType?: string | undefined;
-    parentField?: string | undefined;
-    searchable?: boolean | undefined;
+    displayName: string | null;
+    tags?: string[] | null | undefined;
+    system?: boolean | null | undefined;
+    collection?: boolean | null | undefined;
+    onlyForTypes?: string[] | null | undefined;
+    required?: boolean | null | undefined;
+    notNullable?: boolean | null | undefined;
     defaultValue?: any;
-    isTypeField?: boolean | undefined;
-    restrictions?: import("./types").SchemaRestrictions | undefined;
+    isTypeField?: boolean | null | undefined;
+    searchable?: boolean | null | undefined;
+    options?: FieldOption[] | null | undefined;
+    validators?: import("./types").SchemaValidator[] | null | undefined;
     type: FieldType.String;
 };
-export declare function stringOptionsField(displayName: string, ...options: FieldOption[]): (name: string) => ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
-} & {
+export declare function stringOptionsField(displayName: string, ...options: FieldOption[]): (name: string) => SchemaField & {
     type: FieldType.String;
     displayName: string;
-    restrictions: {
-        options: FieldOption[];
-    };
+    options: FieldOption[];
 };
-export declare function withScalarOptions<S extends ScalarField>(options: Partial<ScalarField>, v: (name: string) => S): (name: string) => S;
-export declare function makeScalarField<S extends Partial<ScalarField>>(options: S): (name: string) => ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
-} & S;
+export declare function withScalarOptions<S extends SchemaField>(options: Partial<SchemaField>, v: (name: string) => S): (name: string) => S;
+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 & {
-    schemaType: SchemaFieldType.Compound;
     type: FieldType.Compound;
 } & S;
-export declare function intField(displayName: string, options?: Partial<Omit<ScalarField, "schemaType" | "type">>): (name: string) => ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
-} & {
+export declare function intField(displayName: string, options?: Partial<Omit<SchemaField, "type">>): (name: string) => SchemaField & {
     field?: string | undefined;
-    displayName: string;
-    tags?: string[] | undefined;
-    system?: boolean | undefined;
-    collection?: boolean | undefined;
-    onlyForTypes?: string[] | undefined;
-    required?: boolean | undefined;
-    entityRefType?: string | undefined;
-    parentField?: string | undefined;
-    searchable?: boolean | undefined;
+    displayName: string | null;
+    tags?: string[] | null | undefined;
+    system?: boolean | null | undefined;
+    collection?: boolean | null | undefined;
+    onlyForTypes?: string[] | null | undefined;
+    required?: boolean | null | undefined;
+    notNullable?: boolean | null | undefined;
     defaultValue?: any;
-    isTypeField?: boolean | undefined;
-    restrictions?: import("./types").SchemaRestrictions | undefined;
+    isTypeField?: boolean | null | undefined;
+    searchable?: boolean | null | undefined;
+    options?: FieldOption[] | null | undefined;
+    validators?: import("./types").SchemaValidator[] | null | undefined;
     type: FieldType.Int;
 };
-export declare function boolField(displayName: string, options?: Partial<Omit<ScalarField, "schemaType" | "type">>): (name: string) => ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
-} & {
+export declare function boolField(displayName: string, options?: Partial<Omit<SchemaField, "type">>): (name: string) => SchemaField & {
     field?: string | undefined;
-    displayName: string;
-    tags?: string[] | undefined;
-    system?: boolean | undefined;
-    collection?: boolean | undefined;
-    onlyForTypes?: string[] | undefined;
-    required?: boolean | undefined;
-    entityRefType?: string | undefined;
-    parentField?: string | undefined;
-    searchable?: boolean | undefined;
+    displayName: string | null;
+    tags?: string[] | null | undefined;
+    system?: boolean | null | undefined;
+    collection?: boolean | null | undefined;
+    onlyForTypes?: string[] | null | undefined;
+    required?: boolean | null | undefined;
+    notNullable?: boolean | null | undefined;
     defaultValue?: any;
-    isTypeField?: boolean | undefined;
-    restrictions?: import("./types").SchemaRestrictions | undefined;
+    isTypeField?: boolean | null | undefined;
+    searchable?: boolean | null | undefined;
+    options?: FieldOption[] | null | undefined;
+    validators?: import("./types").SchemaValidator[] | null | undefined;
     type: FieldType.Bool;
 };
 export declare function compoundField<Other extends Partial<Omit<CompoundField, "type" | "schemaType">>>(displayName: string, fields: SchemaField[], other: Other): (name: string) => CompoundField & {
-    schemaType: SchemaFieldType.Compound;
-    type: FieldType.Compound;
     collection: Other["collection"];
 };
-export declare function defaultScalarField(field: string, displayName: string): ScalarField & {
-    schemaType: SchemaFieldType.Scalar;
+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;
-    schemaType: SchemaFieldType.Compound;
 };
 export {};

package/lib/tailwind.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRendererOptions } from "./renderers";
+export declare const defaultTailwindTheme: DefaultRendererOptions;

package/lib/types.d.ts

@@ -1,17 +1,18 @@
 export interface SchemaField {
-    schemaType: SchemaFieldType;
+    type: string;
     field: string;
-    displayName: string;
-    type: FieldType;
-    tags: string[];
-    system: boolean;
-    collection: boolean;
-    onlyForTypes: string[];
-    required: boolean;
-}
-export declare enum SchemaFieldType {
-    Scalar = "Scalar",
-    Compound = "Compound"
+    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 declare enum FieldType {
     String = "String",
@@ -23,33 +24,30 @@ export declare enum FieldType {
     EntityRef = "EntityRef",
     Compound = "Compound",
     AutoId = "AutoId",
-    Image = "Image"
+    Image = "Image",
+    Any = "Any"
 }
-export interface ScalarField extends SchemaField {
+export interface EntityRefField extends SchemaField {
+    type: FieldType.EntityRef;
     entityRefType: string;
     parentField: string;
-    searchable: boolean;
-    defaultValue: any;
-    isTypeField: boolean;
-    restrictions: SchemaRestrictions | undefined;
-}
-export interface SchemaRestrictions {
-    options: FieldOption[] | undefined;
 }
 export interface FieldOption {
     name: string;
     value: any;
 }
 export interface CompoundField extends SchemaField {
+    type: FieldType.Compound;
     children: SchemaField[];
-    treeChildren: boolean;
+    treeChildren?: boolean;
 }
 export type AnyControlDefinition = DataControlDefinition | GroupedControlsDefinition | ActionControlDefinition | DisplayControlDefinition;
 export interface ControlDefinition {
     type: string;
-    title?: string;
-    dynamic?: DynamicProperty[];
-    adornments?: ControlAdornment[];
+    title?: string | null;
+    dynamic?: DynamicProperty[] | null;
+    adornments?: ControlAdornment[] | null;
+    children?: ControlDefinition[] | null;
 }
 export declare enum ControlDefinitionType {
     Data = "Data",
@@ -58,7 +56,7 @@ export declare enum ControlDefinitionType {
     Action = "Action"
 }
 export interface DynamicProperty {
-    type: DynamicPropertyType;
+    type: string;
     expr: EntityExpression;
 }
 export declare enum DynamicPropertyType {
@@ -66,7 +64,7 @@ export declare enum DynamicPropertyType {
     DefaultValue = "DefaultValue"
 }
 export interface EntityExpression {
-    type: ExpressionType;
+    type: string;
 }
 export declare enum ExpressionType {
     Jsonata = "Jsonata",
@@ -74,39 +72,58 @@ export declare enum ExpressionType {
     UserMatch = "UserMatch"
 }
 export interface JsonataExpression extends EntityExpression {
+    type: ExpressionType.Jsonata;
     expression: string;
 }
 export interface FieldValueExpression extends EntityExpression {
+    type: ExpressionType.FieldValue;
     field: string;
     value: any;
 }
 export interface UserMatchExpression extends EntityExpression {
+    type: ExpressionType.UserMatch;
     userMatch: string;
 }
 export interface ControlAdornment {
-    type: ControlAdornmentType;
+    type: string;
+}
+export declare enum AdornmentPlacement {
+    ControlStart = "ControlStart",
+    ControlEnd = "ControlEnd",
+    LabelStart = "LabelStart",
+    LabelEnd = "LabelEnd"
 }
 export declare enum ControlAdornmentType {
     Tooltip = "Tooltip",
-    Accordion = "Accordion"
+    Accordion = "Accordion",
+    HelpText = "HelpText"
 }
 export interface TooltipAdornment extends ControlAdornment {
+    type: ControlAdornmentType.Tooltip;
     tooltip: string;
 }
 export interface AccordionAdornment extends ControlAdornment {
+    type: ControlAdornmentType.Accordion;
     title: string;
     defaultExpanded: boolean;
 }
+export interface HelpTextAdornment extends ControlAdornment {
+    type: ControlAdornmentType.HelpText;
+    helpText: string;
+    placement: AdornmentPlacement;
+}
 export interface DataControlDefinition extends ControlDefinition {
     type: ControlDefinitionType.Data;
     field: string;
-    required?: boolean;
-    renderOptions: RenderOptions;
+    required?: boolean | null;
+    renderOptions?: RenderOptions | null;
     defaultValue?: any;
-    readonly?: boolean;
+    readonly?: boolean | null;
+    validators?: SchemaValidator[] | null;
+    hideTitle?: boolean | null;
 }
 export interface RenderOptions {
-    type: DataRenderType;
+    type: string;
 }
 export declare enum DataRenderType {
     Standard = "Standard",
@@ -117,28 +134,37 @@ export declare enum DataRenderType {
     UserSelection = "UserSelection",
     Synchronised = "Synchronised",
     IconSelector = "IconSelector",
-    DateTime = "DateTime"
+    DateTime = "DateTime",
+    Checkbox = "Checkbox",
+    Dropdown = "Dropdown"
 }
 export interface RadioButtonRenderOptions extends RenderOptions {
+    type: DataRenderType.Radio;
 }
 export interface StandardRenderer extends RenderOptions {
+    type: DataRenderType.Standard;
 }
 export interface HtmlEditorRenderOptions extends RenderOptions {
+    type: DataRenderType.HtmlEditor;
     allowImages: boolean;
 }
 export interface DateTimeRenderOptions extends RenderOptions {
-    format?: string;
+    type: DataRenderType.DateTime;
+    format?: string | null;
 }
 export interface IconListRenderOptions extends RenderOptions {
+    type: DataRenderType.IconList;
     iconMappings: IconMapping[];
 }
 export interface IconMapping {
     value: string;
-    materialIcon: string | undefined;
+    materialIcon?: string | null;
 }
 export interface CheckListRenderOptions extends RenderOptions {
+    type: DataRenderType.CheckList;
 }
 export interface SynchronisedRenderOptions extends RenderOptions {
+    type: DataRenderType.Synchronised;
     fieldToSync: string;
     syncType: SyncTextType;
 }
@@ -148,20 +174,21 @@ export declare enum SyncTextType {
     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;
-    children: AnyControlDefinition[];
-    compoundField?: string;
-    groupOptions: GroupRenderOptions;
+    compoundField?: string | null;
+    groupOptions?: GroupRenderOptions;
 }
 export interface GroupRenderOptions {
-    type: GroupRenderType;
-    hideTitle?: boolean;
+    type: string;
+    hideTitle?: boolean | null;
 }
 export declare enum GroupRenderType {
     Standard = "Standard",
@@ -169,31 +196,69 @@ export declare enum GroupRenderType {
     GroupElement = "GroupElement"
 }
 export interface StandardGroupRenderer extends GroupRenderOptions {
+    type: GroupRenderType.Standard;
 }
 export interface GroupElementRenderer extends GroupRenderOptions {
+    type: GroupRenderType.GroupElement;
     value: any;
 }
 export interface GridRenderer extends GroupRenderOptions {
-    columns: number | undefined;
+    type: GroupRenderType.Grid;
+    columns?: number | null;
 }
 export interface DisplayControlDefinition extends ControlDefinition {
     type: ControlDefinitionType.Display;
     displayData: DisplayData;
 }
 export interface DisplayData {
-    type: DisplayDataType;
+    type: string;
 }
 export declare enum DisplayDataType {
     Text = "Text",
     Html = "Html"
 }
 export interface TextDisplay extends DisplayData {
+    type: DisplayDataType.Text;
     text: string;
 }
 export interface HtmlDisplay extends DisplayData {
+    type: DisplayDataType.Html;
     html: string;
 }
 export interface ActionControlDefinition extends ControlDefinition {
     type: ControlDefinitionType.Action;
     actionId: string;
 }
+export declare enum ValidatorType {
+    Jsonata = "Jsonata",
+    Date = "Date"
+}
+export interface SchemaValidator {
+    type: string;
+}
+export interface JsonataValidator extends SchemaValidator {
+    type: ValidatorType.Jsonata;
+    expression: string;
+}
+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;
+export declare function isActionControlsDefinition(x: ControlDefinition): x is ActionControlDefinition;
+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;

package/lib/util.d.ts

@@ -0,0 +1,35 @@
+import { CompoundField, ControlDefinition, DataControlDefinition, FieldOption, GroupedControlsDefinition, SchemaField } from "./types";
+import { MutableRefObject } from "react";
+import { Control } from "@react-typed-forms/core";
+export interface ControlGroupContext {
+    groupControl: Control<any>;
+    fields: SchemaField[];
+}
+export declare function applyDefaultValues(v: {
+    [k: string]: any;
+} | undefined, fields: SchemaField[]): any;
+export declare function applyDefaultForField(v: any, field: SchemaField, parent: SchemaField[], notElement?: boolean): any;
+export declare function defaultValueForFields(fields: SchemaField[]): any;
+export declare function defaultValueForField(sf: SchemaField, required?: boolean | null): any;
+export declare function elementValueForField(sf: SchemaField): any;
+export declare function findScalarField(fields: SchemaField[], field: string): SchemaField | undefined;
+export declare function findCompoundField(fields: SchemaField[], field: string): CompoundField | undefined;
+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 declare function fieldHasTag(field: SchemaField, tag: string): boolean;
+export declare function fieldDisplayName(field: SchemaField): string;
+export declare function hasOptions(o: {
+    options: FieldOption[] | undefined | null;
+}): boolean;
+export declare function defaultControlForField(sf: SchemaField): DataControlDefinition | GroupedControlsDefinition;
+export declare function addMissingControls(fields: SchemaField[], controls: ControlDefinition[]): ControlDefinition[];
+export declare function useUpdatedRef<A>(a: A): MutableRefObject<A>;
+export declare function getTypeField(context: ControlGroupContext): Control<string> | undefined;
+export declare function visitControlDataArray<A>(controls: ControlDefinition[] | undefined | null, context: ControlGroupContext, cb: (definition: DataControlDefinition, field: SchemaField, control: Control<any>, element: boolean) => A | undefined): A | undefined;
+export declare function visitControlData<A>(definition: ControlDefinition, ctx: ControlGroupContext, cb: (definition: DataControlDefinition, field: SchemaField, control: Control<any>, element: boolean) => A | undefined): A | undefined;
+export declare function cleanDataForSchema(v: {
+    [k: string]: any;
+} | undefined, fields: SchemaField[]): any;

package/lib/validators.d.ts

@@ -0,0 +1,4 @@
+import { ControlDefinition } from "./types";
+import { Control } from "@react-typed-forms/core";
+import { ControlGroupContext } from "./util";
+export declare function useValidationHook(definition: ControlDefinition): (control: Control<any>, hidden: boolean, groupContext: ControlGroupContext) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@react-typed-forms/schemas",
-	"version": "3.0.0-dev.99",
+	"version": "4.1.0",
 	"description": "",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
@@ -24,19 +24,26 @@
 		"material-ui"
 	],
 	"dependencies": {
-		"@react-typed-forms/core": "3.0.0-dev.99"
+		"@react-typed-forms/core": "^3.0.0-dev.117",
+		"clsx": "^1 || ^2",
+		"jsonata": "^2.0.4",
+		"react": "^18.2.0"
 	},
 	"devDependencies": {
-		"@types/react": "^18.0.22",
+		"@react-typed-forms/transform": "^0.2.0",
+		"@types/react": "^18.2.28",
+		"markdown-magic": "^2.6.1",
+		"microbundle": "^0.15.1",
 		"nswag": "^13.18.2",
-		"react": "^18.2.0",
-		"react-dom": "^18.2.0",
-		"rimraf": "^3.0.2"
+		"prettier": "^3.0.3",
+		"rimraf": "^3.0.2",
+		"typescript": "^5.2.2"
 	},
 	"gitHead": "698e16cd3ab31b7dd0528fc76536f4d3205ce8c6",
 	"scripts": {
-		"build": "rimraf ./lib/ && tsc",
-		"watch": "tsc -w",
+		"build": "rimraf ./lib/ && microbundle -f cjs --no-compress --jsx React.createElement --jsxFragment React.Fragment",
+		"watch": "microbundle -w -f cjs --no-compress --jsx React.createElement --jsxFragment React.Fragment",
+		"update-readme": "md-magic --path README.md",
 		"gencode": "nswag swagger2tsclient /input:http://localhost:5216/swagger/v1/swagger.json /runtime:Net60 /output:src/types.ts /GenerateClientClasses:false /MarkOptionalProperties:false /Template:Fetch /TypeStyle:Interface /DateTimeType:string"
 	}
 }

package/src/controlBuilder.ts

@@ -0,0 +1,121 @@
+import {
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  DisplayControlDefinition,
+  DisplayDataType,
+  DynamicProperty,
+  DynamicPropertyType,
+  EntityExpression,
+  ExpressionType,
+  FieldValueExpression,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  HtmlDisplay,
+  JsonataExpression,
+  SchemaField,
+  TextDisplay,
+} from "./types";
+import { ActionRendererProps } from "./controlRender";
+import { useMemo } from "react";
+import { addMissingControls } from "./util";
+
+export function dataControl(
+  field: string,
+  title?: string | null,
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return { type: ControlDefinitionType.Data, field, title, ...options };
+}
+
+export function textDisplayControl(
+  text: string,
+  options?: Partial<DisplayControlDefinition>,
+): DisplayControlDefinition {
+  return {
+    type: ControlDefinitionType.Display,
+    displayData: { type: DisplayDataType.Text, text } as TextDisplay,
+    ...options,
+  };
+}
+
+export function htmlDisplayControl(
+  html: string,
+  options?: Partial<DisplayControlDefinition>,
+): DisplayControlDefinition {
+  return {
+    type: ControlDefinitionType.Display,
+    displayData: { type: DisplayDataType.Html, html } as HtmlDisplay,
+    ...options,
+  };
+}
+
+export function dynamicDefaultValue(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.DefaultValue, expr };
+}
+export function visibility(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Visible, expr };
+}
+
+export function fieldEqExpr(field: string, value: any): FieldValueExpression {
+  return { type: ExpressionType.FieldValue, field, value };
+}
+export function jsonataExpr(expression: string): JsonataExpression {
+  return { type: ExpressionType.Jsonata, expression };
+}
+
+export function groupedControl(
+  children: ControlDefinition[],
+  title?: string,
+  options?: Partial<GroupedControlsDefinition>,
+): GroupedControlsDefinition {
+  return {
+    type: ControlDefinitionType.Group,
+    children,
+    title,
+    groupOptions: { type: "Standard", hideTitle: !title },
+    ...options,
+  };
+}
+export function compoundControl(
+  field: string,
+  title: string | undefined,
+  children: ControlDefinition[],
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return {
+    type: ControlDefinitionType.Data,
+    field,
+    children,
+    title,
+    renderOptions: { type: "Standard" },
+    ...options,
+  };
+}
+
+export function createAction(
+  actionId: string,
+  onClick: () => void,
+  actionText?: string,
+): ActionRendererProps {
+  return { actionId, onClick, actionText: actionText ?? actionId };
+}
+
+export const emptyGroupDefinition: GroupedControlsDefinition = {
+  type: ControlDefinitionType.Group,
+  children: [],
+  groupOptions: { type: GroupRenderType.Standard, hideTitle: true },
+};
+
+export function useControlDefinitionForSchema(
+  sf: SchemaField[],
+  definition: GroupedControlsDefinition = emptyGroupDefinition,
+): GroupedControlsDefinition {
+  return useMemo<GroupedControlsDefinition>(
+    () => ({
+      ...definition,
+      children: addMissingControls(sf, definition.children ?? []),
+    }),
+    [sf, definition],
+  );
+}