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

package/src/schemaBuilder.ts

@@ -1,25 +1,15 @@
-import {
-  CompoundField,
-  FieldOption,
-  FieldType,
-  ScalarField,
-  SchemaField,
-  SchemaFieldType,
-} from "./types";
+import { CompoundField, FieldOption, FieldType, SchemaField } from "./types";
 
 type AllowedSchema<T> = T extends string
-  ? ScalarField & {
-      schemaType: SchemaFieldType.Scalar;
+  ? SchemaField & {
       type: FieldType.String | FieldType.Date | FieldType.DateTime;
     }
   : T extends number
-  ? ScalarField & {
-      schemaType: SchemaFieldType.Scalar;
+  ? SchemaField & {
       type: FieldType.Int | FieldType.Double;
     }
   : T extends boolean
-  ? ScalarField & {
-      schemaType: SchemaFieldType.Scalar;
+  ? SchemaField & {
       type: FieldType.Bool;
     }
   : T extends Array<infer E>
@@ -28,25 +18,31 @@ type AllowedSchema<T> = T extends string
     }
   : T extends { [key: string]: any }
   ? CompoundField & {
-      schemaType: SchemaFieldType.Compound;
       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])
+    (x[1] as (n: string) => SchemaField)(x[0]),
   );
 }
 
 export function stringField(
   displayName: string,
-  options?: Partial<Omit<ScalarField, "schemaType" | "type">>
+  options?: Partial<Omit<SchemaField, "type">>,
 ) {
-  return makeScalarField({ type: FieldType.String, displayName, ...options });
+  return makeScalarField({
+    type: FieldType.String as const,
+    displayName,
+    ...options,
+  });
 }
 
 export function stringOptionsField(
@@ -54,29 +50,28 @@ export function stringOptionsField(
   ...options: FieldOption[]
 ) {
   return makeScalarField({
-    type: FieldType.String,
+    type: FieldType.String as const,
     displayName,
-    restrictions: { options },
+    options,
   });
 }
 
-export function withScalarOptions<S extends ScalarField>(
-  options: Partial<ScalarField>,
-  v: (name: string) => S
+export function withScalarOptions<S extends SchemaField>(
+  options: Partial<SchemaField>,
+  v: (name: string) => S,
 ): (name: string) => S {
   return (n) => ({ ...v(n), ...options });
 }
 
-export function makeScalarField<S extends Partial<ScalarField>>(
-  options: S
-): (name: string) => ScalarField & { schemaType: SchemaFieldType.Scalar } & S {
+export function makeScalarField<S extends Partial<SchemaField>>(
+  options: S,
+): (name: string) => SchemaField & S {
   return (n) => ({ ...defaultScalarField(n, n), ...options });
 }
 
 export function makeCompoundField<S extends Partial<CompoundField>>(
-  options: S
+  options: S,
 ): (name: string) => CompoundField & {
-  schemaType: SchemaFieldType.Compound;
   type: FieldType.Compound;
 } & S {
   return (n) => ({ ...defaultCompoundField(n, n, false), ...options });
@@ -84,27 +79,33 @@ export function makeCompoundField<S extends Partial<CompoundField>>(
 
 export function intField(
   displayName: string,
-  options?: Partial<Omit<ScalarField, "schemaType" | "type">>
+  options?: Partial<Omit<SchemaField, "type">>,
 ) {
-  return makeScalarField({ type: FieldType.Int, displayName, ...options });
+  return makeScalarField({
+    type: FieldType.Int as const,
+    displayName,
+    ...options,
+  });
 }
 
 export function boolField(
   displayName: string,
-  options?: Partial<Omit<ScalarField, "schemaType" | "type">>
+  options?: Partial<Omit<SchemaField, "type">>,
 ) {
-  return makeScalarField({ type: FieldType.Bool, displayName, ...options });
+  return makeScalarField({
+    type: FieldType.Bool as const,
+    displayName,
+    ...options,
+  });
 }
 
 export function compoundField<
-  Other extends Partial<Omit<CompoundField, "type" | "schemaType">>
+  Other extends Partial<Omit<CompoundField, "type" | "schemaType">>,
 >(
   displayName: string,
   fields: SchemaField[],
-  other: Other
+  other: Other,
 ): (name: string) => CompoundField & {
-  schemaType: SchemaFieldType.Compound;
-  type: FieldType.Compound;
   collection: Other["collection"];
 } {
   return (field) =>
@@ -112,56 +113,34 @@ export function compoundField<
       ...defaultCompoundField(field, displayName, false),
       ...other,
       children: fields,
-    } as any);
+    }) as any;
 }
 
 export function defaultScalarField(
   field: string,
-  displayName: string
-): ScalarField & {
-  schemaType: SchemaFieldType.Scalar;
+  displayName: string,
+): Omit<SchemaField, "type"> & {
   type: FieldType.String;
 } {
   return {
-    restrictions: {
-      options: [],
-    },
-    tags: [],
     field,
     displayName,
     type: FieldType.String,
-    collection: false,
-    searchable: false,
-    schemaType: SchemaFieldType.Scalar,
-    system: false,
-    entityRefType: "",
-    parentField: "",
-    required: false,
-    defaultValue: undefined,
-    onlyForTypes: [],
-    isTypeField: false,
   };
 }
 
 export function defaultCompoundField(
   field: string,
   displayName: string,
-  collection: boolean
+  collection: boolean,
 ): CompoundField & {
   type: FieldType.Compound;
-  schemaType: SchemaFieldType.Compound;
 } {
   return {
-    tags: [],
     field,
     displayName,
     type: FieldType.Compound,
     collection,
-    schemaType: SchemaFieldType.Compound,
-    system: false,
-    treeChildren: false,
     children: [],
-    onlyForTypes: [],
-    required: true,
   };
 }

package/src/tailwind.tsx

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

package/src/types.ts

@@ -1,18 +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 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 enum FieldType {
@@ -26,19 +26,13 @@ export enum FieldType {
   Compound = "Compound",
   AutoId = "AutoId",
   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 {
@@ -47,8 +41,9 @@ export interface FieldOption {
 }
 
 export interface CompoundField extends SchemaField {
+  type: FieldType.Compound;
   children: SchemaField[];
-  treeChildren: boolean;
+  treeChildren?: boolean;
 }
 
 export type AnyControlDefinition =
@@ -59,9 +54,10 @@ export type AnyControlDefinition =
 
 export interface ControlDefinition {
   type: string;
-  title?: string;
-  dynamic?: DynamicProperty[];
-  adornments?: ControlAdornment[];
+  title?: string | null;
+  dynamic?: DynamicProperty[] | null;
+  adornments?: ControlAdornment[] | null;
+  children?: ControlDefinition[] | null;
 }
 
 export enum ControlDefinitionType {
@@ -72,7 +68,7 @@ export enum ControlDefinitionType {
 }
 
 export interface DynamicProperty {
-  type: DynamicPropertyType;
+  type: string;
   expr: EntityExpression;
 }
 
@@ -82,7 +78,7 @@ export enum DynamicPropertyType {
 }
 
 export interface EntityExpression {
-  type: ExpressionType;
+  type: string;
 }
 
 export enum ExpressionType {
@@ -92,47 +88,68 @@ 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;
+  hideTitle?: boolean | null;
 }
 
 export interface RenderOptions {
-  type: DataRenderType;
+  type: string;
 }
 
 export enum DataRenderType {
@@ -144,34 +161,45 @@ export enum DataRenderType {
   UserSelection = "UserSelection",
   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;
 }
@@ -183,22 +211,24 @@ 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;
-  groupOptions: GroupRenderOptions;
+  compoundField?: string | null;
+  groupOptions?: GroupRenderOptions;
 }
 
 export interface GroupRenderOptions {
-  type: GroupRenderType;
-  hideTitle?: boolean;
+  type: string;
+  hideTitle?: boolean | null;
 }
 
 export enum GroupRenderType {
@@ -207,14 +237,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 {
@@ -223,7 +257,7 @@ export interface DisplayControlDefinition extends ControlDefinition {
 }
 
 export interface DisplayData {
-  type: DisplayDataType;
+  type: string;
 }
 
 export enum DisplayDataType {
@@ -232,10 +266,12 @@ export enum DisplayDataType {
 }
 
 export interface TextDisplay extends DisplayData {
+  type: DisplayDataType.Text;
   text: string;
 }
 
 export interface HtmlDisplay extends DisplayData {
+  type: DisplayDataType.Html;
   html: string;
 }
 
@@ -243,3 +279,83 @@ 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 isGridRenderer(
+  options: GroupRenderOptions,
+): options is GridRenderer {
+  return options.type === GroupRenderType.Grid;
+}