@react-typed-forms/schemas 1.0.0-dev.2 → 1.0.0-dev.21

package/src/schemaBuilder.ts

@@ -20,11 +20,14 @@ type AllowedSchema<T> = T extends string
   ? CompoundField & {
       type: FieldType.Compound;
     }
-  : never;
-type AllowedField<T> = (name: string) => AllowedSchema<T>;
+  : SchemaField & { type: FieldType.Any };
 
-export function buildSchema<T>(def: {
-  [K in keyof T]-?: AllowedField<T[K]>;
+type AllowedField<T, K> = (
+  name: string
+) => (SchemaField & { type: K }) | AllowedSchema<T>;
+
+export function buildSchema<T, Custom = "">(def: {
+  [K in keyof T]-?: AllowedField<T[K], Custom>;
 }): SchemaField[] {
   return Object.entries(def).map((x) =>
     (x[1] as (n: string) => SchemaField)(x[0])

package/src/tailwind.tsx

@@ -0,0 +1,21 @@
+import React from "react";
+import { DefaultRendererOptions } from "./renderers";
+
+export const defaultTailwindTheme: DefaultRendererOptions = {
+  label: {
+    className: "flex flex-col",
+    groupLabelClass: "font-bold",
+    requiredElement: <span className="text-red-500"> *</span>,
+  },
+  array: {
+    removableClass: "grid grid-cols-[1fr_auto] items-center gap-x-2",
+    childClass: "grow",
+  },
+  group: {
+    standardClassName: "space-y-4",
+    gridClassName: "gap-x-2 gap-y-4",
+  },
+  action: {
+    className: "bg-primary rounded-lg p-3 text-white",
+  },
+};

package/src/types.ts

@@ -1,20 +1,17 @@
 export interface SchemaField {
   type: string;
   field: string;
-  displayName?: string;
-  tags?: string[];
-  system?: boolean;
-  collection?: boolean;
-  onlyForTypes?: string[];
-  required?: boolean;
+  displayName?: string | null;
+  tags?: string[] | null;
+  system?: boolean | null;
+  collection?: boolean | null;
+  onlyForTypes?: string[] | null;
+  required?: boolean | null;
   defaultValue?: any;
-  isTypeField?: boolean;
-  searchable?: boolean;
-  options?: FieldOption[];
-  /**
-   * @deprecated Use options directly
-   */
-  restrictions?: SchemaRestrictions | undefined;
+  isTypeField?: boolean | null;
+  searchable?: boolean | null;
+  options?: FieldOption[] | null;
+  validators?: SchemaValidator[] | null;
 }
 
 export enum FieldType {
@@ -28,6 +25,7 @@ export enum FieldType {
   Compound = "Compound",
   AutoId = "AutoId",
   Image = "Image",
+  Any = "Any",
 }
 
 export interface EntityRefField extends SchemaField {
@@ -36,10 +34,6 @@ export interface EntityRefField extends SchemaField {
   parentField: string;
 }
 
-export interface SchemaRestrictions {
-  options: FieldOption[] | undefined;
-}
-
 export interface FieldOption {
   name: string;
   value: any;
@@ -59,9 +53,9 @@ export type AnyControlDefinition =
 
 export interface ControlDefinition {
   type: string;
-  title?: string;
-  dynamic?: DynamicProperty[];
-  adornments?: ControlAdornment[];
+  title?: string | null;
+  dynamic?: DynamicProperty[] | null;
+  adornments?: ControlAdornment[] | null;
 }
 
 export enum ControlDefinitionType {
@@ -72,7 +66,7 @@ export enum ControlDefinitionType {
 }
 
 export interface DynamicProperty {
-  type: DynamicPropertyType;
+  type: string;
   expr: EntityExpression;
 }
 
@@ -82,7 +76,7 @@ export enum DynamicPropertyType {
 }
 
 export interface EntityExpression {
-  type: ExpressionType;
+  type: string;
 }
 
 export enum ExpressionType {
@@ -92,43 +86,63 @@ export enum ExpressionType {
 }
 
 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 enum AdornmentPlacement {
+  ControlStart = "ControlStart",
+  ControlEnd = "ControlEnd",
+  LabelStart = "LabelStart",
+  LabelEnd = "LabelEnd",
 }
 
 export enum ControlAdornmentType {
   Tooltip = "Tooltip",
   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;
 }
 
 export interface RenderOptions {
@@ -145,32 +159,44 @@ export enum DataRenderType {
   Synchronised = "Synchronised",
   IconSelector = "IconSelector",
   DateTime = "DateTime",
+  Checkbox = "Checkbox",
+  Dropdown = "Dropdown",
 }
 
-export interface RadioButtonRenderOptions extends RenderOptions {}
+export interface RadioButtonRenderOptions extends RenderOptions {
+  type: DataRenderType.Radio;
+}
 
-export interface StandardRenderer extends RenderOptions {}
+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 {}
+export interface CheckListRenderOptions extends RenderOptions {
+  type: DataRenderType.CheckList;
+}
 
 export interface SynchronisedRenderOptions extends RenderOptions {
+  type: DataRenderType.Synchronised;
   fieldToSync: string;
   syncType: SyncTextType;
 }
@@ -182,22 +208,25 @@ export enum SyncTextType {
 }
 
 export interface UserSelectionRenderOptions extends RenderOptions {
+  type: DataRenderType.UserSelection;
   noGroups: boolean;
   noUsers: boolean;
 }
 
-export interface IconSelectionRenderOptions extends RenderOptions {}
+export interface IconSelectionRenderOptions extends RenderOptions {
+  type: DataRenderType.IconSelector;
+}
 
 export interface GroupedControlsDefinition extends ControlDefinition {
   type: ControlDefinitionType.Group;
-  children: AnyControlDefinition[];
-  compoundField?: string;
+  children: ControlDefinition[];
+  compoundField?: string | null;
   groupOptions: GroupRenderOptions;
 }
 
 export interface GroupRenderOptions {
-  type: GroupRenderType;
-  hideTitle?: boolean;
+  type: string;
+  hideTitle?: boolean | null;
 }
 
 export enum GroupRenderType {
@@ -206,14 +235,18 @@ export enum GroupRenderType {
   GroupElement = "GroupElement",
 }
 
-export interface StandardGroupRenderer extends GroupRenderOptions {}
+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 {
@@ -222,7 +255,7 @@ export interface DisplayControlDefinition extends ControlDefinition {
 }
 
 export interface DisplayData {
-  type: DisplayDataType;
+  type: string;
 }
 
 export enum DisplayDataType {
@@ -231,10 +264,12 @@ export enum DisplayDataType {
 }
 
 export interface TextDisplay extends DisplayData {
+  type: DisplayDataType.Text;
   text: string;
 }
 
 export interface HtmlDisplay extends DisplayData {
+  type: DisplayDataType.Html;
   html: string;
 }
 
@@ -242,3 +277,102 @@ export interface ActionControlDefinition extends ControlDefinition {
   type: ControlDefinitionType.Action;
   actionId: string;
 }
+
+export enum ValidatorType {
+  Jsonata = "Jsonata",
+  Date = "Date",
+}
+export interface SchemaValidator {
+  type: string;
+}
+
+export interface JsonataValidator extends SchemaValidator {
+  type: ValidatorType.Jsonata;
+  expression: string;
+}
+
+export enum DateComparison {
+  NotBefore = "NotBefore",
+  NotAfter = "NotAfter",
+}
+
+export interface DateValidator extends SchemaValidator {
+  type: ValidatorType.Date;
+  comparison: DateComparison;
+  fixedDate?: string | null;
+  daysFromCurrent?: number | null;
+}
+
+export function isDataControlDefinition(
+  x: ControlDefinition,
+): x is DataControlDefinition {
+  return x.type === ControlDefinitionType.Data;
+}
+
+export function isGroupControlsDefinition(
+  x: ControlDefinition,
+): x is GroupedControlsDefinition {
+  return x.type === ControlDefinitionType.Group;
+}
+
+export function isDisplayControlsDefinition(
+  x: ControlDefinition,
+): x is DisplayControlDefinition {
+  return x.type === ControlDefinitionType.Display;
+}
+
+export function isActionControlsDefinition(
+  x: ControlDefinition,
+): x is ActionControlDefinition {
+  return x.type === ControlDefinitionType.Action;
+}
+
+export interface ControlVisitor<A> {
+  data(d: DataControlDefinition): A;
+  group(d: GroupedControlsDefinition): A;
+  display(d: DisplayControlDefinition): A;
+  action(d: ActionControlDefinition): A;
+}
+
+export function visitControlDefinition<A>(
+  x: ControlDefinition,
+  visitor: ControlVisitor<A>,
+  defaultValue: (c: ControlDefinition) => A,
+): A {
+  switch (x.type) {
+    case ControlDefinitionType.Action:
+      return visitor.action(x as ActionControlDefinition);
+    case ControlDefinitionType.Data:
+      return visitor.data(x as DataControlDefinition);
+    case ControlDefinitionType.Display:
+      return visitor.display(x as DisplayControlDefinition);
+    case ControlDefinitionType.Group:
+      return visitor.group(x as GroupedControlsDefinition);
+    default:
+      return defaultValue(x);
+  }
+}
+
+export function dataControl(
+  field: string,
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return { type: ControlDefinitionType.Data, field, ...options };
+}
+
+export function fieldValueExpr(
+  field: string,
+  value: any,
+): FieldValueExpression {
+  return { type: ExpressionType.FieldValue, field, value };
+}
+
+export function visibility(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Visible, expr };
+}
+
+export function isGridRenderer(
+  options: GroupRenderOptions,
+): options is GridRenderer {
+  return options.type === GroupRenderType.Grid;
+}

package/src/util.ts

@@ -0,0 +1,212 @@
+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));
+}
+
+export function fieldDisplayName(field: SchemaField) {
+  return field.displayName ?? field.field;
+}
+
+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)),
+  );
+}

package/tsconfig.json

@@ -1,18 +1,19 @@
 {
   "compilerOptions": {
-    "target": "ES2015",
+    "target": "ESNext",
     "lib": ["dom", "dom.iterable", "esnext"],
     "allowJs": true,
     "skipLibCheck": true,
     "strict": true,
+    "noEmit": true,
     "forceConsistentCasingInFileNames": true,
     "esModuleInterop": true,
     "declaration": true,
-    "module": "CommonJS",
+    "module": "ESNext",
     "moduleResolution": "node",
     "resolveJsonModule": true,
     "isolatedModules": true,
-    "jsx": "react",
+    "jsx": "preserve",
     "outDir": "lib"
   },
   "include": ["src/**/*.ts", "src/**/*.tsx"],