@react-typed-forms/schemas 1.0.0-dev.10

package/src/schemaBuilder.ts

@@ -0,0 +1,148 @@
+import { CompoundField, FieldOption, FieldType, SchemaField } from "./types";
+
+type AllowedSchema<T> = T extends string
+  ? SchemaField & {
+      type: FieldType.String | FieldType.Date | FieldType.DateTime;
+    }
+  : T extends number
+  ? SchemaField & {
+      type: FieldType.Int | FieldType.Double;
+    }
+  : T extends boolean
+  ? SchemaField & {
+      type: FieldType.Bool;
+    }
+  : T extends Array<infer E>
+  ? AllowedSchema<E> & {
+      collection: true;
+    }
+  : T extends { [key: string]: any }
+  ? CompoundField & {
+      type: FieldType.Compound;
+    }
+  : SchemaField & { type: FieldType.Any };
+type AllowedField<T> = (name: string) => AllowedSchema<T>;
+
+export function buildSchema<T>(def: {
+  [K in keyof T]-?: AllowedField<T[K]>;
+}): SchemaField[] {
+  return Object.entries(def).map((x) =>
+    (x[1] as (n: string) => SchemaField)(x[0])
+  );
+}
+
+export function stringField(
+  displayName: string,
+  options?: Partial<Omit<SchemaField, "type">>
+) {
+  return makeScalarField({
+    type: FieldType.String as const,
+    displayName,
+    ...options,
+  });
+}
+
+export function stringOptionsField(
+  displayName: string,
+  ...options: FieldOption[]
+) {
+  return makeScalarField({
+    type: FieldType.String as const,
+    displayName,
+    options,
+  });
+}
+
+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<SchemaField>>(
+  options: S
+): (name: string) => SchemaField & S {
+  return (n) => ({ ...defaultScalarField(n, n), ...options });
+}
+
+export function makeCompoundField<S extends Partial<CompoundField>>(
+  options: S
+): (name: string) => CompoundField & {
+  type: FieldType.Compound;
+} & S {
+  return (n) => ({ ...defaultCompoundField(n, n, false), ...options });
+}
+
+export function intField(
+  displayName: string,
+  options?: Partial<Omit<SchemaField, "type">>
+) {
+  return makeScalarField({
+    type: FieldType.Int as const,
+    displayName,
+    ...options,
+  });
+}
+
+export function boolField(
+  displayName: string,
+  options?: Partial<Omit<SchemaField, "type">>
+) {
+  return makeScalarField({
+    type: FieldType.Bool as const,
+    displayName,
+    ...options,
+  });
+}
+
+export function compoundField<
+  Other extends Partial<Omit<CompoundField, "type" | "schemaType">>
+>(
+  displayName: string,
+  fields: SchemaField[],
+  other: Other
+): (name: string) => CompoundField & {
+  collection: Other["collection"];
+} {
+  return (field) =>
+    ({
+      ...defaultCompoundField(field, displayName, false),
+      ...other,
+      children: fields,
+    } as any);
+}
+
+export function defaultScalarField(
+  field: string,
+  displayName: string
+): Omit<SchemaField, "type"> & {
+  type: FieldType.String;
+} {
+  return {
+    field,
+    displayName,
+    type: FieldType.String,
+  };
+}
+
+export function defaultCompoundField(
+  field: string,
+  displayName: string,
+  collection: boolean
+): CompoundField & {
+  type: FieldType.Compound;
+} {
+  return {
+    tags: [],
+    field,
+    displayName,
+    type: FieldType.Compound,
+    collection,
+    system: false,
+    treeChildren: false,
+    children: [],
+    onlyForTypes: [],
+    required: true,
+  };
+}

package/src/types.ts

