The best way to control Claude Code, Codex and more from any computer or phone
| 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 | }; |