@goodie-forms/core 1.2.5-alpha → 1.3.0

package/dist/types/DeepHelpers.d.ts

@@ -0,0 +1,11 @@
+export type DeepPartial<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
+} & {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export type DeepReadonly<T> = {
+    [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
+} & {
+    readonly [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
+};
+//# sourceMappingURL=DeepHelpers.d.ts.map

package/dist/types/DeepHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepHelpers.d.ts","sourceRoot":"","sources":["../../src/types/DeepHelpers.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CACzE,GAAG;KACD,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACjD,KAAK,GACL,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;KAC3B,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CACzE,GAAG;IACF,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAC1D,KAAK,GACL,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACxD,CAAC"}

package/dist/types/FormHelpers.d.ts

@@ -0,0 +1,5 @@
+import { FormField } from 'packages/core/src/form/FormField';
+export type FieldValue<T extends FormField<any, any>> = NonNullable<T> extends {
+    value: infer V;
+} ? NonNullable<V> : never;
+//# sourceMappingURL=FormHelpers.d.ts.map

package/dist/types/FormHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormHelpers.d.ts","sourceRoot":"","sources":["../../src/types/FormHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAG7D,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,IAClD,WAAW,CAAC,CAAC,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC"}

package/dist/types/Suppliable.d.ts

@@ -0,0 +1,3 @@
+export type Suppliable<T> = T | (() => T);
+export declare function supply<T>(suppliable: T | (() => T)): T;
+//# sourceMappingURL=Suppliable.d.ts.map

package/dist/types/Suppliable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Suppliable.d.ts","sourceRoot":"","sources":["../../src/types/Suppliable.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAE1C,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAItD"}

package/dist/validation/CustomValidation.d.ts

@@ -1,5 +1,5 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
-import { DeepPartial } from '../types/DeepPartial';
+import { DeepPartial } from '../types/DeepHelpers';
 import { FieldPath } from '../field/FieldPath';
 export type CustomValidationIssue<TOutput extends object> = {
     path: FieldPath.StringPaths<TOutput>;

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "@goodie-forms/core",
-  "version": "1.2.5-alpha",
+  "version": "1.3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iGoodie/goodie-forms"
+  },
+  "author": {
+    "name": "Taha Anılcan Metinyurt",
+    "email": "igoodie@programmer.net",
+    "url": "https://github.com/iGoodie"
+  },
+  "license": "CC BY-SA 4.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,13 +20,20 @@
       "default": "./dist/index.js"
     }
   },
+  "files": [
+    "src",
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
+    "type-testing": "^0.2.0",
     "typescript": "^5.9.3",
     "vite": "^7.3.1",
-    "vite-plugin-dts": "^4.5.4"
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
   },
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
@@ -24,6 +41,9 @@
     "nanoevents": "^9.1.0"
   },
   "scripts": {
-    "build": "vite build"
+    "build": "vite build",
+    "coverage": "vitest run --coverage",
+    "test": "tsc --noEmit && vitest run",
+    "test:watch": "vitest"
   }
 }

package/src/field/FieldPath.spec.ts

