@react-typed-forms/schemas 1.0.0-dev.18 → 1.0.0-dev.19

package/lib/types.d.ts

@@ -12,10 +12,6 @@ export interface SchemaField {
     searchable?: boolean | null;
     options?: FieldOption[] | null;
     validators?: SchemaValidator[] | null;
-    /**
-     * @deprecated Use options directly
-     */
-    restrictions?: SchemaRestrictions | undefined | null;
 }
 export declare enum FieldType {
     String = "String",
@@ -35,9 +31,6 @@ export interface EntityRefField extends SchemaField {
     entityRefType: string;
     parentField: string;
 }
-export interface SchemaRestrictions {
-    options?: FieldOption[] | null;
-}
 export interface FieldOption {
     name: string;
     value: any;

package/lib/util.d.ts

@@ -1,6 +1,22 @@
-import { FieldOption, SchemaField } from "./types";
+import { CompoundField, ControlDefinition, DataControlDefinition, FieldOption, GroupedControlsDefinition, SchemaField } from "./types";
+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): 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[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@react-typed-forms/schemas",
-	"version": "1.0.0-dev.18",
+	"version": "1.0.0-dev.19",
 	"description": "",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
@@ -25,18 +25,18 @@
 	],
 	"dependencies": {
 		"@react-typed-forms/core": "^3.0.0-dev.116",
-		"react": "^18.2.0",
+		"clsx": "^1 || ^2",
 		"jsonata": "^2.0.3",
-		"clsx": "^1 || ^2"
+		"react": "^18.2.0"
 	},
 	"devDependencies": {
-		"typescript": "^5.2.2",
 		"@react-typed-forms/transform": "^0.1.0",
 		"@types/react": "^18.2.28",
 		"microbundle": "^0.15.1",
 		"nswag": "^13.18.2",
+		"prettier": "^3.0.3",
 		"rimraf": "^3.0.2",
-		"prettier": "^3.0.3"
+		"typescript": "^5.2.2"
 	},
 	"gitHead": "698e16cd3ab31b7dd0528fc76536f4d3205ce8c6",
 	"scripts": {

package/src/controlRender.tsx

@@ -9,23 +9,15 @@ import {
   DisplayControlDefinition,
   EntityExpression,
   FieldOption,
-  FieldType,
   GroupedControlsDefinition,
   RenderOptions,
   SchemaField,
   SchemaValidator,
   visitControlDefinition,
 } from "./types";
-import React, {
-  Context,
-  createContext,
-  Key,
-  ReactElement,
-  ReactNode,
-  useContext,
-} from "react";
-import { Control, newControl } from "@react-typed-forms/core";
-import { fieldDisplayName } from "./util";
+import React, {Context, createContext, Key, ReactElement, ReactNode, useContext,} from "react";
+import {Control, newControl} from "@react-typed-forms/core";
+import {fieldDisplayName, findCompoundField, findField, findScalarField, isDataControl, isGroupControl} from "./util";
 
 export interface SchemaHooks {
   useExpression(
@@ -190,100 +182,10 @@ export interface ActionRendererProps {
   onClick: () => void;
 }
 
-export function isScalarField(sf: SchemaField): sf is SchemaField {
-  return !isCompoundField(sf);
-}
-
-export function isCompoundField(sf: SchemaField): sf is CompoundField {
-  return sf.type === FieldType.Compound;
-}
-
 export type AnySchemaFields =
   | SchemaField
   | (Omit<CompoundField, "children"> & { children: AnySchemaFields[] });
 
-export function applyDefaultValues(
-  v: { [k: string]: any } | undefined,
-  fields: SchemaField[],
-): any {
-  if (!v) return defaultValueForFields(fields);
-  const applyValue = fields.filter(
-    (x) => isCompoundField(x) || !(x.field in v),
-  );
-  if (!applyValue.length) return v;
-  const out = { ...v };
-  applyValue.forEach((x) => {
-    out[x.field] =
-      x.field in v
-        ? applyDefaultForField(v[x.field], x, fields)
-        : defaultValueForField(x);
-  });
-  return out;
-}
-
-export function applyDefaultForField(
-  v: any,
-  field: SchemaField,
-  parent: SchemaField[],
-  notElement?: boolean,
-): any {
-  if (field.collection && !notElement) {
-    return ((v as any[]) ?? []).map((x) =>
-      applyDefaultForField(x, field, parent, true),
-    );
-  }
-  if (isCompoundField(field)) {
-    if (!v && !field.required) return v;
-    return applyDefaultValues(v, field.treeChildren ? parent : field.children);
-  }
-  return defaultValueForField(field);
-}
-
-export function defaultValueForFields(fields: SchemaField[]): any {
-  return Object.fromEntries(
-    fields.map((x) => [x.field, defaultValueForField(x)]),
-  );
-}
-
-export function defaultValueForField(sf: SchemaField): any {
-  if (isCompoundField(sf)) {
-    return sf.required
-      ? sf.collection
-        ? []
-        : defaultValueForFields(sf.children)
-      : undefined;
-  }
-  if (sf.collection) return [];
-  return sf.defaultValue;
-}
-
-export function elementValueForField(sf: SchemaField): any {
-  if (isCompoundField(sf)) {
-    return defaultValueForFields(sf.children);
-  }
-  return sf.defaultValue;
-}
-
-export function findScalarField(
-  fields: SchemaField[],
-  field: string,
-): SchemaField | undefined {
-  return findField(fields, field);
-}
-
-export function findCompoundField(
-  fields: SchemaField[],
-  field: string,
-): CompoundField | undefined {
-  return findField(fields, field) as CompoundField | undefined;
-}
-
-export function findField(
-  fields: SchemaField[],
-  field: string,
-): SchemaField | undefined {
-  return fields.find((x) => x.field === field);
-}
 export function controlTitle(
   title: string | undefined | null,
   field: SchemaField,
@@ -437,18 +339,6 @@ export function fieldForControl(c: ControlDefinition) {
     : undefined;
 }
 
-export function isDataControl(
-  c: ControlDefinition,
-): c is DataControlDefinition {
-  return c.type === ControlDefinitionType.Data;
-}
-
-export function isGroupControl(
-  c: ControlDefinition,
-): c is GroupedControlsDefinition {
-  return c.type === ControlDefinitionType.Group;
-}
-
 export const AlwaysVisible: Visibility = { value: true, canChange: false };
 
 export function createAction(

package/src/hooks.tsx

@@ -23,15 +23,10 @@ import {
   controlForField,
   controlTitle,
   DataRendererProps,
-  elementValueForField,
   fieldForControl,
-  findCompoundField,
-  findField,
   FormEditHooks,
   FormEditState,
   GroupRendererProps,
-  isGroupControl,
-  isScalarField,
   renderControl,
   SchemaHooks,
   Visibility,
@@ -49,6 +44,14 @@ import {
   useValidator,
 } from "@react-typed-forms/core";
 import jsonata from "jsonata";
+import {
+  addMissingControls,
+  elementValueForField,
+  findCompoundField,
+  findField,
+  isGroupControl,
+  isScalarField,
+} from "./util";
 
 export function useDefaultValue(
   definition: DataControlDefinition,
@@ -140,7 +143,7 @@ export function getDefaultScalarControlProperties(
 export function getOptionsForScalarField(
   field: SchemaField,
 ): FieldOption[] | undefined | null {
-  const opts = field.options ?? field.restrictions?.options;
+  const opts = field.options;
   if (opts?.length ?? 0 > 0) {
     return opts;
   }
@@ -423,3 +426,16 @@ function defaultArrayRendererProps(
     },
   };
 }
+
+export function useControlsWithDefaults(
+  definition: GroupedControlsDefinition,
+  sf: SchemaField[],
+) {
+  return useMemo(
+    () =>
+      definition.children.length
+        ? definition
+        : { ...definition, children: addMissingControls(sf, []) },
+    [sf, definition],
+  );
+}

package/src/types.ts

@@ -12,10 +12,6 @@ export interface SchemaField {
   searchable?: boolean | null;
   options?: FieldOption[] | null;
   validators?: SchemaValidator[] | null;
-  /**
-   * @deprecated Use options directly
-   */
-  restrictions?: SchemaRestrictions | undefined | null;
 }
 
 export enum FieldType {
@@ -38,10 +34,6 @@ export interface EntityRefField extends SchemaField {
   parentField: string;
 }
 
-export interface SchemaRestrictions {
-  options?: FieldOption[] | null;
-}
-
 export interface FieldOption {
   name: string;
   value: any;

package/src/util.ts

@@ -1,4 +1,119 @@
-import { FieldOption, SchemaField } from "./types";
+import {
+  CompoundField,
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  DataRenderType,
+  FieldOption,
+  FieldType,
+  GridRenderer,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  SchemaField,
+} from "./types";
+
+export function applyDefaultValues(
+  v: { [k: string]: any } | undefined,
+  fields: SchemaField[],
+): any {
+  if (!v) return defaultValueForFields(fields);
+  const applyValue = fields.filter(
+    (x) => isCompoundField(x) || !(x.field in v),
+  );
+  if (!applyValue.length) return v;
+  const out = { ...v };
+  applyValue.forEach((x) => {
+    out[x.field] =
+      x.field in v
+        ? applyDefaultForField(v[x.field], x, fields)
+        : defaultValueForField(x);
+  });
+  return out;
+}
+
+export function applyDefaultForField(
+  v: any,
+  field: SchemaField,
+  parent: SchemaField[],
+  notElement?: boolean,
+): any {
+  if (field.collection && !notElement) {
+    return ((v as any[]) ?? []).map((x) =>
+      applyDefaultForField(x, field, parent, true),
+    );
+  }
+  if (isCompoundField(field)) {
+    if (!v && !field.required) return v;
+    return applyDefaultValues(v, field.treeChildren ? parent : field.children);
+  }
+  return defaultValueForField(field);
+}
+
+export function defaultValueForFields(fields: SchemaField[]): any {
+  return Object.fromEntries(
+    fields.map((x) => [x.field, defaultValueForField(x)]),
+  );
+}
+
+export function defaultValueForField(sf: SchemaField): any {
+  if (isCompoundField(sf)) {
+    return sf.required
+      ? sf.collection
+        ? []
+        : defaultValueForFields(sf.children)
+      : undefined;
+  }
+  if (sf.collection) return [];
+  return sf.defaultValue;
+}
+
+export function elementValueForField(sf: SchemaField): any {
+  if (isCompoundField(sf)) {
+    return defaultValueForFields(sf.children);
+  }
+  return sf.defaultValue;
+}
+
+export function findScalarField(
+  fields: SchemaField[],
+  field: string,
+): SchemaField | undefined {
+  return findField(fields, field);
+}
+
+export function findCompoundField(
+  fields: SchemaField[],
+  field: string,
+): CompoundField | undefined {
+  return findField(fields, field) as CompoundField | undefined;
+}
+
+export function findField(
+  fields: SchemaField[],
+  field: string,
+): SchemaField | undefined {
+  return fields.find((x) => x.field === field);
+}
+
+export function isScalarField(sf: SchemaField): sf is SchemaField {
+  return !isCompoundField(sf);
+}
+
+export function isCompoundField(sf: SchemaField): sf is CompoundField {
+  return sf.type === FieldType.Compound;
+}
+
+export function isDataControl(
+  c: ControlDefinition,
+): c is DataControlDefinition {
+  return c.type === ControlDefinitionType.Data;
+}
+
+export function isGroupControl(
+  c: ControlDefinition,
+): c is GroupedControlsDefinition {
+  return c.type === ControlDefinitionType.Group;
+}
 
 export function fieldHasTag(field: SchemaField, tag: string) {
   return Boolean(field.tags?.includes(tag));
@@ -11,3 +126,87 @@ export function fieldDisplayName(field: SchemaField) {
 export function hasOptions(o: { options: FieldOption[] | undefined | null }) {
   return (o.options?.length ?? 0) > 0;
 }
+
+export function defaultControlForField(
+  sf: SchemaField,
+): DataControlDefinition | GroupedControlsDefinition {
+  if (isCompoundField(sf)) {
+    return {
+      type: ControlDefinitionType.Group,
+      title: sf.displayName,
+      compoundField: sf.field,
+      groupOptions: {
+        type: GroupRenderType.Grid,
+        hideTitle: false,
+      } as GridRenderer,
+      children: sf.children.map(defaultControlForField),
+    } satisfies GroupedControlsDefinition;
+  } else if (isScalarField(sf)) {
+    const htmlEditor = sf.tags?.includes("_HtmlEditor");
+    return {
+      type: ControlDefinitionType.Data,
+      title: sf.displayName,
+      field: sf.field,
+      required: sf.required,
+      renderOptions: {
+        type: htmlEditor ? DataRenderType.HtmlEditor : DataRenderType.Standard,
+      },
+    } satisfies DataControlDefinition;
+  }
+  throw "Unknown schema field";
+}
+function findReferencedControl(
+  field: string,
+  control: ControlDefinition,
+): ControlDefinition | undefined {
+  if (isDataControl(control) && field === control.field) return control;
+  if (isGroupControl(control)) {
+    if (control.compoundField)
+      return field === control.compoundField ? control : undefined;
+    return findReferencedControlInArray(field, control.children);
+  }
+  return undefined;
+}
+
+function findReferencedControlInArray(
+  field: string,
+  controls: ControlDefinition[],
+): ControlDefinition | undefined {
+  for (const c of controls) {
+    const ref = findReferencedControl(field, c);
+    if (ref) return ref;
+  }
+  return undefined;
+}
+
+export function addMissingControls(
+  fields: SchemaField[],
+  controls: ControlDefinition[],
+): ControlDefinition[] {
+  const changes: {
+    field: SchemaField;
+    existing: ControlDefinition | undefined;
+  }[] = fields.flatMap((x) => {
+    if (fieldHasTag(x, "_NoControl")) return [];
+    const existing = findReferencedControlInArray(x.field, controls);
+    if (!existing || isCompoundField(x)) return { field: x, existing };
+    return [];
+  });
+  const changedCompounds = controls.map((x) => {
+    const ex = changes.find((c) => c.existing === x);
+    if (!ex) return x;
+    const cf = x as GroupedControlsDefinition;
+    return {
+      ...cf,
+      children: addMissingControls(
+        (ex.field as CompoundField).children,
+        cf.children,
+      ),
+    };
+  });
+  return changedCompounds.concat(
+    changes
+      .filter((x) => !x.existing)
+      .map((x) => defaultControlForField(x.field)),
+  );
+}