@goodie-forms/core 1.1.5-alpha → 1.2.0-alpha

package/dist/validation/CustomValidation.d.ts

@@ -0,0 +1,10 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { DeepPartial } from '../types/DeepPartial';
+import { FieldPath } from '../field/FieldPath';
+export type CustomValidationIssue<TOutput extends object> = {
+    path: FieldPath.StringPaths<TOutput>;
+    message: string;
+};
+export type CustomValidationStrategy<TOutput extends object> = (data: DeepPartial<TOutput>) => void | CustomValidationIssue<TOutput>[] | Promise<CustomValidationIssue<TOutput>[] | void>;
+export declare function customValidation<TOutput extends object>(strategy: CustomValidationStrategy<TOutput>): StandardSchemaV1<TOutput, TOutput>;
+//# sourceMappingURL=CustomValidation.d.ts.map

package/dist/validation/CustomValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomValidation.d.ts","sourceRoot":"","sources":["../../src/validation/CustomValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,MAAM,MAAM,qBAAqB,CAAC,OAAO,SAAS,MAAM,IAAI;IAC1D,IAAI,EAAE,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,OAAO,SAAS,MAAM,IAAI,CAC7D,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,KAExB,IAAI,GACJ,qBAAqB,CAAC,OAAO,CAAC,EAAE,GAChC,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;AAErD,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,MAAM,EACrD,QAAQ,EAAE,wBAAwB,CAAC,OAAO,CAAC,GAiCtC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CACxC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodie-forms/core",
-  "version": "1.1.5-alpha",
+  "version": "1.2.0-alpha",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/field/FieldPath.ts