@@ -0,0 +1,204 @@
+import { Equal, Expect } from "type-testing";
+import { expect, test } from "vitest";
+import { FieldPath } from "../field/FieldPath";
+
+interface Person {
+  name: string;
+  surname: string;
+  address?: {
+    city: string;
+    street: string;
+  };
+  friends?: string[];
+  relations?: {
+    name: string;
+    points: number;
+    metAddress?: {
+      city: string;
+      street: string;
+    };
+  }[];
+}
+
+const person: Person = {
+  name: "John",
+  surname: "Doe",
+  address: {
+    city: "Arkham City",
+    street: "Sesame Street",
+  },
+  friends: ["Alice", "Bob"],
+  relations: [
+    {
+      name: "Alice",
+      points: 99,
+      metAddress: {
+        city: "Arkham City",
+        street: "Sesame Street",
+      },
+    },
+    {
+      name: "Bob",
+      points: 0,
+    },
+  ],
+};
+
+/* ------------------------------ */
+
+test("resolves field types by path", () => {
+  type Shape = {
+    user?: {
+      profile?: { name?: string };
+      tags?: boolean[];
+    };
+  };
+
+  type typeTests = [
+    Expect<
+      Equal<
+        FieldPath.Resolve<Shape, ["user"]>,
+        { profile?: { name?: string }; tags?: boolean[] } | undefined
+      >
+    >,
+
+    Expect<
+      Equal<
+        FieldPath.Resolve<Shape, ["user", "profile"]>,
+        { name?: string } | undefined
+      >
+    >,
+
+    Expect<
+      Equal<
+        FieldPath.Resolve<Shape, ["user", "profile", "name"]>,
+        string | undefined
+      >
+    >,
+
+    Expect<
+      Equal<
+        FieldPath.Resolve<Shape, ["user", "tags", number]>,
+        //
+        boolean
+      >
+    >,
+
+    Expect<
+      Equal<
+        FieldPath.Resolve<Shape, ["user", "tags", 0]>,
+        //
+        boolean
+      >
+    >,
+
+    Expect<
+      Equal<
+        FieldPath.Resolve<Shape, ["user", "missing"]>,
+        //
+        never
+      >
+    >,
+  ];
+});
+
+test("parses string paths", () => {
+  type PersonPaths = FieldPath.StringPaths<Person>;
+
+  const path1 = FieldPath.fromStringPath("a.b");
+  expect(path1).toStrictEqual(["a", "b"]);
+
+  const path2 = FieldPath.fromStringPath("a.b.c");
+  expect(path2).toStrictEqual(["a", "b", "c"]);
+
+  const path3 = FieldPath.fromStringPath("a[99].b.c[3]");
+  expect(path3).toStrictEqual(["a", 99, "b", "c", 3]);
+
+  type typeTests = [
+    Expect<
+      Equal<
+        PersonPaths,
+        | "name"
+        | "surname"
+        | "address"
+        | "friends"
+        | "relations"
+        | "address.city"
+        | "address.street"
+        | "friends[0]"
+        | FieldPath._Unfoldable<`friends[${number}]`>
+        | "relations[0]"
+        | FieldPath._Unfoldable<`relations[${number}]`>
+        | "relations[0].metAddress"
+        | FieldPath._Unfoldable<`relations[${number}].metAddress`>
+        | "relations[0].name"
+        | FieldPath._Unfoldable<`relations[${number}].name`>
+        | "relations[0].points"
+        | FieldPath._Unfoldable<`relations[${number}].points`>
+        | "relations[0].metAddress.city"
+        | FieldPath._Unfoldable<`relations[${number}].metAddress.city`>
+        | "relations[0].metAddress.street"
+        | FieldPath._Unfoldable<`relations[${number}].metAddress.street`>
+      >
+    >,
+  ];
+});
+
+test("gets fields properly", () => {
+  const getFieldValue = (stringPath: FieldPath.StringPaths<Person>) =>
+    FieldPath.getValue(person, FieldPath.fromStringPath(stringPath));
+
+  expect(getFieldValue("name")).toBe(person.name);
+  expect(getFieldValue("surname")).toBe(person.surname);
+  expect(getFieldValue("address")).toBe(person.address);
+  expect(getFieldValue("address.city")).toBe(person.address?.city);
+  expect(getFieldValue("address.street")).toBe(person.address?.street);
+  expect(getFieldValue("friends")).toBe(person.friends);
+  expect(getFieldValue("friends[0]")).toBe(person.friends?.[0]);
+  expect(getFieldValue("friends[1]")).toBe(person.friends?.[1]);
+  expect(getFieldValue("relations")).toBe(person.relations);
+  expect(getFieldValue("relations[0]")).toBe(person.relations?.[0]);
+  expect(getFieldValue("relations[1]")).toBe(person.relations?.[1]);
+  expect(getFieldValue("relations[1].metAddress.city")).toBe(
+    person.relations?.[1].metAddress?.city,
+  );
+});
+
+test("sets fields properly", () => {
+  const obj = {
+    a: 1,
+    b: 2,
+    c: {
+      d: 3,
+      e: [4, 5],
+    },
+  };
+
+  type ObjPaths = FieldPath.StringPaths<typeof obj>;
+
+  const getPath = <TPath extends ObjPaths>(stringPath: TPath) => {
+    return FieldPath.fromStringPath(stringPath);
+  };
+
+  const setFieldValue = <TPath extends FieldPath.Segments>(
+    path: TPath,
+    value: FieldPath.Resolve<typeof obj, TPath>,
+  ) => {
+    FieldPath.setValue(obj, path, value);
+  };
+
+  setFieldValue(getPath("a"), 99);
+  setFieldValue(getPath("b"), 99);
+  setFieldValue(getPath("c.d"), 99);
+  setFieldValue(getPath("c.e"), [99, 99]);
+  setFieldValue(getPath("c.e[2]"), 99);
+
+  expect(obj).toMatchObject({
+    a: 99,
+    b: 99,
+    c: {
+      d: 99,
+      e: [99, 99, 99],
+    },
+  });
+});

