@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 76 lines 2.53 KB
Raw
1 /**
2 * Shallow, order-sensitive array equality. `undefined`-tolerant: two
3 * `undefined`s are equal, an `undefined` and an array are not.
4 *
5 * Pass a custom `eq` comparator for non-primitive elements, e.g.
6 * `(x, y) => JSON.stringify(x) === JSON.stringify(y)`.
7 */
8 export const arrayEquals = <T>(
9 a: ReadonlyArray<T> | undefined,
10 b: ReadonlyArray<T> | undefined,
11 eq: (x: T, y: T) => boolean = (x, y) => x === y,
12 ): boolean => {
13 if (a === b) return true;
14 if (a === undefined || b === undefined) return false;
15 if (a.length !== b.length) return false;
16 for (let i = 0; i < a.length; i++) {
17 if (!eq(a[i], b[i])) return false;
18 }
19 return true;
20 };
21
22 /**
23 * Order-insensitive array equality for primitive elements (compares
24 * sorted copies). `undefined`-tolerant like {@link arrayEquals}.
25 */
26 export const arrayEqualsUnordered = <T extends string | number>(
27 a: ReadonlyArray<T> | undefined,
28 b: ReadonlyArray<T> | undefined,
29 ): boolean => {
30 if (a === b) return true;
31 if (a === undefined || b === undefined) return false;
32 if (a.length !== b.length) return false;
33 const compare = (x: T, y: T) => (x < y ? -1 : x > y ? 1 : 0);
34 const as = [...a].sort(compare);
35 const bs = [...b].sort(compare);
36 for (let i = 0; i < as.length; i++) {
37 if (as[i] !== bs[i]) return false;
38 }
39 return true;
40 };
41
42 /**
43 * Shallow equality of two string records (same keys, same values).
44 */
45 export const recordsEqual = (a: Record<string, string>, b: Record<string, string>): boolean => {
46 const aKeys = Object.keys(a);
47 const bKeys = Object.keys(b);
48 if (aKeys.length !== bKeys.length) return false;
49 for (const k of aKeys) {
50 if (a[k] !== b[k]) return false;
51 }
52 return true;
53 };
54
55 /**
56 * True when any DEFINED leaf of `desired` differs from the corresponding
57 * value in `observed`. Keys the caller left undefined are ignored, so the
58 * comparison only covers configuration the user actually expressed.
59 */
60 export const subsetDiffers = (desired: unknown, observed: unknown): boolean => {
61 if (desired === undefined) return false;
62 if (Array.isArray(desired)) {
63 if (!Array.isArray(observed) || observed.length !== desired.length) {
64 return true;
65 }
66 return desired.some((value, i) => subsetDiffers(value, observed[i]));
67 }
68 if (typeof desired === "object" && desired !== null) {
69 if (typeof observed !== "object" || observed === null) return true;
70 return Object.entries(desired).some(
71 ([key, value]) =>
72 value !== undefined && subsetDiffers(value, (observed as Record<string, unknown>)[key]),
73 );
74 }
75 return desired !== observed;
76 };