@react-typed-forms/schemas 14.0.4 → 14.0.5

package/lib/util.d.ts

@@ -243,4 +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;
+export declare function getDiffObject(dataNode: SchemaDataNode, force?: boolean): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-typed-forms/schemas",
-  "version": "14.0.4",
+  "version": "14.0.5",
   "description": "",
   "type": "module",
   "main": "lib/index.cjs",

package/test/diff.test.ts

@@ -1,14 +1,12 @@
 import { describe, expect, it } from "@jest/globals";
 import fc from "fast-check";
-import { changeValue, makeDataNode, valueAndSchema } from "./gen";
+import { makeDataNode, newIndexes, valueAndSchema } from "./gen";
+import { getDiffObject, getTagParam, SchemaDataNode, SchemaTags } from "../src";
 import {
-  getDiffObject,
-  getTagParam,
-  isCompoundNode,
-  SchemaDataNode,
-  SchemaTags,
-} from "../src";
-import { Control } from "@react-typed-forms/core";
+  deepEquals,
+  newElement,
+  updateElements,
+} from "@react-typed-forms/core";
 
 describe("diff", () => {
   it("unchanged value always returns undefined", () => {
@@ -27,7 +25,7 @@ describe("diff", () => {
         (fv) => {
           const dataNode = makeDataNode(fv);
           const control = dataNode.control!;
-          control.setValue((x) => changeValue(x, dataNode.schema.field));
+          control.setValue((x) => fv.newValue);
           expect(getDiffObject(dataNode)).toBe(control.value);
         },
       ),
@@ -37,25 +35,23 @@ describe("diff", () => {
   it("compound fields only return changed values", () => {
     fc.assert(
       fc.property(
-        valueAndSchema({ arrayChance: 0, forceCompound: true }),
+        valueAndSchema({
+          arrayChance: 0,
+          compoundChance: 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);
+          control.value = fv.newValue;
+          const changed = dataNode.schema
+            .getChildNodes()
+            .map((x) => x.field.field)
+            .filter((x) => fv.value?.[x] !== fv.newValue?.[x])
+            .map((x) => [x, fv.newValue?.[x]]);
+          expect(getDiffObject(dataNode)).toStrictEqual(
+            changed.length ? Object.fromEntries(changed) : undefined,
+          );
         },
       ),
     );
@@ -74,14 +70,20 @@ describe("diff", () => {
         (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);
+          arrayControl.value = fv.newValue;
+          const idField = getTagParam(
+            dataNode.schema.field,
+            SchemaTags.IdField,
+          );
+          const origValues = (fv.value ?? []) as any[];
+          const newValues = (fv.newValue ?? []) as any[];
+          const expected = newValues.map((nv, i) => {
+            if (nv == null) return null;
+            return objectDiff(dataNode, origValues[i], nv, idField);
           });
-          expect(getDiffObject(dataNode)).toStrictEqual(results);
+          expect(getDiffObject(dataNode)).toStrictEqual(
+            arrayControl.dirty ? expected : undefined,
+          );
         },
       ),
     );
@@ -95,44 +97,31 @@ describe("diff", () => {
           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) => {
+        })
+          .filter((x) => !deepEquals(x.newValue, x.value) && x.value != null)
+          .chain((x) => newIndexes(x.value.length).map((i) => [x, i] as const)),
+        ([fv, indexes]) => {
           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,
+          const newValue = fv.newValue as any[];
+          const results = Array.from({ length: newValue.length });
+          updateElements(arrayControl, (x) => {
+            const sorted = indexes.map((ni, i) => {
+              const c = x[ni];
+              c.value = newValue[i];
+              results[i] = {
+                old: ni,
+                edit: objectDiff(dataNode, c.initialValue, c.value),
+              };
+              return c;
             });
+            while (newValue.length > sorted.length) {
+              const ne = newElement(arrayControl, undefined);
+              ne.value = newValue[sorted.length];
+              results[sorted.length] = { old: undefined, edit: ne.value };
+              sorted.push(ne);
+            }
+            return sorted;
           });
           expect(getDiffObject(dataNode)).toStrictEqual(results);
         },
@@ -141,26 +130,17 @@ describe("diff", () => {
   });
 });
 
-function editCompound(
-  existing: Record<string, any>,
+function objectDiff(
   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 };
+  oldValue: Record<string, any> | undefined | null,
+  newValue: Record<string, any> | undefined | null,
+  idField?: string,
+) {
+  if (newValue == null) return oldValue == null ? undefined : newValue;
+  const changed = dataNode.schema
+    .getChildNodes()
+    .map((x) => x.field.field)
+    .filter((x) => x == idField || oldValue?.[x] !== newValue[x])
+    .map((x) => [x, newValue[x]]);
+  return changed.length ? Object.fromEntries(changed) : undefined;
 }

package/test/gen.ts

@@ -3,6 +3,7 @@ import {
   CompoundField,
   createSchemaLookup,
   FieldType,
+  getTagParam,
   isCompoundField,
   makeSchemaDataNode,
   SchemaDataNode,
@@ -16,13 +17,39 @@ export interface FieldAndValue {
   value: any;
 }
 
-export function valueAndSchema(
-  options?: SchemaFieldGenOptions,
-): Arbitrary<FieldAndValue> {
-  return randomSchemaField(options).chain((schema) =>
-    randomValueForField(schema).map((value) => ({ field: schema, value })),
+export interface FieldAndValueChanged extends FieldAndValue {
+  newValue: any;
+}
+
+export function newIndexes(arr: number): Arbitrary<number[]> {
+  return fc.array(fc.integer(), { minLength: arr, maxLength: arr }).map((x) =>
+    x
+      .map((n, i) => ({ n, i }))
+      .sort((a, b) => a.n - b.n)
+      .map((x) => x.i),
   );
 }
+export function valueAndSchema(
+  schemaOptions?: SchemaFieldGenOptions,
+): Arbitrary<FieldAndValueChanged> {
+  return randomSchemaField(schemaOptions)
+    .chain((schema) =>
+      randomValueForField(schema).map((value) => ({
+        field: schema,
+        value,
+      })),
+    )
+    .chain(changedValue);
+}
+
+export function changedValue(
+  val: FieldAndValue,
+): Arbitrary<FieldAndValueChanged> {
+  return changeValue(val.value, val.field, true).map((newValue) => ({
+    ...val,
+    newValue,
+  }));
+}
 
 export function makeDataNode(fv: FieldAndValue): SchemaDataNode {
   return makeSchemaDataNode(
@@ -122,7 +149,7 @@ function randomValueForField(
       }
       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.Double) return fc.double({ noNaN: true });
       if (f.type === FieldType.Bool) return fc.boolean();
       if (f.type === FieldType.Date)
         return fc.date().map((x) => x.toISOString().substring(0, 10));
@@ -137,39 +164,57 @@ function randomValueForField(
           ),
         );
     }
-    return fc.constantFrom(null, undefined);
+    return fc.constantFrom(null);
   }) as (x: number) => Arbitrary<any>);
 }
 
 export function changeValue(
   value: any,
   field: SchemaField,
+  forceChange: boolean | undefined,
   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),
-        ]),
+): Arbitrary<any> {
+  return fc.boolean().chain((shouldChange) => {
+    if (forceChange === false || (!shouldChange && !forceChange))
+      return fc.constant(value);
+    if (field.collection && !element) {
+      if (!value || !value.length)
+        return changeValue(undefined, field, true, true).map((x) => [x]);
+      return (value as any[]).reduce(
+        (acc, x) =>
+          acc.chain((nx: any[]) =>
+            changeValue(x, field, undefined, true).map((v) => [...nx, v]),
+          ),
+        fc.constant([] as any[]),
+      );
+    }
+    if (isCompoundField(field)) {
+      return fc.record(
+        Object.fromEntries(
+          field.children.map((x) => [
+            x.field,
+            changeValue(value?.[x.field], x, value == null ? true : undefined),
+          ]),
+        ),
       );
-    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);
-  }
+    }
+    return fc.constant(changePrim() as any);
+    function changePrim() {
+      switch (field.type) {
+        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

@@ -1,50 +1,54 @@
-import { changeValue, FieldAndValue, makeDataNode } from "./gen";
+import {
+  changeValue,
+  FieldAndValue,
+  FieldAndValueChanged,
+  makeDataNode,
+} from "./gen";
 import { getDiffObject } from "../src";
+import { updateElements } from "@react-typed-forms/core";
 
-
-const fv = {
-  field: {
-    field: "",
-    type: "Compound",
-    collection: true,
-    notNullable: false,
-    children: [
-      {
-        field: "",
-        type: "String",
-        collection: false,
-        notNullable: false,
-        children: null,
-      },
+const testData = [
+  {
+    field: {
+      field: ")W",
+      type: "Compound",
+      collection: true,
+      notNullable: true,
+      children: [
+        {
+          field: "4N`rCgnDXm",
+          type: "DateTime",
+          collection: false,
+          notNullable: false,
+          children: null,
+        },
+      ],
+    },
+    value: [
+      { "4N`rCgnDXm": "1970-01-01T00:00:00.000Z" },
+      { "4N`rCgnDXm": "1970-01-01T00:00:00.000Z" },
+      { "4N`rCgnDXm": "1970-01-01T00:00:00.000Z" },
+    ],
+    newValue: [
+      { "4N`rCgnDXm": "1970-01-01T00:00:00.000Zx" },
+      { "4N`rCgnDXm": "1970-01-01T00:00:00.000Z" },
+      { "4N`rCgnDXm": "1970-01-01T00:00:00.000Zz" },
     ],
-  },
-  value: [{ "": "" }],
-  index: 0,
-  add: false,
-} as FieldAndValue;
+  } as FieldAndValueChanged,
+  [2, 0, 1],
+] as [FieldAndValueChanged, number[]];
 
+const [fv, indexes] = testData;
 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];
-    }
+
+const newValue = fv.newValue as any[];
+updateElements(arrayControl.as<any[]>(), (x) => {
+  const sorted = indexes.map((ni, i) => {
+    const c = x[ni];
+    c.value = newValue[i];
+    return c;
   });
-  control.value = newValue;
-  if (!results) results = [];
-  results.push(result);
+  return sorted;
 });
-console.log(fv.value);
-console.log(arrayControl.value);
-console.log(results);
 console.log(getDiffObject(dataNode));

package/tsconfig.json

@@ -13,7 +13,7 @@
     "moduleResolution": "node",
     "resolveJsonModule": true,
     "isolatedModules": true,
-    "jsx": "preserve",
+    "jsx": "react",
     "outDir": "lib"
   },
   "include": ["src/**/*.ts", "src/**/*.tsx"],