package/src/field/FieldPath.ts

@@ -1,12 +1,7 @@
 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 = "";
@@ -100,6 +95,7 @@ export namespace FieldPath {
     }
     return true;
   }
+
   export function isDescendant(parentPath: Segments, childPath: Segments) {
     if (parentPath.length >= childPath.length) return false;
 
@@ -112,15 +108,13 @@ export namespace FieldPath {
     return true;
   }
 
-  type Unfoldable<T> = T & { _____foldMark?: never } & {};
+  /** @internal used to mark and prevent array types, so IntellSense can suggest and accept array indices */
+  export type _Unfoldable<T> = T & { _____foldMark?: never } & {};
 
-  export type Resolve<
-    TObject,
-    TPath extends readonly PropertyKey[],
-  > = TPath extends []
+  export type Resolve<TObject, TPath extends Segments> = TPath extends []
     ? TObject
     : TPath extends readonly [infer Prop, ...infer Rest]
-      ? Rest extends readonly PropertyKey[]
+      ? Rest extends Segments
         ? Resolve<ResolveStep<TObject, Prop>, Rest>
         : never
       : never;
@@ -150,7 +144,7 @@ export namespace FieldPath {
     TCanonicalStringPaths extends `${string}[*]${string}`
       ?
           | ReplaceAll<TCanonicalStringPaths, "[*]", "[0]">
-          | Unfoldable<ReplaceAll<TCanonicalStringPaths, "[*]", `[${number}]`>>
+          | _Unfoldable<ReplaceAll<TCanonicalStringPaths, "[*]", `[${number}]`>>
       : TCanonicalStringPaths;
 
   type CanonicalStringPaths<TObject extends object> = {
@@ -210,9 +204,47 @@ export namespace FieldPath {
           ? K
           : never;
 
+  export function walkPath<
+    TObject extends object,
+    const TPath extends FieldPath.Segments,
+  >(object: TObject, path: TPath): { target: any; key: PropertyKey };
+  export function walkPath<
+    TObject extends object,
+    const TPath extends FieldPath.Segments,
+  >(
+    object: TObject,
+    path: TPath,
+    opts: { returnOnEmptyBranch: true },
+  ): { target: any; key: PropertyKey | null };
+  export function walkPath<
+    TObject extends object,
+    const TPath extends FieldPath.Segments,
+  >(object: TObject, path: TPath, opts?: { returnOnEmptyBranch?: boolean }) {
+    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) {
+        if (opts?.returnOnEmptyBranch) return { target: null, key: null };
+        current[pathFragment] = typeof nextFragment === "number" ? [] : {};
+      }
+
+      current = current[pathFragment];
+    }
+
+    const lastFragment = path[path.length - 1];
+
+    return {
+      target: current,
+      key: lastFragment,
+    };
+  }
+
   export function getValue<
     TObject extends object,
-    const TPath extends readonly PropertyKey[],
+    const TPath extends Segments,
   >(
     object: TObject,
     path: TPath,
@@ -229,64 +261,36 @@ export namespace FieldPath {
 
   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);
+    const TPath extends Segments,
+  >(object: TObject, path: TPath, value: FieldPath.Resolve<TObject, TPath>) {
+    const { target, key } = walkPath(object, path);
+    target[key] = value;
   }
 
   export function modifyValue<
     TObject extends object,
-    const TPath extends readonly PropertyKey[],
+    const TPath extends Segments,
   >(
     object: TObject,
     path: TPath,
     modifier: (
-      currentValue: FieldPath.Resolve<TObject, TPath>,
-    ) => FieldPath.Resolve<TObject, TPath> | void,
+      currentValue: FieldPath.Resolve<TObject, TPath> | undefined,
+    ) => 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;
-    }
+    const { target, key } = walkPath(object, path);
+    modifier(target[key]);
   }
 
-  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];
-    }
+  export function deleteValue<TObject extends object, TPath extends Segments>(
+    object: TObject,
+    path: TPath,
+  ) {
+    const { target, key } = walkPath(object, path, {
+      returnOnEmptyBranch: true,
+    });
 
-    const lastFragment = path[path.length - 1];
+    if (key == null) return;
 
-    delete current[lastFragment];
+    delete target[key];
   }
 }
