@react-typed-forms/schemas 3.0.0-dev.100

package/src/schemaBuilder.ts

@@ -0,0 +1,167 @@
+import {
+  CompoundField,
+  FieldOption,
+  FieldType,
+  ScalarField,
+  SchemaField,
+  SchemaFieldType,
+} from "./types";
+
+type AllowedSchema<T> = T extends string
+  ? ScalarField & {
+      schemaType: SchemaFieldType.Scalar;
+      type: FieldType.String | FieldType.Date | FieldType.DateTime;
+    }
+  : T extends number
+  ? ScalarField & {
+      schemaType: SchemaFieldType.Scalar;
+      type: FieldType.Int | FieldType.Double;
+    }
+  : T extends boolean
+  ? ScalarField & {
+      schemaType: SchemaFieldType.Scalar;
+      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 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<ScalarField, "schemaType" | "type">>
+) {
+  return makeScalarField({ type: FieldType.String, displayName, ...options });
+}
+
+export function stringOptionsField(
+  displayName: string,
+  ...options: FieldOption[]
+) {
+  return makeScalarField({
+    type: FieldType.String,
+    displayName,
+    restrictions: { options },
+  });
+}
+
+export function withScalarOptions<S extends ScalarField>(
+  options: Partial<ScalarField>,
+  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 {
+  return (n) => ({ ...defaultScalarField(n, n), ...options });
+}
+
+export function makeCompoundField<S extends Partial<CompoundField>>(
+  options: S
+): (name: string) => CompoundField & {
+  schemaType: SchemaFieldType.Compound;
+  type: FieldType.Compound;
+} & S {
+  return (n) => ({ ...defaultCompoundField(n, n, false), ...options });
+}
+
+export function intField(
+  displayName: string,
+  options?: Partial<Omit<ScalarField, "schemaType" | "type">>
+) {
+  return makeScalarField({ type: FieldType.Int, displayName, ...options });
+}
+
+export function boolField(
+  displayName: string,
+  options?: Partial<Omit<ScalarField, "schemaType" | "type">>
+) {
+  return makeScalarField({ type: FieldType.Bool, displayName, ...options });
+}
+
+export 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"];
+} {
+  return (field) =>
+    ({
+      ...defaultCompoundField(field, displayName, false),
+      ...other,
+      children: fields,
+    } as any);
+}
+
+export function defaultScalarField(
+  field: string,
+  displayName: string
+): ScalarField & {
+  schemaType: SchemaFieldType.Scalar;
+  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
+): 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/types.ts

