@react-typed-forms/schemas 8.2.0 → 9.0.0

package/src/schemaBuilder.ts

@@ -1,171 +0,0 @@
-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, 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]),
-  );
-}
-
-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,
-  S2 extends Partial<SchemaField>,
->(options: S2, v: (name: string) => S): (name: string) => S & S2 {
-  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 {
-    field,
-    displayName,
-    type: FieldType.Compound,
-    collection,
-    children: [],
-  };
-}
-
-export function mergeField(
-  field: SchemaField,
-  mergeInto: SchemaField[],
-): SchemaField[] {
-  const existing = mergeInto.find((x) => x.field === field.field);
-  if (existing) {
-    return mergeInto.map((x) =>
-      x !== existing
-        ? x
-        : {
-            ...x,
-            onlyForTypes: mergeTypes(x.onlyForTypes, field.onlyForTypes),
-          },
-    );
-  }
-  return [...mergeInto, field];
-
-  function mergeTypes(f?: string[] | null, s?: string[] | null) {
-    if (!f) return s;
-    if (!s) return f;
-    const extras = s.filter((x) => !f.includes(x));
-    return extras.length ? [...f, ...extras] : f;
-  }
-}

package/src/schemaInterface.ts

@@ -1,31 +0,0 @@
-import { FieldType, SchemaField, SchemaInterface } from "./types";
-
-export const defaultSchemaInterface: SchemaInterface = {
-  isEmptyValue: defaultIsEmpty,
-  textValue: defaultTextValue,
-};
-
-export function defaultIsEmpty(f: SchemaField, value: any): boolean {
-  if (f.collection)
-    return Array.isArray(value) ? value.length === 0 : value == null;
-  switch (f.type) {
-    case FieldType.String:
-      return !value;
-    default:
-      return value == null;
-  }
-}
-
-export function defaultTextValue(
-  f: SchemaField,
-  value: any,
-): string | undefined {
-  switch (f.type) {
-    case FieldType.DateTime:
-      return new Date(value).toLocaleDateString();
-    case FieldType.Date:
-      return new Date(value).toLocaleDateString();
-    default:
-      return value != null ? value.toString() : undefined;
-  }
-}

package/src/tailwind.tsx

@@ -1,29 +0,0 @@
-import React from "react";
-import { DefaultRendererOptions } from "./renderers";
-
-export const defaultTailwindTheme = {
-  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: "flex flex-col gap-4",
-    gridClassName: "gap-x-2 gap-y-4",
-    flexClassName: "gap-2",
-  },
-  action: {
-    className: "bg-primary rounded-lg p-3 text-white",
-  },
-  layout: {
-    className: "flex flex-col",
-    errorClass: "text-sm text-danger-500",
-  },
-  data: {
-    displayOnlyClass: "flex flex-row items-center gap-2",
-  },
-} satisfies DefaultRendererOptions;

package/src/types.ts

@@ -1,423 +0,0 @@
-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;
-  notNullable?: boolean | null;
-  defaultValue?: any;
-  isTypeField?: boolean | null;
-  searchable?: boolean | null;
-  options?: FieldOption[] | null;
-  validators?: SchemaValidator[] | 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 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 SchemaInterface {
-  isEmptyValue(field: SchemaField, value: any): boolean;
-  textValue(
-    field: SchemaField,
-    value: any,
-    element?: boolean,
-  ): string | undefined;
-}
-export interface ControlDefinition {
-  type: string;
-  title?: string | null;
-  styleClass?: string | null;
-  layoutClass?: string | null;
-  labelClass?: string | null;
-  dynamic?: DynamicProperty[] | null;
-  adornments?: ControlAdornment[] | null;
-  children?: ControlDefinition[] | 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",
-  Readonly = "Readonly",
-  Disabled = "Disabled",
-  Display = "Display",
-  Style = "Style",
-  LayoutStyle = "LayoutStyle",
-  AllowedOptions = "AllowedOptions",
-  Label = "Label",
-}
-
-export interface EntityExpression {
-  type: string;
-}
-
-export enum ExpressionType {
-  Jsonata = "Jsonata",
-  Data = "Data",
-  DataMatch = "FieldValue",
-  UserMatch = "UserMatch",
-}
-
-export interface JsonataExpression extends EntityExpression {
-  type: ExpressionType.Jsonata;
-  expression: string;
-}
-
-export interface DataExpression extends EntityExpression {
-  type: ExpressionType.Data;
-  field: string;
-}
-
-export interface DataMatchExpression extends EntityExpression {
-  type: ExpressionType.DataMatch;
-  field: string;
-  value: any;
-}
-
-export interface UserMatchExpression extends EntityExpression {
-  type: ExpressionType.UserMatch;
-  userMatch: string;
-}
-
-export interface ControlAdornment {
-  type: string;
-}
-
-export enum AdornmentPlacement {
-  ControlStart = "ControlStart",
-  ControlEnd = "ControlEnd",
-  LabelStart = "LabelStart",
-  LabelEnd = "LabelEnd",
-}
-
-export enum ControlAdornmentType {
-  Tooltip = "Tooltip",
-  Accordion = "Accordion",
-  HelpText = "HelpText",
-  Icon = "Icon",
-}
-
-export interface IconAdornment extends ControlAdornment {
-  type: ControlAdornmentType.Icon;
-  iconClass: string;
-  placement?: AdornmentPlacement | null;
-}
-
-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 | null;
-}
-
-export interface DataControlDefinition extends ControlDefinition {
-  type: ControlDefinitionType.Data;
-  field: string;
-  required?: boolean | null;
-  renderOptions?: RenderOptions | null;
-  defaultValue?: any;
-  readonly?: boolean | null;
-  validators?: SchemaValidator[] | null;
-  hideTitle?: boolean | null;
-  dontClearHidden?: 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",
-  Checkbox = "Checkbox",
-  Dropdown = "Dropdown",
-  DisplayOnly = "DisplayOnly",
-}
-
-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 DisplayOnlyRenderOptions extends RenderOptions {
-  type: DataRenderType.DisplayOnly;
-  emptyText?: string | null;
-  sampleText?: string | null;
-}
-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;
-  compoundField?: string | null;
-  groupOptions?: GroupRenderOptions;
-}
-
-export interface GroupRenderOptions {
-  type: string;
-  hideTitle?: boolean | null;
-}
-
-export enum GroupRenderType {
-  Standard = "Standard",
-  Grid = "Grid",
-  Flex = "Flex",
-  GroupElement = "GroupElement",
-}
-
-export interface StandardGroupRenderer extends GroupRenderOptions {
-  type: GroupRenderType.Standard;
-}
-
-export interface FlexRenderer extends GroupRenderOptions {
-  type: GroupRenderType.Flex;
-  direction?: string | null;
-  gap?: string | null;
-}
-
-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",
-  Icon = "Icon",
-}
-export interface TextDisplay extends DisplayData {
-  type: DisplayDataType.Text;
-  text: string;
-}
-
-export interface IconDisplay extends DisplayData {
-  type: DisplayDataType.Icon;
-  iconClass: string;
-}
-
-export interface HtmlDisplay extends DisplayData {
-  type: DisplayDataType.Html;
-  html: string;
-}
-
-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;
-}
-
-export function isFlexRenderer(
-  options: GroupRenderOptions,
-): options is FlexRenderer {
-  return options.type === GroupRenderType.Flex;
-}
-
-export function isDisplayOnlyRenderer(
-  options: RenderOptions,
-): options is DisplayOnlyRenderOptions {
-  return options.type === DataRenderType.DisplayOnly;
-}