@react-typed-forms/schemas 14.0.4 → 14.1.0

package/test/diff.test.ts

@@ -1,166 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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));