-
-// 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.spec.ts

@@ -0,0 +1,47 @@
+import { expect, test } from "vitest";
+import { FieldPath } from "../field/FieldPath";
+import { FieldPathBuilder } from "../field/FieldPathBuilder";
+
+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,
+};
+
+test("builds path segments from proxy and string paths", () => {
+  const path1 = builder.of((data) => data.friends[0].tags[1]);
+  const value1 = FieldPath.getValue(data, path1);
+  expect(path1).toStrictEqual(["friends", 0, "tags", 1]);
+  expect(value1).toStrictEqual(data.friends[0].tags[1]);
+
+  const path2 = builder.of("friends[0].tags[0]");
+  const value2 = FieldPath.getValue(data, path2);
+  expect(path2).toStrictEqual(["friends", 0, "tags", 0]);
+  expect(value2).toStrictEqual(data.friends[0].tags[0]);
+
+  const path3 = builder.of("friends[0].tags");
+  const value3 = FieldPath.getValue(data, path3);
+  expect(path3).toStrictEqual(["friends", 0, "tags"]);
+  expect(value3).toStrictEqual(data.friends[0].tags);
+
+  const path4 = builder.of("coords[1]");
+  const value4 = FieldPath.getValue(data, path4);
+  expect(path4).toStrictEqual(["coords", 1]);
+  expect(value4).toStrictEqual(data.coords[1]);
+});

package/src/field/FieldPathBuilder.ts

@@ -44,89 +44,23 @@ export class FieldPathBuilder<TOutput extends object> {
     }) as any;
   }
 
-  public fromStringPath<TStrPath extends FieldPath.StringPaths<TOutput>>(
+  public of<TStrPath extends FieldPath.StringPaths<TOutput>>(
     stringPath: TStrPath,
-  ) {
-    return FieldPath.fromStringPath(
-      stringPath,
-    ) as unknown as FieldPath.ParseStringPath<TStrPath>;
-  }
+  ): FieldPath.ParseStringPath<TStrPath>;
 
-  public fromProxy<TProxy extends FieldPathBuilder.Proxy<any, any>>(
+  public of<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);
+  ): TProxy[typeof resolverCall];
 
-// 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]>;
-// //   ^?
+  public of(
+    arg:
+      | FieldPath.StringPaths<TOutput>
+      | ((data: FieldPathBuilder.Proxy<TOutput, []>) => any),
+  ) {
+    if (typeof arg === "function") {
+      return arg(FieldPathBuilder.wrap<TOutput, []>([]))[resolverCall];
+    }
 
-// type D = FieldPath.Resolve<Shape, ["user", "missing"]>;
-// //   ^?
+    return FieldPath.fromStringPath(arg as any);
+  }
+}

package/src/field/Reconcile.ts

@@ -1,4 +1,4 @@
-export namespace Reconsile {
+export namespace Reconcile {
   export function deepEqual(
     a: any,
     b: any,
@@ -70,27 +70,32 @@ export namespace Reconsile {
     return true;
   }
 
-  export function diff<T>(
+  export function arrayDiff<T>(
     prev: readonly T[],
     next: readonly T[],
-    equals: (a: T, b: T) => boolean,
-    filter?: (a: T) => boolean,
+    opts?: {
+      equals?: (a: T, b: T) => boolean;
+      include?: (a: T) => boolean;
+    },
   ) {
     const added: T[] = [];
     const removed: T[] = [];
     const unchanged: T[] = [];
 
+    const equals = (a: T, b: T) => (opts?.equals ? opts.equals(a, b) : a === b);
+    const include = (a: T) => (opts?.include ? opts.include(a) : true);
+
     for (const n of next) {
       if (prev.some((p) => equals(p, n))) {
-        if (filter?.(n) ?? true) unchanged.push(n);
+        if (include(n)) unchanged.push(n);
       } else {
-        if (filter?.(n) ?? true) added.push(n);
+        if (include(n)) added.push(n);
       }
     }
 
     for (const p of prev) {
       if (!next.some((n) => equals(p, n))) {
-        if (filter?.(p) ?? true) removed.push(p);
+        if (include(p)) removed.push(p);
       }
     }