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

package/src/util.ts

@@ -0,0 +1,360 @@
+import {
+  ActionControlDefinition,
+  CompoundField,
+  ControlDefinition,
+  ControlDefinitionType,
+  DataControlDefinition,
+  DataRenderType,
+  DisplayControlDefinition,
+  FieldOption,
+  FieldType,
+  GridRenderer,
+  GroupedControlsDefinition,
+  GroupRenderType,
+  SchemaField,
+  visitControlDefinition,
+} from "./types";
+import { MutableRefObject, useRef } from "react";
+import { Control } from "@react-typed-forms/core";
+
+export interface ControlGroupContext {
+  groupControl: Control<any>;
+  fields: SchemaField[];
+}
+
+export function applyDefaultValues(
+  v: { [k: string]: any } | undefined,
+  fields: SchemaField[],
+): any {
+  if (!v) return defaultValueForFields(fields);
+  const applyValue = fields.filter(
+    (x) => isCompoundField(x) || !(x.field in v),
+  );
+  if (!applyValue.length) return v;
+  const out = { ...v };
+  applyValue.forEach((x) => {
+    out[x.field] =
+      x.field in v
+        ? applyDefaultForField(v[x.field], x, fields)
+        : defaultValueForField(x);
+  });
+  return out;
+}
+
+export function applyDefaultForField(
+  v: any,
+  field: SchemaField,
+  parent: SchemaField[],
+  notElement?: boolean,
+): any {
+  if (field.collection && !notElement) {
+    return ((v as any[]) ?? []).map((x) =>
+      applyDefaultForField(x, field, parent, true),
+    );
+  }
+  if (isCompoundField(field)) {
+    if (!v && !field.required) return v;
+    return applyDefaultValues(v, field.treeChildren ? parent : field.children);
+  }
+  return defaultValueForField(field);
+}
+
+export function defaultValueForFields(fields: SchemaField[]): any {
+  return Object.fromEntries(
+    fields.map((x) => [x.field, defaultValueForField(x)]),
+  );
+}
+
+export function defaultValueForField(
+  sf: SchemaField,
+  required?: boolean | null,
+): any {
+  if (sf.defaultValue !== undefined) return sf.defaultValue;
+  const isRequired = !!(required || sf.required);
+  if (isCompoundField(sf)) {
+    if (isRequired) {
+      const childValue = defaultValueForFields(sf.children);
+      return sf.collection ? [childValue] : childValue;
+    }
+    return sf.notNullable ? (sf.collection ? [] : {}) : undefined;
+  }
+  if (sf.collection) {
+    return isRequired ? [undefined] : [];
+  }
+  return undefined;
+}
+
+export function elementValueForField(sf: SchemaField): any {
+  if (isCompoundField(sf)) {
+    return defaultValueForFields(sf.children);
+  }
+  return sf.defaultValue;
+}
+
+export function findScalarField(
+  fields: SchemaField[],
+  field: string,
+): SchemaField | undefined {
+  return findField(fields, field);
+}
+
+export function findCompoundField(
+  fields: SchemaField[],
+  field: string,
+): CompoundField | undefined {
+  return findField(fields, field) as CompoundField | undefined;
+}
+
+export function findField(
+  fields: SchemaField[],
+  field: string,
+): SchemaField | undefined {
+  return fields.find((x) => x.field === field);
+}
+
+export function isScalarField(sf: SchemaField): sf is SchemaField {
+  return !isCompoundField(sf);
+}
+
+export function isCompoundField(sf: SchemaField): sf is CompoundField {
+  return sf.type === FieldType.Compound;
+}
+
+export function isDataControl(
+  c: ControlDefinition,
+): c is DataControlDefinition {
+  return c.type === ControlDefinitionType.Data;
+}
+
+export function isGroupControl(
+  c: ControlDefinition,
+): c is GroupedControlsDefinition {
+  return c.type === ControlDefinitionType.Group;
+}
+
+export function fieldHasTag(field: SchemaField, tag: string) {
+  return Boolean(field.tags?.includes(tag));
+}
+
+export function fieldDisplayName(field: SchemaField) {
+  return field.displayName ?? field.field;
+}
+
+export function hasOptions(o: { options: FieldOption[] | undefined | null }) {
+  return (o.options?.length ?? 0) > 0;
+}
+
+export function defaultControlForField(
+  sf: SchemaField,
+): DataControlDefinition | GroupedControlsDefinition {
+  if (isCompoundField(sf)) {
+    return {
+      type: ControlDefinitionType.Group,
+      title: sf.displayName,
+      compoundField: sf.field,
+      groupOptions: {
+        type: GroupRenderType.Grid,
+        hideTitle: false,
+      } as GridRenderer,
+      children: sf.children.map(defaultControlForField),
+    } satisfies GroupedControlsDefinition;
+  } else if (isScalarField(sf)) {
+    const htmlEditor = sf.tags?.includes("_HtmlEditor");
+    return {
+      type: ControlDefinitionType.Data,
+      title: sf.displayName,
+      field: sf.field,
+      required: sf.required,
+      renderOptions: {
+        type: htmlEditor ? DataRenderType.HtmlEditor : DataRenderType.Standard,
+      },
+    } satisfies DataControlDefinition;
+  }
+  throw "Unknown schema field";
+}
+function findReferencedControl(
+  field: string,
+  control: ControlDefinition,
+): ControlDefinition | undefined {
+  if (isDataControl(control) && field === control.field) return control;
+  if (isGroupControl(control)) {
+    if (control.compoundField)
+      return field === control.compoundField ? control : undefined;
+    return findReferencedControlInArray(field, control.children ?? []);
+  }
+  return undefined;
+}
+
+function findReferencedControlInArray(
+  field: string,
+  controls: ControlDefinition[],
+): ControlDefinition | undefined {
+  for (const c of controls) {
+    const ref = findReferencedControl(field, c);
+    if (ref) return ref;
+  }
+  return undefined;
+}
+
+export function addMissingControls(
+  fields: SchemaField[],
+  controls: ControlDefinition[],
+): ControlDefinition[] {
+  const changes: {
+    field: SchemaField;
+    existing: ControlDefinition | undefined;
+  }[] = fields.flatMap((x) => {
+    if (fieldHasTag(x, "_NoControl")) return [];
+    const existing = findReferencedControlInArray(x.field, controls);
+    if (!existing || isCompoundField(x)) return { field: x, existing };
+    return [];
+  });
+  const changedCompounds = controls.map((x) => {
+    const ex = changes.find((c) => c.existing === x);
+    if (!ex) return x;
+    const cf = x as GroupedControlsDefinition;
+    return {
+      ...cf,
+      children: addMissingControls(
+        (ex.field as CompoundField).children,
+        cf.children ?? [],
+      ),
+    };
+  });
+  return changedCompounds.concat(
+    changes
+      .filter((x) => !x.existing)
+      .map((x) => defaultControlForField(x.field)),
+  );
+}
+
+export function useUpdatedRef<A>(a: A): MutableRefObject<A> {
+  const r = useRef(a);
+  r.current = a;
+  return r;
+}
+
+export function getTypeField(
+  context: ControlGroupContext,
+): Control<string> | undefined {
+  const typeSchemaField = context.fields.find((x) => x.isTypeField);
+  return typeSchemaField
+    ? context.groupControl.fields?.[typeSchemaField.field]
+    : undefined;
+}
+
+export function visitControlDataArray<A>(
+  controls: ControlDefinition[] | undefined | null,
+  context: ControlGroupContext,
+  cb: (
+    definition: DataControlDefinition,
+    field: SchemaField,
+    control: Control<any>,
+    element: boolean,
+  ) => A | undefined,
+): A | undefined {
+  if (!controls) return undefined;
+  for (const c of controls) {
+    const r = visitControlData(c, context, cb);
+    if (r !== undefined) return r;
+  }
+  return undefined;
+}
+
+export function visitControlData<A>(
+  definition: ControlDefinition,
+  ctx: ControlGroupContext,
+  cb: (
+    definition: DataControlDefinition,
+    field: SchemaField,
+    control: Control<any>,
+    element: boolean,
+  ) => A | undefined,
+): A | undefined {
+  return visitControlDefinition<A | undefined>(
+    definition,
+    {
+      data(def: DataControlDefinition) {
+        return processData(def, def.field, def.children);
+      },
+      group(d: GroupedControlsDefinition) {
+        return processData(undefined, d.compoundField, d.children);
+      },
+      action: () => undefined,
+      display: () => undefined,
+    },
+    () => undefined,
+  );
+
+  function processData(
+    def: DataControlDefinition | undefined,
+    fieldName: string | undefined | null,
+    children: ControlDefinition[] | null | undefined,
+  ) {
+    const fieldData = fieldName ? findField(ctx.fields, fieldName) : undefined;
+    if (!fieldData)
+      return !fieldName ? visitControlDataArray(children, ctx, cb) : undefined;
+
+    const control = ctx.groupControl.fields[fieldData.field];
+    const result = def ? cb(def, fieldData, control, false) : undefined;
+    if (result !== undefined) return result;
+    if (fieldData.collection) {
+      for (const c of control.elements ?? []) {
+        const elemResult = def ? cb(def, fieldData, c, true) : undefined;
+        if (elemResult !== undefined) return elemResult;
+        if (isCompoundField(fieldData)) {
+          const cfResult = visitControlDataArray(
+            children,
+            { fields: fieldData.children, groupControl: c },
+            cb,
+          );
+          if (cfResult !== undefined) return cfResult;
+        }
+      }
+    }
+  }
+}
+
+export function cleanDataForSchema(
+  v: { [k: string]: any } | undefined,
+  fields: SchemaField[],
+): any {
+  if (!v) return v;
+  const typeField = fields.find((x) => x.isTypeField);
+  if (!typeField) return v;
+  const typeValue = v[typeField.field];
+  const cleanableFields = fields.filter(
+    (x) => isCompoundField(x) || (x.onlyForTypes?.length ?? 0) > 0,
+  );
+  if (!cleanableFields.length) return v;
+  const out = { ...v };
+  cleanableFields.forEach((x) => {
+    const childValue = v[x.field];
+    if (
+      x.onlyForTypes?.includes(typeValue) === false ||
+      (!x.notNullable && canBeNull())
+    ) {
+      delete out[x.field];
+      return;
+    }
+    if (isCompoundField(x)) {
+      const childFields = x.treeChildren ? fields : x.children;
+      if (x.collection) {
+        if (Array.isArray(childValue)) {
+          out[x.field] = childValue.map((cv) =>
+            cleanDataForSchema(cv, childFields),
+          );
+        }
+      } else {
+        out[x.field] = cleanDataForSchema(childValue, childFields);
+      }
+    }
+    function canBeNull() {
+      return (
+        x.collection && Array.isArray(childValue) && !childValue.length
+        //|| (x.type === FieldType.Bool && childValue === false)
+      );
+    }
+  });
+  return out;
+}