@@ -0,0 +1,292 @@
+export namespace FieldPath {
+  export type Segments = readonly PropertyKey[];
+  export type CanonicalPath = string;
+  export type StringPath = string;
+
+  export function toCanonicalPath(path: Segments) {
+    return path.join(".") as CanonicalPath;
+  }
+
+  export function toStringPath(path: Segments) {
+    const normalizedPath = normalize(path);
+    let result = "";
+
+    for (const fragment of normalizedPath) {
+      if (typeof fragment === "number") {
+        result += `[${fragment}]`;
+      } else {
+        if (result.length > 0) {
+          result += ".";
+        }
+        result += fragment.toString();
+      }
+    }
+
+    return result;
+  }
+
+  export function fromStringPath<TStrPath extends string>(
+    stringPath: TStrPath,
+  ) {
+    const result: Array<string | number> = [];
+
+    let i = 0;
+
+    while (i < stringPath.length) {
+      const char = stringPath[i];
+
+      // dot separator
+      if (char === ".") {
+        i++;
+        continue;
+      }
+
+      // bracket index: [123]
+      if (char === "[") {
+        i++; // skip '['
+        let num = "";
+
+        while (i < stringPath.length && stringPath[i] !== "]") {
+          num += stringPath[i];
+          i++;
+        }
+
+        i++; // skip ']'
+
+        if (!num || !/^\d+$/.test(num)) {
+          throw new Error(`Invalid array index in path: ${stringPath}`);
+        }
+
+        result.push(Number(num));
+        continue;
+      }
+
+      // identifier
+      let key = "";
+      while (i < stringPath.length && /[^\.\[]/.test(stringPath[i])) {
+        key += stringPath[i];
+        i++;
+      }
+
+      if (key) {
+        result.push(key);
+      }
+    }
+
+    return result as FieldPath.ParseStringPath<TStrPath>;
+  }
+
+  export function normalize<T extends readonly any[] | undefined>(path: T) {
+    return path?.map((segment) => {
+      if (typeof segment === "string") return segment;
+      if (typeof segment === "number") return segment;
+      if (typeof segment === "symbol") return segment;
+      if (typeof segment === "object" && "key" in segment) {
+        if (typeof segment === "string") return segment;
+        if (typeof segment === "number") return segment;
+        if (typeof segment === "symbol") return segment;
+        return segment.key;
+      }
+    }) as Segments;
+  }
+
+  export function equals(path1?: Segments, path2?: Segments) {
+    if (path1 === path2) return true;
+    if (path1 == null) return false;
+    if (path2 == null) return false;
+    if (path1.length !== path2.length) return false;
+    for (let i = 0; i < path1.length; i++) {
+      if (path1[i] !== path2[i]) return false;
+    }
+    return true;
+  }
+  export function isDescendant(parentPath: Segments, childPath: Segments) {
+    if (parentPath.length >= childPath.length) return false;
+
+    for (let i = 0; i < parentPath.length; i++) {
+      if (parentPath[i] !== childPath[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  type Unfoldable<T> = T & { _____foldMark?: never } & {};
+
+  export type Resolve<
+    TObject,
+    TPath extends readonly PropertyKey[],
+  > = TPath extends []
+    ? TObject
+    : TPath extends readonly [infer Prop, ...infer Rest]
+      ? Rest extends readonly PropertyKey[]
+        ? Resolve<ResolveStep<TObject, Prop>, Rest>
+        : never
+      : never;
+
+  type ResolveStep<TObject, TKey> =
+    NonNullable<TObject> extends infer U
+      ? U extends readonly unknown[]
+        ? number extends U["length"]
+          ? TKey extends number | `${number}`
+            ? U[number]
+            : never
+          : TKey extends keyof U
+            ? U[TKey]
+            : TKey extends `${infer N extends number}`
+              ? U[N]
+              : never
+        : TKey extends keyof U
+          ? U[TKey]
+          : never
+      : never;
+
+  export type StringPaths<TObject extends object> = StringPathsImpl<
+    CanonicalStringPaths<TObject>
+  >;
+
+  type StringPathsImpl<TCanonicalStringPaths extends string> =
+    TCanonicalStringPaths extends `${string}[*]${string}`
+      ?
+          | ReplaceAll<TCanonicalStringPaths, "[*]", "[0]">
+          | Unfoldable<ReplaceAll<TCanonicalStringPaths, "[*]", `[${number}]`>>
+      : TCanonicalStringPaths;
+
+  type CanonicalStringPaths<TObject extends object> = {
+    [K in keyof TObject & string]: NonNullable<TObject[K]> extends (
+      ...args: any[]
+    ) => any
+      ? never
+      : NonNullable<TObject[K]> extends (infer U)[]
+        ? U extends object
+          ? K | `${K}[*]` | `${K}[*].${CanonicalStringPaths<NonNullable<U>>}`
+          : K | `${K}[*]`
+        : NonNullable<TObject[K]> extends object
+          ? K | `${K}.${CanonicalStringPaths<NonNullable<TObject[K]>>}`
+          : K;
+  }[keyof TObject & string];
+
+  type ReplaceAll<
+    TString extends string,
+    TMatch extends string,
+    TReplace extends string | number,
+  > = TString extends `${infer A}${TMatch}${infer B}`
+    ? `${A}${TReplace}${ReplaceAll<B, TMatch, TReplace>}`
+    : TString;
+
+  export type ParseStringPath<TStrPath extends string> = string extends TStrPath
+    ? never
+    : ParseStringPathImpl<NormalizeStrPath<TStrPath>, []>;
+
+  type ParseStringPathImpl<
+    TStrPath extends string,
+    TPath extends PropertyKey[],
+  > = TStrPath extends ""
+    ? TPath
+    : TStrPath extends `.${infer Rest}`
+      ? ParseStringPathImpl<Rest, TPath>
+      : TStrPath extends `[${infer Bracket}]${infer Rest}`
+        ? ParseStringPathImpl<Rest, [...TPath, ParseBracket<Bracket>]>
+        : TStrPath extends `${infer Head}.${infer Rest}`
+          ? ParseStringPathImpl<Rest, [...TPath, Head]>
+          : TStrPath extends `${infer Head}[${infer Tail}`
+            ? ParseStringPathImpl<`[${Tail}`, [...TPath, Head]>
+            : [...TPath, TStrPath];
+
+  type NormalizeStrPath<TStringPath extends string> =
+    TStringPath extends `${infer A}[${infer B}]${infer Rest}`
+      ? NormalizeStrPath<`${A}.${B}${Rest}`>
+      : TStringPath extends `.${infer R}`
+        ? NormalizeStrPath<R>
+        : TStringPath;
+
+  type ParseBracket<TString extends string> =
+    TString extends `${infer N extends number}`
+      ? N
+      : TString extends `"${infer K}"`
+        ? K
+        : TString extends `'${infer K}'`
+          ? K
+          : never;
+
+  export function getValue<
+    TObject extends object,
+    const TPath extends readonly PropertyKey[],
+  >(
+    object: TObject,
+    path: TPath,
+  ): FieldPath.Resolve<TObject, TPath> | undefined {
+    let current: any = object;
+
+    for (const pathFragment of path) {
+      if (current == null) return undefined;
+      current = current[pathFragment];
+    }
+
+    return current;
+  }
+
+  export function setValue<
+    TObject extends object,
+    const TPath extends readonly PropertyKey[],
+  >(object: TObject, key: TPath, value: FieldPath.Resolve<TObject, TPath>) {
+    return FieldPath.modifyValue(object, key, () => value);
+  }
+
+  export function modifyValue<
+    TObject extends object,
+    const TPath extends readonly PropertyKey[],
+  >(
+    object: TObject,
+    path: TPath,
+    modifier: (
+      currentValue: FieldPath.Resolve<TObject, TPath>,
+    ) => FieldPath.Resolve<TObject, TPath> | void,
+  ) {
+    let current: any = object;
+
+    for (let i = 0; i < path.length - 1; i++) {
+      const pathFragment = path[i];
+      const nextFragment = path[i + 1];
+
+      if (current[pathFragment] == null) {
+        current[pathFragment] = typeof nextFragment === "number" ? [] : {};
+      }
+
+      current = current[pathFragment];
+    }
+
+    const lastFragment = path[path.length - 1];
+
+    const oldValue = current[lastFragment];
+    const newValue = modifier(oldValue);
+
+    if (newValue !== undefined) {
+      current[lastFragment] = newValue;
+    }
+  }
+
+  export function deleteValue<
+    TObject extends object,
+    TPath extends readonly PropertyKey[],
+  >(object: TObject, path: TPath) {
+    let current: any = object;
+
+    for (let i = 0; i < path.length - 1; i++) {
+      const pathFragment = path[i];
+
+      if (current[pathFragment] == null) return;
+
+      current = current[pathFragment];
+    }
+
+    const lastFragment = path[path.length - 1];
+
+    delete current[lastFragment];
+  }
+}
+
+// const x = {} as { foo: { bar: string[] } };
+// FieldPath.setValue(x, FieldPath.fromStringPath("foo.bar[9]"), "C");
+// console.log(x); // <-- { foo: { bar: [<9xempty>, "C"] } }

package/src/field/FieldPathBuilder.ts

@@ -0,0 +1,132 @@
+import { FieldPath } from "./FieldPath";
+
+const resolverCall = Symbol("PathResolver");
+
+export namespace FieldPathBuilder {
+  export type Proxy<TObject, TPath extends readonly PropertyKey[]> =
+    NonNullable<TObject> extends readonly (infer E)[]
+      ? {
+          [K in number]: Proxy<NonNullable<E>, [...TPath, K]>;
+        } & {
+          [resolverCall]: TPath;
+        }
+      : NonNullable<TObject> extends object
+        ? {
+            [K in keyof TObject]-?: Proxy<
+              NonNullable<TObject[K]>,
+              [...TPath, K]
+            >;
+          } & {
+            [resolverCall]: TPath;
+          }
+        : {
+            [resolverCall]: TPath;
+          };
+}
+
+export class FieldPathBuilder<TOutput extends object> {
+  protected static wrap<
+    TObject extends object,
+    TPath extends readonly PropertyKey[],
+  >(paths: TPath): FieldPathBuilder.Proxy<TObject, TPath> {
+    return new Proxy<TObject>(paths as any, {
+      get(_target, p, _receiver) {
+        if (p === resolverCall) return paths;
+        const key =
+          typeof p === "string" ? (/^\d+$/.test(p) ? Number(p) : p) : p;
+
+        // TODO: Branch instead of reallocating a copy
+        return FieldPathBuilder.wrap<any, [...TPath, typeof key]>([
+          ...paths,
+          key,
+        ]);
+      },
+    }) as any;
+  }
+
+  public fromStringPath<TStrPath extends FieldPath.StringPaths<TOutput>>(
+    stringPath: TStrPath,
+  ) {
+    return FieldPath.fromStringPath(
+      stringPath,
+    ) as unknown as FieldPath.ParseStringPath<TStrPath>;
+  }
+
+  public fromProxy<TProxy extends FieldPathBuilder.Proxy<any, any>>(
+    consumer: (data: FieldPathBuilder.Proxy<TOutput, []>) => TProxy,
+  ): TProxy[typeof resolverCall] {
+    return consumer(FieldPathBuilder.wrap<TOutput, []>([]))[resolverCall];
+  }
+}
+
+/* ---- TESTS ---------------- */
+
+// interface User {
+//   name: string;
+//   address: {
+//     city: string;
+//     street: string;
+//   };
+//   friends: {
+//     name: string;
+//     tags: string[];
+//   }[];
+//   coords: [100, 200];
+// }
+
+// const builder = new FieldPathBuilder<User>();
+
+// const data: User = {
+//   name: "",
+//   address: { city: "", street: "" },
+//   friends: [{ name: "", tags: ["A", "B"] }],
+//   coords: [100, 200] as const,
+// };
+
+// const path = builder.fromProxy((data) => data.friends[0].tags[1]);
+// //    ^?
+// const value = FieldPath.getValue(data, path);
+// //    ^?
+// console.log(path, "=", value);
+
+// const path2 = builder.fromStringPath("friends[0].tags[0]");
+// //    ^?
+// const value2 = FieldPath.getValue(data, path2);
+// //    ^?
+// console.log(path2, "=", value2);
+
+// const path3 = builder.fromStringPath("coords[0]");
+// //    ^?
+// const value3 = FieldPath.getValue(data, path3);
+// console.log(path3, "=", value3);
+
+// const path4 = builder.fromStringPath("coords[1]");
+// //    ^?
+// const value4 = FieldPath.getValue(data, path4);
+// //    ^?
+// console.log(path4, "=", value4);
+
+// type Shape = {
+//   user?: {
+//     profile?: { name?: string };
+//     tags?: boolean[];
+//   };
+// };
+
+// type A = FieldPath.Resolve<Shape, ["user"]>;
+// //   ^?
+
+// type A2 = FieldPath.Resolve<Shape, ["user", "profile"]>;
+// //   ^?
+
+// type B = FieldPath.Resolve<Shape, ["user", "profile", "name"]>;
+// //   ^?
+
+// type C = FieldPath.Resolve<Shape, ["user", "tags", number]>;
+// //   ^?
+
+// type C2 = FieldPath.Resolve<Shape, ["user", "tags", 0]>;
+// //   ^?
+
+// type D = FieldPath.Resolve<Shape, ["user", "missing"]>;
+// //   ^?

package/src/field/Reconcile.ts

@@ -0,0 +1,99 @@
+export namespace Reconsile {
+  export function deepEqual(
+    a: any,
+    b: any,
+    customComparator?: (a: any, b: any) => boolean | undefined,
+  ) {
+    if (a === b) return true;
+
+    if (a === null || b === null) return false;
+    if (typeof a !== "object" || typeof b !== "object") return false;
+
+    // Arrays
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!deepEqual(a[i], b[i])) return false;
+      }
+      return true;
+    }
+
+    // Allow custom comparison
+    if (customComparator != null) {
+      const result = customComparator(a, b);
+      if (result !== undefined) return result;
+    }
+
+    // Dates
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() === b.getTime();
+    }
+
+    // RegExp
+    if (a instanceof RegExp && b instanceof RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+
+    // Map
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) return false;
+      for (const [key, val] of a) {
+        if (!b.has(key) || !deepEqual(val, b.get(key))) return false;
+      }
+      return true;
+    }
+
+    // Set
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) return false;
+      for (const val of a) {
+        if (!b.has(val)) return false;
+      }
+      return true;
+    }
+
+    // Plain / class objects
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+      return false;
+    }
+
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+
+    if (keysA.length !== keysB.length) return false;
+
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+      if (!deepEqual(a[key], b[key])) return false;
+    }
+
+    return true;
+  }
+
+  export function diff<T>(
+    prev: readonly T[],
+    next: readonly T[],
+    equals: (a: T, b: T) => boolean,
+    filter?: (a: T) => boolean,
+  ) {
+    const added: T[] = [];
+    const removed: T[] = [];
+    const unchanged: T[] = [];
+
+    for (const n of next) {
+      if (prev.some((p) => equals(p, n))) {
+        if (filter?.(n) ?? true) unchanged.push(n);
+      } else {
+        if (filter?.(n) ?? true) added.push(n);
+      }
+    }
+
+    for (const p of prev) {
+      if (!next.some((n) => equals(p, n))) {
+        if (filter?.(p) ?? true) removed.push(p);
+      }
+    }
+
+    return { added, removed, unchanged };
+  }
+}