@@ -0,0 +1,321 @@
+import { DataControlProperties } from "./controlRender";
+
+export interface SchemaField {
+  type: string;
+  field: string;
+  displayName?: string | null;
+  tags?: string[] | null;
+  system?: boolean | null;
+  collection?: boolean | null;
+  onlyForTypes?: string[] | null;
+  required?: boolean | null;
+  defaultValue?: any;
+  isTypeField?: boolean | null;
+  searchable?: boolean | null;
+  options?: FieldOption[] | null;
+  /**
+   * @deprecated Use options directly
+   */
+  restrictions?: SchemaRestrictions | undefined | null;
+}
+
+export enum FieldType {
+  String = "String",
+  Bool = "Bool",
+  Int = "Int",
+  Date = "Date",
+  DateTime = "DateTime",
+  Double = "Double",
+  EntityRef = "EntityRef",
+  Compound = "Compound",
+  AutoId = "AutoId",
+  Image = "Image",
+  Any = "Any",
+}
+
+export interface EntityRefField extends SchemaField {
+  type: FieldType.EntityRef;
+  entityRefType: string;
+  parentField: string;
+}
+
+export interface SchemaRestrictions {
+  options?: FieldOption[] | null;
+}
+
+export interface FieldOption {
+  name: string;
+  value: any;
+}
+
+export interface CompoundField extends SchemaField {
+  type: FieldType.Compound;
+  children: SchemaField[];
+  treeChildren?: boolean;
+}
+
+export type AnyControlDefinition =
+  | DataControlDefinition
+  | GroupedControlsDefinition
+  | ActionControlDefinition
+  | DisplayControlDefinition;
+
+export interface ControlDefinition {
+  type: string;
+  title?: string | null;
+  dynamic?: DynamicProperty[] | null;
+  adornments?: ControlAdornment[] | null;
+}
+
+export enum ControlDefinitionType {
+  Data = "Data",
+  Group = "Group",
+  Display = "Display",
+  Action = "Action",
+}
+
+export interface DynamicProperty {
+  type: string;
+  expr: EntityExpression;
+}
+
+export enum DynamicPropertyType {
+  Visible = "Visible",
+  DefaultValue = "DefaultValue",
+}
+
+export interface EntityExpression {
+  type: string;
+}
+
+export enum ExpressionType {
+  Jsonata = "Jsonata",
+  FieldValue = "FieldValue",
+  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: string;
+}
+
+export enum ControlAdornmentType {
+  Tooltip = "Tooltip",
+  Accordion = "Accordion",
+}
+
+export interface TooltipAdornment extends ControlAdornment {
+  type: ControlAdornmentType.Tooltip;
+  tooltip: string;
+}
+
+export interface AccordionAdornment extends ControlAdornment {
+  type: ControlAdornmentType.Accordion;
+  title: string;
+  defaultExpanded: boolean;
+}
+
+export interface DataControlDefinition extends ControlDefinition {
+  type: ControlDefinitionType.Data;
+  field: string;
+  required?: boolean | null;
+  renderOptions?: RenderOptions | null;
+  defaultValue?: any;
+  readonly?: boolean | null;
+}
+
+export interface RenderOptions {
+  type: string;
+}
+
+export enum DataRenderType {
+  Standard = "Standard",
+  Radio = "Radio",
+  HtmlEditor = "HtmlEditor",
+  IconList = "IconList",
+  CheckList = "CheckList",
+  UserSelection = "UserSelection",
+  Synchronised = "Synchronised",
+  IconSelector = "IconSelector",
+  DateTime = "DateTime",
+}
+
+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 {
+  type: DataRenderType.DateTime;
+  format?: string | null;
+}
+
+export interface IconListRenderOptions extends RenderOptions {
+  type: DataRenderType.IconList;
+  iconMappings: IconMapping[];
+}
+
+export interface IconMapping {
+  value: string;
+  materialIcon?: string | null;
+}
+
+export interface CheckListRenderOptions extends RenderOptions {
+  type: DataRenderType.CheckList;
+}
+
+export interface SynchronisedRenderOptions extends RenderOptions {
+  type: DataRenderType.Synchronised;
+  fieldToSync: string;
+  syncType: SyncTextType;
+}
+
+export enum SyncTextType {
+  Camel = "Camel",
+  Snake = "Snake",
+  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: ControlDefinition[];
+  compoundField?: string | null;
+  groupOptions: GroupRenderOptions;
+}
+
+export interface GroupRenderOptions {
+  type: string;
+  hideTitle?: boolean | null;
+}
+
+export enum GroupRenderType {
+  Standard = "Standard",
+  Grid = "Grid",
+  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 {
+  type: GroupRenderType.Grid;
+  columns?: number | null;
+}
+
+export interface DisplayControlDefinition extends ControlDefinition {
+  type: ControlDefinitionType.Display;
+  displayData: DisplayData;
+}
+
+export interface DisplayData {
+  type: string;
+}
+
+export 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 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);
+  }
+}

package/tsconfig.json

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