@react-typed-forms/schemas 14.2.0 → 14.3.0

package/lib/renderers.d.ts

@@ -1,6 +1,6 @@
 import { ReactElement, ReactNode } from "react";
 import { ActionRendererProps, AdornmentProps, AdornmentRenderer, ArrayRendererProps, ControlLayoutProps, DataRendererProps, DisplayRendererProps, FormRenderer, GroupRendererProps, LabelRendererProps, LabelType, RenderedControl, VisibilityRendererProps } from "./controlRender";
-import { AccordionAdornment, ControlAdornment, IconAdornment, OptionalAdornment, SetFieldAdornment } from "./controlDefinition";
+import { AccordionAdornment, ControlAdornment, IconAdornment, OptionalAdornment, RenderOptions, SetFieldAdornment } from "./controlDefinition";
 export interface DefaultRenderers {
     data: DataRendererRegistration;
     label: LabelRendererRegistration;
@@ -23,7 +23,7 @@ export interface DataRendererRegistration {
     renderType?: string | string[];
     options?: boolean;
     collection?: boolean;
-    match?: (props: DataRendererProps) => boolean;
+    match?: (props: DataRendererProps, renderOptions: RenderOptions) => boolean;
     render: (props: DataRendererProps, renderers: FormRenderer) => ReactNode | ((layout: ControlLayoutProps) => ControlLayoutProps);
 }
 export interface LabelRendererRegistration {

package/lib/util.d.ts

@@ -1,4 +1,4 @@
-import { ControlActionHandler, ControlDefinition, DataControlDefinition, DisplayOnlyRenderOptions, GroupRenderOptions } from "./controlDefinition";
+import { ControlActionHandler, ControlDataVisitor, ControlDefinition, DataControlDefinition, DisplayOnlyRenderOptions, GroupRenderOptions } from "./controlDefinition";
 import { MutableRefObject } from "react";
 import { CompoundField, FieldOption, SchemaDataNode, SchemaField, SchemaNode } from "./schemaField";
 import { Control } from "@react-typed-forms/core";
@@ -247,9 +247,13 @@ export declare function isControlDisplayOnly(def: ControlDefinition): boolean;
 export declare function actionHandlers(...handlers: (ControlActionHandler | undefined)[]): ControlActionHandler;
 export declare function getDiffObject(dataNode: SchemaDataNode, force?: boolean): any;
 export declare function getNullToggler(c: Control<any>): Control<boolean>;
+export interface ExternalEditAction {
+    action: ActionRendererProps;
+    dontValidate?: boolean;
+}
 export interface ExternalEditData {
     data: unknown;
-    actions: ActionRendererProps[];
+    actions: ExternalEditAction[];
 }
 export declare function getExternalEditData(c: Control<any>): Control<ExternalEditData | undefined>;
 export declare function getLastDefinedValue<V>(control: Control<V>): Control<V>;
@@ -260,3 +264,4 @@ export declare function collectDifferences(dataNode: SchemaDataNode, values: unk
     editable: number;
     editing: number;
 };
+export declare function validationVisitor(onInvalid: (data: Control<unknown>) => void): ControlDataVisitor<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-typed-forms/schemas",
-  "version": "14.2.0",
+  "version": "14.3.0",
   "description": "",
   "type": "module",
   "main": "lib/index.cjs",
@@ -60,9 +60,10 @@
   },
   "gitHead": "698e16cd3ab31b7dd0528fc76536f4d3205ce8c6",
   "scripts": {
-    "build": "rimraf ./lib/ node_modules/.cache && microbundle -f modern,cjs --jsx React.createElement --jsxFragment React.Fragment",
+    "build": "rimraf ./lib/ node_modules/.cache && microbundle -f modern,cjs --no-compress --jsx React.createElement --jsxFragment React.Fragment",
     "watch": "microbundle -w -f modern,cjs --no-compress --jsx React.createElement --jsxFragment React.Fragment",
     "test": "jest --coverage",
+    "play": "tsx test/play.ts",
     "update-readme": "md-magic --path README.md",
     "gencode": "nswag swagger2tsclient /input:http://localhost:5216/swagger/v1/swagger.json /runtime:Net60 /output:src/types.ts /GenerateClientClasses:false /MarkOptionalProperties:false /Template:Fetch /TypeStyle:Interface /DateTimeType:string"
   }

package/src/controlBuilder.ts

@@ -0,0 +1,268 @@
+import {
+  AccordionAdornment,
+  ActionControlDefinition,
+  AutocompleteRenderOptions,
+  CheckListRenderOptions,
+  ControlAdornmentType,
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  DataRenderType,
+  DisplayControlDefinition,
+  DisplayDataType,
+  DisplayOnlyRenderOptions,
+  DynamicProperty,
+  DynamicPropertyType,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  HtmlDisplay,
+  JsonataRenderOptions,
+  RadioButtonRenderOptions,
+  RenderOptions,
+  TextDisplay,
+  TextfieldRenderOptions,
+} from "./controlDefinition";
+import { ActionRendererProps } from "./controlRender";
+import { useMemo } from "react";
+import { addMissingControls } from "./util";
+import { mergeFields, resolveSchemas } from "./schemaBuilder";
+import {
+  DateValidator,
+  JsonataValidator,
+  LengthValidator,
+  ValidatorType,
+} from "./schemaValidator";
+import { SchemaField, SchemaMap, SchemaNode } from "./schemaField";
+import {
+  DataExpression,
+  DataMatchExpression,
+  EntityExpression,
+  ExpressionType,
+  JsonataExpression,
+} from "./entityExpression";
+
+export function dataControl(
+  field: string,
+  title?: string | null,
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return { type: ControlDefinitionType.Data, field, title, ...options };
+}
+
+export function validatorOptions<A extends { type: string }>(
+  type: ValidatorType,
+): (options: Omit<A, "type">) => A {
+  return (o) => ({ type, ...o }) as A;
+}
+
+export function adornmentOptions<A extends { type: string }>(
+  type: ControlAdornmentType,
+): (options: Omit<A, "type">) => A {
+  return (o) => ({ type, ...o }) as A;
+}
+
+export function renderOptionsFor<A extends RenderOptions>(
+  type: DataRenderType,
+): (options: Omit<A, "type">) => { renderOptions: A } {
+  return (o) => ({ renderOptions: { type, ...o } as A });
+}
+
+export const autocompleteOptions = renderOptionsFor<AutocompleteRenderOptions>(
+  DataRenderType.Autocomplete,
+);
+
+export const checkListOptions = renderOptionsFor<CheckListRenderOptions>(
+  DataRenderType.CheckList,
+);
+
+export const radioButtonOptions = renderOptionsFor<RadioButtonRenderOptions>(
+  DataRenderType.Radio,
+);
+
+export const lengthValidatorOptions = validatorOptions<LengthValidator>(
+  ValidatorType.Length,
+);
+
+export const jsonataValidatorOptions = validatorOptions<JsonataValidator>(
+  ValidatorType.Jsonata,
+);
+
+export const dateValidatorOptions = validatorOptions<DateValidator>(
+  ValidatorType.Date,
+);
+
+export const accordionOptions = adornmentOptions<AccordionAdornment>(
+  ControlAdornmentType.Accordion,
+);
+
+export const textfieldOptions = renderOptionsFor<TextfieldRenderOptions>(
+  DataRenderType.Textfield,
+);
+
+export const displayOnlyOptions = renderOptionsFor<DisplayOnlyRenderOptions>(
+  DataRenderType.DisplayOnly,
+);
+
+export const jsonataOptions = renderOptionsFor<JsonataRenderOptions>(
+  DataRenderType.Jsonata,
+);
+
+export function textDisplayControl(
+  text: string,
+  options?: Partial<DisplayControlDefinition>,
+): DisplayControlDefinition {
+  return {
+    type: ControlDefinitionType.Display,
+    displayData: { type: DisplayDataType.Text, text } as TextDisplay,
+    ...options,
+  };
+}
+
+export function htmlDisplayControl(
+  html: string,
+  options?: Partial<DisplayControlDefinition>,
+): DisplayControlDefinition {
+  return {
+    type: ControlDefinitionType.Display,
+    displayData: { type: DisplayDataType.Html, html } as HtmlDisplay,
+    ...options,
+  };
+}
+
+export function dynamicDefaultValue(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.DefaultValue, expr };
+}
+
+export function dynamicReadonly(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Readonly, expr };
+}
+
+export function dynamicVisibility(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Visible, expr };
+}
+
+export function dynamicDisabled(expr: EntityExpression): DynamicProperty {
+  return { type: DynamicPropertyType.Disabled, expr };
+}
+
+export function fieldExpr(field: string): DataExpression {
+  return { type: ExpressionType.Data, field };
+}
+
+export function fieldEqExpr(field: string, value: any): DataMatchExpression {
+  return { type: ExpressionType.DataMatch, field, value };
+}
+export function jsonataExpr(expression: string): JsonataExpression {
+  return { type: ExpressionType.Jsonata, expression };
+}
+
+export function groupedControl(
+  children: ControlDefinition[],
+  title?: string,
+  options?: Partial<GroupedControlsDefinition>,
+): GroupedControlsDefinition {
+  return {
+    type: ControlDefinitionType.Group,
+    children,
+    title,
+    groupOptions: { type: "Standard", hideTitle: !title },
+    ...options,
+  };
+}
+export function compoundControl(
+  field: string,
+  title: string | undefined,
+  children: ControlDefinition[],
+  options?: Partial<DataControlDefinition>,
+): DataControlDefinition {
+  return {
+    type: ControlDefinitionType.Data,
+    field,
+    children,
+    title,
+    renderOptions: { type: "Standard" },
+    ...options,
+  };
+}
+
+export function actionControl(
+  actionText: string,
+  actionId: string,
+  options?: Partial<ActionControlDefinition>,
+): ActionControlDefinition {
+  return {
+    type: ControlDefinitionType.Action,
+    title: actionText,
+    actionId,
+    ...options,
+  };
+}
+export function createAction(
+  actionId: string,
+  onClick: () => void,
+  actionText?: string,
+  options?: Partial<ActionRendererProps>,
+): ActionRendererProps {
+  return { actionId, onClick, actionText: actionText ?? actionId, ...options };
+}
+
+export const emptyGroupDefinition: GroupedControlsDefinition = {
+  type: ControlDefinitionType.Group,
+  children: [],
+  groupOptions: { type: GroupRenderType.Standard, hideTitle: true },
+};
+
+export function useControlDefinitionForSchema(
+  sf: SchemaField[],
+  definition: GroupedControlsDefinition = emptyGroupDefinition,
+): GroupedControlsDefinition {
+  return useMemo<GroupedControlsDefinition>(
+    () => ({
+      ...definition,
+      children: addMissingControls(sf, definition.children ?? []),
+    }),
+    [sf, definition],
+  );
+}
+
+export interface EditorGroup {
+  parent: string;
+  group: GroupedControlsDefinition;
+}
+
+export interface CustomRenderOptions {
+  value: string;
+  name: string;
+  fields?: SchemaField[];
+  groups?: EditorGroup[];
+  applies?: (sf: SchemaNode) => boolean;
+}
+
+export type ControlDefinitionExtension = {
+  RenderOptions?: CustomRenderOptions | CustomRenderOptions[];
+  GroupRenderOptions?: CustomRenderOptions | CustomRenderOptions[];
+  ControlAdornment?: CustomRenderOptions | CustomRenderOptions[];
+  SchemaValidator?: CustomRenderOptions | CustomRenderOptions[];
+  DisplayData?: CustomRenderOptions | CustomRenderOptions[];
+};
+
+export function applyExtensionToSchema<A extends SchemaMap>(
+  schemaMap: A,
+  extension: ControlDefinitionExtension,
+): A {
+  const outMap = { ...schemaMap };
+  Object.entries(extension).forEach(([field, cro]) => {
+    outMap[field as keyof A] = (Array.isArray(cro) ? cro : [cro]).reduce(
+      (a, cr) => mergeFields(a, cr.name, cr.value, cr.fields ?? []),
+      outMap[field],
+    ) as A[string];
+  });
+  return outMap;
+}
+
+export function applyExtensionsToSchema<A extends SchemaMap>(
+  schemaMap: A,
+  extensions: ControlDefinitionExtension[],
+) {
+  return resolveSchemas(extensions.reduce(applyExtensionToSchema, schemaMap));
+}