@@ -0,0 +1,245 @@
+export interface SchemaField {
+  schemaType: SchemaFieldType;
+  field: string;
+  displayName: string;
+  type: FieldType;
+  tags: string[];
+  system: boolean;
+  collection: boolean;
+  onlyForTypes: string[];
+  required: boolean;
+}
+
+export enum SchemaFieldType {
+  Scalar = "Scalar",
+  Compound = "Compound",
+}
+
+export enum FieldType {
+  String = "String",
+  Bool = "Bool",
+  Int = "Int",
+  Date = "Date",
+  DateTime = "DateTime",
+  Double = "Double",
+  EntityRef = "EntityRef",
+  Compound = "Compound",
+  AutoId = "AutoId",
+  Image = "Image",
+}
+
+export interface ScalarField extends SchemaField {
+  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 {
+  children: SchemaField[];
+  treeChildren: boolean;
+}
+
+export type AnyControlDefinition =
+  | DataControlDefinition
+  | GroupedControlsDefinition
+  | ActionControlDefinition
+  | DisplayControlDefinition;
+
+export interface ControlDefinition {
+  type: string;
+  title?: string;
+  dynamic?: DynamicProperty[];
+  adornments?: ControlAdornment[];
+}
+
+export enum ControlDefinitionType {
+  Data = "Data",
+  Group = "Group",
+  Display = "Display",
+  Action = "Action",
+}
+
+export interface DynamicProperty {
+  type: DynamicPropertyType;
+  expr: EntityExpression;
+}
+
+export enum DynamicPropertyType {
+  Visible = "Visible",
+  DefaultValue = "DefaultValue",
+}
+
+export interface EntityExpression {
+  type: ExpressionType;
+}
+
+export enum ExpressionType {
+  Jsonata = "Jsonata",
+  FieldValue = "FieldValue",
+  UserMatch = "UserMatch",
+}
+
+export interface JsonataExpression extends EntityExpression {
+  expression: string;
+}
+
+export interface FieldValueExpression extends EntityExpression {
+  field: string;
+  value: any;
+}
+
+export interface UserMatchExpression extends EntityExpression {
+  userMatch: string;
+}
+
+export interface ControlAdornment {
+  type: ControlAdornmentType;
+}
+
+export enum ControlAdornmentType {
+  Tooltip = "Tooltip",
+  Accordion = "Accordion",
+}
+
+export interface TooltipAdornment extends ControlAdornment {
+  tooltip: string;
+}
+
+export interface AccordionAdornment extends ControlAdornment {
+  title: string;
+  defaultExpanded: boolean;
+}
+
+export interface DataControlDefinition extends ControlDefinition {
+  type: ControlDefinitionType.Data;
+  field: string;
+  required?: boolean;
+  renderOptions: RenderOptions;
+  defaultValue?: any;
+  readonly?: boolean;
+}
+
+export interface RenderOptions {
+  type: DataRenderType;
+}
+
+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 {}
+
+export interface StandardRenderer extends RenderOptions {}
+
+export interface HtmlEditorRenderOptions extends RenderOptions {
+  allowImages: boolean;
+}
+
+export interface DateTimeRenderOptions extends RenderOptions {
+  format?: string;
+}
+
+export interface IconListRenderOptions extends RenderOptions {
+  iconMappings: IconMapping[];
+}
+
+export interface IconMapping {
+  value: string;
+  materialIcon: string | undefined;
+}
+
+export interface CheckListRenderOptions extends RenderOptions {}
+
+export interface SynchronisedRenderOptions extends RenderOptions {
+  fieldToSync: string;
+  syncType: SyncTextType;
+}
+
+export enum SyncTextType {
+  Camel = "Camel",
+  Snake = "Snake",
+  Pascal = "Pascal",
+}
+
+export interface UserSelectionRenderOptions extends RenderOptions {
+  noGroups: boolean;
+  noUsers: boolean;
+}
+
+export interface IconSelectionRenderOptions extends RenderOptions {}
+
+export interface GroupedControlsDefinition extends ControlDefinition {
+  type: ControlDefinitionType.Group;
+  children: AnyControlDefinition[];
+  compoundField?: string;
+  groupOptions: GroupRenderOptions;
+}
+
+export interface GroupRenderOptions {
+  type: GroupRenderType;
+  hideTitle?: boolean;
+}
+
+export enum GroupRenderType {
+  Standard = "Standard",
+  Grid = "Grid",
+  GroupElement = "GroupElement",
+}
+
+export interface StandardGroupRenderer extends GroupRenderOptions {}
+
+export interface GroupElementRenderer extends GroupRenderOptions {
+  value: any;
+}
+
+export interface GridRenderer extends GroupRenderOptions {
+  columns: number | undefined;
+}
+
+export interface DisplayControlDefinition extends ControlDefinition {
+  type: ControlDefinitionType.Display;
+  displayData: DisplayData;
+}
+
+export interface DisplayData {
+  type: DisplayDataType;
+}
+
+export enum DisplayDataType {
+  Text = "Text",
+  Html = "Html",
+}
+
+export interface TextDisplay extends DisplayData {
+  text: string;
+}
+
+export interface HtmlDisplay extends DisplayData {
+  html: string;
+}
+
+export interface ActionControlDefinition extends ControlDefinition {
+  type: ControlDefinitionType.Action;
+  actionId: string;
+}

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"]
+}