package/src/validators.ts

@@ -0,0 +1,116 @@
+import {
+  ControlDefinition,
+  DataControlDefinition,
+  DateComparison,
+  DateValidator,
+  isDataControlDefinition,
+  JsonataValidator,
+  ValidatorType,
+} from "./types";
+import {
+  Control,
+  useControlEffect,
+  useValidator,
+  useValueChangeEffect,
+} from "@react-typed-forms/core";
+import { useCallback } from "react";
+import { ControlGroupContext, useUpdatedRef } from "./util";
+import { useJsonataExpression } from "./hooks";
+
+export function useValidationHook(
+  definition: ControlDefinition,
+): (
+  control: Control<any>,
+  hidden: boolean,
+  groupContext: ControlGroupContext,
+) => void {
+  const validatorTypes = isDataControlDefinition(definition)
+    ? definition.validators?.map((x) => x.type) ?? []
+    : null;
+  const r = useUpdatedRef(definition as DataControlDefinition);
+  return useCallback(
+    (control, hidden, groupContext) => {
+      if (!validatorTypes) return;
+      const dd = r.current;
+
+      useValueChangeEffect(control, () => control.setError("default", ""));
+      useValidator(
+        control,
+        (v) =>
+          !hidden &&
+          dd.required &&
+          (v == null || v === "" || (Array.isArray(v) && v.length === 0))
+            ? "Please enter a value"
+            : null,
+        "required",
+      );
+      (dd.validators ?? []).forEach((x, i) => {
+        switch (x.type) {
+          case ValidatorType.Jsonata:
+            return useJsonataValidator(
+              control,
+              groupContext,
+              x as JsonataValidator,
+              hidden,
+              i,
+            );
+          case ValidatorType.Date:
+            return useDateValidator(control, x as DateValidator, i);
+        }
+      });
+    },
+    validatorTypes ? validatorTypes : [null],
+  );
+}
+
+function useJsonataValidator(
+  control: Control<any>,
+  context: ControlGroupContext,
+  expr: JsonataValidator,
+  hidden: boolean,
+  i: number,
+) {
+  const errorMsg = useJsonataExpression(expr.expression, context.groupControl);
+  useControlEffect(
+    () => [hidden, errorMsg.value],
+    ([hidden, msg]) => control.setError("jsonata" + i, !hidden ? msg : null),
+    true,
+  );
+}
+
+function useDateValidator(
+  control: Control<string | null | undefined>,
+  dv: DateValidator,
+  i: number,
+) {
+  let comparisonDate: number;
+  if (dv.fixedDate) {
+    comparisonDate = Date.parse(dv.fixedDate);
+  } else {
+    const nowDate = new Date();
+    comparisonDate = Date.UTC(
+      nowDate.getFullYear(),
+      nowDate.getMonth(),
+      nowDate.getDate(),
+    );
+    if (dv.daysFromCurrent) {
+      comparisonDate += dv.daysFromCurrent * 86400000;
+    }
+  }
+  useValidator(
+    control,
+    (v) => {
+      if (v) {
+        const selDate = Date.parse(v);
+        const notAfter = dv.comparison === DateComparison.NotAfter;
+        if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
+          return `Date must not be ${notAfter ? "after" : "before"} ${new Date(
+            comparisonDate,
+          ).toDateString()}`;
+        }
+      }
+      return null;
+    },
+    "date" + i,
+  );
+}

package/tsconfig.json

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

package/.rush/temp/package-deps_build.json

@@ -1,13 +0,0 @@
-{
-  "files": {
-    "packages/schemas/.rush/temp/shrinkwrap-deps.json": "5ce6417fae765db5c61e400f851ecafe0ce756f0",
-    "packages/schemas/package.json": "bf139da03e9c398c9ef59a9dcf3a4ba25e92c2bb",
-    "packages/schemas/src/controlRender.tsx": "b54a8e7ad36207ccd6684c30af2027789d9f806d",
-    "packages/schemas/src/hooks.ts": "a34545b7c63dc78ea77974f6c2fc386daaee80ea",
-    "packages/schemas/src/index.ts": "b15fbb6de132cd912cf8141d5c4d2329e947546e",
-    "packages/schemas/src/schemaBuilder.ts": "4662698fd46ac14459f429ce24d919ef91992de2",
-    "packages/schemas/src/types.ts": "0f55d35f7e4b052a01bc433799647d8288e237ab",
-    "packages/schemas/tsconfig.json": "52e4f044fa580f4e0ad5830f3cfca574e2788372"
-  },
-  "arguments": "rimraf ./lib/ && tsc "
-}