@react-typed-forms/schemas 14.0.3 → 14.0.4

package/lib/schemaField.d.ts

@@ -212,7 +212,7 @@ export interface SchemaDataNode {
     id: string;
     schema: SchemaNode;
     elementIndex?: number;
-    control?: Control<unknown>;
+    control: Control<any>;
     parent?: SchemaDataNode;
     getChild(schemaNode: SchemaNode): SchemaDataNode;
     getChildElement(index: number): SchemaDataNode;
@@ -221,7 +221,7 @@ export declare function findField(fields: SchemaField[], field: string): SchemaF
 export declare function isScalarField(sf: SchemaField): sf is SchemaField;
 export declare function isCompoundField(sf: SchemaField): sf is CompoundField;
 export declare function createSchemaLookup<A extends Record<string, SchemaField[]>>(schemaMap: A): SchemaTreeLookup<keyof A>;
-export declare function makeSchemaDataNode(schema: SchemaNode, control?: Control<unknown>, parent?: SchemaDataNode, elementIndex?: number): SchemaDataNode;
+export declare function makeSchemaDataNode(schema: SchemaNode, control: Control<unknown>, parent?: SchemaDataNode, elementIndex?: number): SchemaDataNode;
 export declare function schemaDataForFieldRef(fieldRef: string | undefined, schema: SchemaDataNode): SchemaDataNode;
 export declare function schemaForFieldRef(fieldRef: string | undefined, schema: SchemaNode): SchemaNode;
 export declare function traverseSchemaPath<A>(fieldPath: string[], schema: SchemaNode, acc: A, next: (acc: A, node: SchemaNode) => A): A;
@@ -243,7 +243,8 @@ export declare enum SchemaTags {
     NoControl = "_NoControl",
     HtmlEditor = "_HtmlEditor",
     ControlGroup = "_ControlGroup:",
-    ControlRef = "_ControlRef:"
+    ControlRef = "_ControlRef:",
+    IdField = "_IdField:"
 }
 export declare function getTagParam(field: SchemaField, tag: string): string | undefined;
 export declare function makeParamTag(tag: string, value: string): string;

package/lib/util.d.ts

@@ -1,6 +1,6 @@
 import { ControlActionHandler, ControlDefinition, DataControlDefinition, DisplayOnlyRenderOptions, GroupRenderOptions } from "./controlDefinition";
 import { MutableRefObject } from "react";
-import { CompoundField, FieldOption, SchemaField, SchemaNode } from "./schemaField";
+import { CompoundField, FieldOption, SchemaDataNode, SchemaField, SchemaNode } from "./schemaField";
 /**
  * Interface representing the classes for a control.
  */
@@ -243,3 +243,4 @@ export declare function isControlDisplayOnly(def: ControlDefinition): boolean;
  * @returns {ControlActionHandler} - The combined action handler.
  */
 export declare function actionHandlers(...handlers: (ControlActionHandler | undefined)[]): ControlActionHandler;
+export declare function getDiffObject(dataNode: SchemaDataNode, idField?: string | null): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-typed-forms/schemas",
-  "version": "14.0.3",
+  "version": "14.0.4",
   "description": "",
   "type": "module",
   "main": "lib/index.cjs",
@@ -42,6 +42,11 @@
   "devDependencies": {
     "react": "^18.2.0",
     "@react-typed-forms/transform": "^0.2.0",
+    "jest": "^29.7.0",
+    "tsx": "^4.19.1",
+    "fast-check": "^3.22.0",
+    "ts-jest": "^29.2.5",
+    "@jest/globals": "^29.7.0",
     "typedoc": "^0.27.2",
     "@types/uuid": "^10.0.0",
     "@types/react": "^18.2.28",
@@ -51,12 +56,13 @@
     "prettier": "^3.0.3",
     "rimraf": "^3.0.2",
     "typescript": "^5.6.2",
-    "@react-typed-forms/core": "4.0.0"
+    "@react-typed-forms/core": "4.0.3"
   },
   "gitHead": "698e16cd3ab31b7dd0528fc76536f4d3205ce8c6",
   "scripts": {
     "build": "rimraf ./lib/ node_modules/.cache && microbundle -f modern,cjs --jsx React.createElement --jsxFragment React.Fragment",
     "watch": "microbundle -w -f modern,cjs --no-compress --jsx React.createElement --jsxFragment React.Fragment",
+    "test": "jest --coverage",
     "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/test/diff.test.ts

@@ -0,0 +1,166 @@
+import { describe, expect, it } from "@jest/globals";
+import fc from "fast-check";
+import { changeValue, makeDataNode, valueAndSchema } from "./gen";
+import {
+  getDiffObject,
+  getTagParam,
+  isCompoundNode,
+  SchemaDataNode,
+  SchemaTags,
+} from "../src";
+import { Control } from "@react-typed-forms/core";
+
+describe("diff", () => {
+  it("unchanged value always returns undefined", () => {
+    fc.assert(
+      fc.property(valueAndSchema(), (fv) => {
+        const dataNode = makeDataNode(fv);
+        expect(getDiffObject(dataNode)).toBeUndefined();
+      }),
+    );
+  });
+
+  it("primitive value always returns new value", () => {
+    fc.assert(
+      fc.property(
+        valueAndSchema({ arrayChance: 0, compoundChance: 0 }),
+        (fv) => {
+          const dataNode = makeDataNode(fv);
+          const control = dataNode.control!;
+          control.setValue((x) => changeValue(x, dataNode.schema.field));
+          expect(getDiffObject(dataNode)).toBe(control.value);
+        },
+      ),
+    );
+  });
+
+  it("compound fields only return changed values", () => {
+    fc.assert(
+      fc.property(
+        valueAndSchema({ arrayChance: 0, forceCompound: true }),
+        (fv) => {
+          const dataNode = makeDataNode(fv);
+          const control = dataNode.control!;
+          const result = { ...control.value };
+          const newValue = { ...control.value };
+          dataNode.schema.getChildNodes().forEach((child, i) => {
+            const field = child.field;
+            const fieldName = field.field;
+            if (i % 2 == 0) {
+              const nv = changeValue(newValue[fieldName], field);
+              newValue[fieldName] = nv;
+              result[fieldName] = nv;
+            } else {
+              delete result[fieldName];
+            }
+          });
+          control.value = newValue;
+          expect(getDiffObject(dataNode)).toStrictEqual(result);
+        },
+      ),
+    );
+  });
+
+  it("array compound with id field always returns id field and changes", () => {
+    fc.assert(
+      fc.property(
+        valueAndSchema({
+          forceArray: true,
+          forceCompound: true,
+          arrayChance: 0,
+          compoundChance: 0,
+          idField: true,
+        }),
+        (fv) => {
+          const dataNode = makeDataNode(fv);
+          const arrayControl = dataNode.control!;
+          let results: any = undefined;
+          arrayControl.as<any[]>().elements.forEach((control) => {
+            const { newValue, result } = editCompound(control.value, dataNode);
+            control.value = newValue;
+            if (!results) results = [];
+            results.push(result);
+          });
+          expect(getDiffObject(dataNode)).toStrictEqual(results);
+        },
+      ),
+    );
+  });
+
+  it("array without id always returns array index edit format", () => {
+    fc.assert(
+      fc.property(
+        valueAndSchema({
+          forceArray: true,
+          forceCompound: true,
+          arrayChance: 0,
+          compoundChance: 0,
+        }).chain((fv) => {
+          const len = ((fv.value as any[]) ?? []).length;
+          return fc
+            .record({
+              index: fc.integer({ min: 0, max: len }),
+              add: len ? fc.boolean() : fc.constant(true),
+            })
+            .map((x) => ({ ...fv, ...x }));
+        }),
+        (fv) => {
+          const dataNode = makeDataNode(fv);
+          const arrayControl = dataNode.control!.as<any[]>();
+          let results: any = undefined;
+          // if (fv.add || fv.index >= arrayControl.elements.length)
+          //   addElement(
+          //     arrayControl,
+          //     changeValue(undefined, dataNode.schema.field, true),
+          //   );
+          arrayControl.as<any[]>().elements.forEach((control, i) => {
+            let change = undefined;
+            if (i % 2 == 0) {
+              if (isCompoundNode(dataNode.schema)) {
+                const { newValue, result } = editCompound(
+                  control.value,
+                  dataNode,
+                );
+                control.value = newValue;
+                change = result;
+              } else {
+                change = changeValue(control.value, dataNode.schema.field);
+                control.value = change;
+              }
+            }
+            if (!results) results = [];
+            results.push({
+              old: i,
+              edit: change,
+            });
+          });
+          expect(getDiffObject(dataNode)).toStrictEqual(results);
+        },
+      ),
+    );
+  });
+});
+
+function editCompound(
+  existing: Record<string, any>,
+  dataNode: SchemaDataNode,
+): { newValue: any; result: any } {
+  const idField = getTagParam(dataNode.schema.field, SchemaTags.IdField);
+  const result = { ...existing };
+  const newValue = { ...existing };
+  dataNode.schema.getChildNodes().forEach((child, i) => {
+    const field = child.field;
+    const fieldName = field.field;
+    const shouldChange = i % 2 == 0;
+    if (shouldChange || fieldName == idField) {
+      let nv = newValue[fieldName];
+      if (shouldChange) nv = changeValue(nv, field);
+      if (nv === undefined) nv = null;
+      newValue[fieldName] = nv;
+      result[fieldName] = nv;
+    } else {
+      delete result[fieldName];
+    }
+  });
+  return { newValue, result };
+}

package/test/gen.ts

@@ -0,0 +1,175 @@
+import fc, { Arbitrary } from "fast-check";
+import {
+  CompoundField,
+  createSchemaLookup,
+  FieldType,
+  isCompoundField,
+  makeSchemaDataNode,
+  SchemaDataNode,
+  SchemaField,
+  SchemaTags,
+} from "../src";
+import { newControl } from "@react-typed-forms/core";
+
+export interface FieldAndValue {
+  field: SchemaField;
+  value: any;
+}
+
+export function valueAndSchema(
+  options?: SchemaFieldGenOptions,
+): Arbitrary<FieldAndValue> {
+  return randomSchemaField(options).chain((schema) =>
+    randomValueForField(schema).map((value) => ({ field: schema, value })),
+  );
+}
+
+export function makeDataNode(fv: FieldAndValue): SchemaDataNode {
+  return makeSchemaDataNode(
+    createSchemaLookup({ "": [fv.field] })
+      .getSchema("")!
+      .getChildNode(fv.field.field)!,
+    newControl(fv.value),
+  );
+}
+
+export interface SchemaFieldGenOptions {
+  arrayChance?: number;
+  forceCompound?: boolean;
+  forceArray?: boolean;
+  compoundChance?: number;
+  idField?: boolean;
+}
+function randomSchemaField(
+  options: SchemaFieldGenOptions = {},
+): Arbitrary<SchemaField> {
+  const {
+    arrayChance = 5,
+    compoundChance = 10,
+    forceCompound,
+    forceArray,
+    idField,
+  } = options;
+  const nextOptions = { arrayChance, compoundChance };
+  const field = fc.oneof(
+    {
+      weight: forceCompound ? 100 : compoundChance,
+      arbitrary: fc.constant(FieldType.Compound),
+    },
+    {
+      weight: forceCompound ? 0 : 100 - compoundChance,
+      arbitrary: fc.constantFrom(
+        FieldType.String,
+        FieldType.Int,
+        FieldType.Double,
+        FieldType.Bool,
+        FieldType.Date,
+        FieldType.DateTime,
+        FieldType.Time,
+      ),
+    },
+  );
+  const collection = fc.oneof(
+    {
+      weight: forceArray ? 0 : 100 - arrayChance,
+      arbitrary: fc.constant(false),
+    },
+    {
+      weight: forceArray ? 100 : arrayChance,
+      arbitrary: fc.constant(true),
+    },
+  );
+
+  const withoutId = field.chain((fieldType) =>
+    fc.record({
+      field: fc.string(),
+      type: fc.constant(fieldType),
+      collection,
+      notNullable: fc.boolean(),
+      children:
+        fieldType == FieldType.Compound
+          ? fc
+              .array(randomSchemaField(nextOptions), {
+                minLength: 1,
+                maxLength: 10,
+              })
+              .map((x) =>
+                Object.values(Object.fromEntries(x.map((y) => [y.field, y]))),
+              )
+          : fc.constant(null),
+    }),
+  );
+  return !idField
+    ? withoutId
+    : withoutId.chain((x) =>
+        fc.integer({ min: 0, max: (x.children?.length ?? 0) - 1 }).map((i) => ({
+          ...x,
+          tags: [SchemaTags.IdField + x.children![i].field],
+        })),
+      );
+}
+function randomValueForField(
+  f: SchemaField,
+  element?: boolean,
+): Arbitrary<any> {
+  return fc.integer({ min: 0, max: 100 }).chain(((nc) => {
+    if (nc <= 75 || f.notNullable) {
+      if (!element && f.collection) {
+        return fc.array(randomValueForField(f, true), {
+          minLength: 0,
+          maxLength: 10,
+        });
+      }
+      if (f.type === FieldType.String) return fc.string();
+      if (f.type === FieldType.Int) return fc.integer();
+      if (f.type === FieldType.Double) return fc.double();
+      if (f.type === FieldType.Bool) return fc.boolean();
+      if (f.type === FieldType.Date)
+        return fc.date().map((x) => x.toISOString().substring(0, 10));
+      if (f.type === FieldType.DateTime)
+        return fc.date().map((x) => x.toISOString());
+      if (f.type === FieldType.Time)
+        return fc.date().map((x) => x.toISOString().substring(11));
+      if (isCompoundField(f))
+        return fc.record(
+          Object.fromEntries(
+            f.children.map((x) => [x.field, randomValueForField(x)]),
+          ),
+        );
+    }
+    return fc.constantFrom(null, undefined);
+  }) as (x: number) => Arbitrary<any>);
+}
+
+export function changeValue(
+  value: any,
+  field: SchemaField,
+  element?: boolean,
+): any {
+  if (field.collection && !element) {
+    return [...(value ?? []), changeValue(undefined, field, true)];
+  }
+  switch (field.type) {
+    case FieldType.Compound:
+      const objValue = value ?? {};
+      return Object.fromEntries(
+        (field as CompoundField).children.map((x) => [
+          x.field,
+          changeValue(objValue[x.field], x),
+        ]),
+      );
+    case FieldType.String:
+    case FieldType.Date:
+    case FieldType.DateTime:
+    case FieldType.Time:
+      return (value ?? "") + "x";
+    case FieldType.Int:
+      const v = value ?? 0;
+      return !v ? 1 : -v;
+    case FieldType.Double:
+      const dv = value ?? 0;
+      return !dv ? 1 : -dv;
+    case FieldType.Bool:
+      return !(value ?? false);
+  }
+}

package/test/play.ts

@@ -0,0 +1,50 @@
+import { changeValue, FieldAndValue, makeDataNode } from "./gen";
+import { getDiffObject } from "../src";
+
+
+const fv = {
+  field: {
+    field: "",
+    type: "Compound",
+    collection: true,
+    notNullable: false,
+    children: [
+      {
+        field: "",
+        type: "String",
+        collection: false,
+        notNullable: false,
+        children: null,
+      },
+    ],
+  },
+  value: [{ "": "" }],
+  index: 0,
+  add: false,
+} as FieldAndValue;
+
+const dataNode = makeDataNode(fv);
+const arrayControl = dataNode.control!;
+let results: any = undefined;
+arrayControl.as<any[]>().elements.forEach((control) => {
+  const result = { ...control.value };
+  const newValue = { ...control.value };
+  dataNode.schema.getChildNodes().forEach((child, i) => {
+    const field = child.field;
+    const fieldName = field.field;
+    if (i % 2 == 0) {
+      const nv = changeValue(newValue[fieldName], field);
+      newValue[fieldName] = nv;
+      result[fieldName] = nv;
+    } else {
+      delete result[fieldName];
+    }
+  });
+  control.value = newValue;
+  if (!results) results = [];
+  results.push(result);
+});
+console.log(fv.value);
+console.log(arrayControl.value);
+console.log(results);
+console.log(getDiffObject(dataNode));