@stack-dev/core 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+
+
+> @stack-dev/core@0.1.0 build /home/benmclean/projects/stack-dev/packages/core
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v7.3.0
+CLI Using tsup config: /home/benmclean/projects/stack-dev/packages/core/tsup.config.ts
+CLI Target: esnext
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.mjs     1.88 KB
+ESM dist/index.mjs.map 4.31 KB
+ESM ⚡️ Build success in 12ms
+CJS dist/index.js     3.06 KB
+CJS dist/index.js.map 4.53 KB
+CJS ⚡️ Build success in 12ms
+DTS Build start
+DTS ⚡️ Build success in 490ms
+DTS dist/index.d.mts 987.00 B
+DTS dist/index.d.ts  987.00 B

package/.turbo/turbo-check-types.log

@@ -0,0 +1,5 @@
+
+
+> @stack-dev/core@0.1.0 check-types /home/benmclean/projects/stack-dev/packages/core
+> tsc --noEmit
+

package/dist/index.d.mts

@@ -0,0 +1,19 @@
+declare const TOL = 1e-8;
+type EqualityChecker<T> = (t1: T, t2: T, tol?: number) => boolean;
+interface Equalable {
+    equals(other: unknown, tol?: number): boolean;
+}
+declare function isEqualable(t: unknown): t is Equalable;
+declare const defaultEqualityChecker: EqualityChecker<unknown>;
+declare function haveSameItems<T>(it1: Iterable<T>, it2: Iterable<T>, check?: EqualityChecker<T>): boolean;
+
+declare function areObjectsEqual<T>(a: Record<string, T>, b: Record<string, T>, areEqual?: EqualityChecker<T>): boolean;
+
+declare function sortKeys<T extends Record<string, unknown>>(obj: T, comparer: (a: string, b: string) => number): Record<string, unknown>;
+
+type Snapshot = {
+    [key: string]: SnapshotValue;
+};
+type SnapshotValue = string | number | boolean | undefined | Snapshot | ReadonlyArray<SnapshotValue>;
+
+export { type Equalable, type EqualityChecker, type Snapshot, type SnapshotValue, TOL, areObjectsEqual, defaultEqualityChecker, haveSameItems, isEqualable, sortKeys };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+declare const TOL = 1e-8;
+type EqualityChecker<T> = (t1: T, t2: T, tol?: number) => boolean;
+interface Equalable {
+    equals(other: unknown, tol?: number): boolean;
+}
+declare function isEqualable(t: unknown): t is Equalable;
+declare const defaultEqualityChecker: EqualityChecker<unknown>;
+declare function haveSameItems<T>(it1: Iterable<T>, it2: Iterable<T>, check?: EqualityChecker<T>): boolean;
+
+declare function areObjectsEqual<T>(a: Record<string, T>, b: Record<string, T>, areEqual?: EqualityChecker<T>): boolean;
+
+declare function sortKeys<T extends Record<string, unknown>>(obj: T, comparer: (a: string, b: string) => number): Record<string, unknown>;
+
+type Snapshot = {
+    [key: string]: SnapshotValue;
+};
+type SnapshotValue = string | number | boolean | undefined | Snapshot | ReadonlyArray<SnapshotValue>;
+
+export { type Equalable, type EqualityChecker, type Snapshot, type SnapshotValue, TOL, areObjectsEqual, defaultEqualityChecker, haveSameItems, isEqualable, sortKeys };

package/dist/index.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TOL: () => TOL,
+  areObjectsEqual: () => areObjectsEqual,
+  defaultEqualityChecker: () => defaultEqualityChecker,
+  haveSameItems: () => haveSameItems,
+  isEqualable: () => isEqualable,
+  sortKeys: () => sortKeys
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/have-same-items.ts
+var TOL = 1e-8;
+function isEqualable(t) {
+  return typeof t === "object" && t !== null && "equals" in t && typeof t.equals === "function";
+}
+var defaultEqualityChecker = (t1, t2, tol = TOL) => {
+  if (isEqualable(t1)) {
+    return t1.equals(t2, tol);
+  } else {
+    return t1 === t2;
+  }
+};
+function haveSameItems(it1, it2, check = defaultEqualityChecker) {
+  if (bothZeroLength(it1, it2)) {
+    return true;
+  }
+  if (diffLength(it1, it2)) {
+    return false;
+  }
+  return haveSameItems_sameLength(it1, it2, check);
+}
+function haveSameItems_sameLength(it1, it2, check) {
+  const arr1 = [...it1];
+  let arr2 = [...it2];
+  for (const item1 of arr1) {
+    const i2 = arr2.findIndex((item2) => check(item1, item2));
+    if (i2 === -1) {
+      return false;
+    } else {
+      arr2 = remoteAtIndex(arr2, i2);
+    }
+  }
+  return true;
+}
+function remoteAtIndex(arr, i2) {
+  const before = arr.slice(0, i2);
+  const after = arr.slice(i2 + 1);
+  return [...before, ...after];
+}
+function diffLength(it1, it2) {
+  return getSize(it1) !== getSize(it2);
+}
+function bothZeroLength(it1, it2) {
+  return getSize(it1) === 0 && getSize(it2) === 0;
+}
+function getSize(it) {
+  return [...it].length;
+}
+
+// src/are-objects-equal.ts
+function areObjectsEqual(a, b, areEqual = defaultEqualityChecker) {
+  return areObjectsEqualInOneDirection(a, b, areEqual) || areObjectsEqualInOneDirection(b, a, areEqual);
+}
+function areObjectsEqualInOneDirection(a, b, areEqual) {
+  for (const key of Object.keys(a)) {
+    if (!(key in b) || !areEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/sort-keys.ts
+function sortKeys(obj, comparer) {
+  const sortedEntries = Object.entries(obj).sort(([a], [b]) => comparer(a, b));
+  return Object.fromEntries(sortedEntries);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOL,
+  areObjectsEqual,
+  defaultEqualityChecker,
+  haveSameItems,
+  isEqualable,
+  sortKeys
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/have-same-items.ts","../src/are-objects-equal.ts","../src/sort-keys.ts"],"sourcesContent":["export * from './are-objects-equal';\nexport * from './have-same-items';\n\nexport * from './sort-keys';\n\nexport * from './snapshot';\n","// TODO: Break this up\nexport const TOL = 1e-8;\n\nexport type EqualityChecker<T> = (t1: T, t2: T, tol?: number) => boolean;\n\nexport interface Equalable {\n  equals(other: unknown, tol?: number): boolean;\n}\n\nexport function isEqualable(t: unknown): t is Equalable {\n  return (\n    typeof t === 'object' &&\n    t !== null &&\n    'equals' in t &&\n    typeof t.equals === 'function'\n  );\n}\n\nexport const defaultEqualityChecker: EqualityChecker<unknown> = (\n  t1,\n  t2,\n  tol = TOL,\n) => {\n  if (isEqualable(t1)) {\n    return t1.equals(t2, tol);\n  } else {\n    return t1 === t2;\n  }\n};\n\nexport function haveSameItems<T>(\n  it1: Iterable<T>,\n  it2: Iterable<T>,\n  check: EqualityChecker<T> = defaultEqualityChecker,\n): boolean {\n  if (bothZeroLength<T>(it1, it2)) {\n    return true;\n  }\n\n  if (diffLength<T>(it1, it2)) {\n    return false;\n  }\n\n  return haveSameItems_sameLength(it1, it2, check);\n}\n\nfunction haveSameItems_sameLength<T>(\n  it1: Iterable<T>,\n  it2: Iterable<T>,\n  check: EqualityChecker<T>,\n) {\n  const arr1 = [...it1];\n  let arr2 = [...it2];\n\n  for (const item1 of arr1) {\n    const i2 = arr2.findIndex((item2) => check(item1, item2));\n    if (i2 === -1) {\n      return false;\n    } else {\n      arr2 = remoteAtIndex(arr2, i2);\n    }\n  }\n\n  return true;\n}\n\nfunction remoteAtIndex<T>(arr: Array<T>, i2: number): Array<T> {\n  const before = arr.slice(0, i2);\n  const after = arr.slice(i2 + 1);\n\n  return [...before, ...after];\n}\n\nfunction diffLength<T>(it1: Iterable<T>, it2: Iterable<T>) {\n  return getSize(it1) !== getSize(it2);\n}\n\nfunction bothZeroLength<T>(it1: Iterable<T>, it2: Iterable<T>) {\n  return getSize(it1) === 0 && getSize(it2) === 0;\n}\n\nfunction getSize(it: Iterable<unknown>): number {\n  return [...it].length;\n}\n","import { EqualityChecker, defaultEqualityChecker } from './have-same-items';\n\nexport function areObjectsEqual<T>(\n  a: Record<string, T>,\n  b: Record<string, T>,\n  areEqual: EqualityChecker<T> = defaultEqualityChecker,\n): boolean {\n  return (\n    areObjectsEqualInOneDirection(a, b, areEqual) ||\n    areObjectsEqualInOneDirection(b, a, areEqual)\n  );\n}\n\nfunction areObjectsEqualInOneDirection<T>(\n  a: Record<string, T>,\n  b: Record<string, T>,\n  areEqual: EqualityChecker<T>,\n): boolean {\n  for (const key of Object.keys(a)) {\n    if (!(key in b) || !areEqual(a[key], b[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","export function sortKeys<T extends Record<string, unknown>>(\n  obj: T,\n  comparer: (a: string, b: string) => number,\n): Record<string, unknown> {\n  const sortedEntries = Object.entries(obj).sort(([a], [b]) => comparer(a, b));\n  return Object.fromEntries(sortedEntries);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCO,IAAM,MAAM;AAQZ,SAAS,YAAY,GAA4B;AACtD,SACE,OAAO,MAAM,YACb,MAAM,QACN,YAAY,KACZ,OAAO,EAAE,WAAW;AAExB;AAEO,IAAM,yBAAmD,CAC9D,IACA,IACA,MAAM,QACH;AACH,MAAI,YAAY,EAAE,GAAG;AACnB,WAAO,GAAG,OAAO,IAAI,GAAG;AAAA,EAC1B,OAAO;AACL,WAAO,OAAO;AAAA,EAChB;AACF;AAEO,SAAS,cACd,KACA,KACA,QAA4B,wBACnB;AACT,MAAI,eAAkB,KAAK,GAAG,GAAG;AAC/B,WAAO;AAAA,EACT;AAEA,MAAI,WAAc,KAAK,GAAG,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,yBAAyB,KAAK,KAAK,KAAK;AACjD;AAEA,SAAS,yBACP,KACA,KACA,OACA;AACA,QAAM,OAAO,CAAC,GAAG,GAAG;AACpB,MAAI,OAAO,CAAC,GAAG,GAAG;AAElB,aAAW,SAAS,MAAM;AACxB,UAAM,KAAK,KAAK,UAAU,CAAC,UAAU,MAAM,OAAO,KAAK,CAAC;AACxD,QAAI,OAAO,IAAI;AACb,aAAO;AAAA,IACT,OAAO;AACL,aAAO,cAAc,MAAM,EAAE;AAAA,IAC/B;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,cAAiB,KAAe,IAAsB;AAC7D,QAAM,SAAS,IAAI,MAAM,GAAG,EAAE;AAC9B,QAAM,QAAQ,IAAI,MAAM,KAAK,CAAC;AAE9B,SAAO,CAAC,GAAG,QAAQ,GAAG,KAAK;AAC7B;AAEA,SAAS,WAAc,KAAkB,KAAkB;AACzD,SAAO,QAAQ,GAAG,MAAM,QAAQ,GAAG;AACrC;AAEA,SAAS,eAAkB,KAAkB,KAAkB;AAC7D,SAAO,QAAQ,GAAG,MAAM,KAAK,QAAQ,GAAG,MAAM;AAChD;AAEA,SAAS,QAAQ,IAA+B;AAC9C,SAAO,CAAC,GAAG,EAAE,EAAE;AACjB;;;ACjFO,SAAS,gBACd,GACA,GACA,WAA+B,wBACtB;AACT,SACE,8BAA8B,GAAG,GAAG,QAAQ,KAC5C,8BAA8B,GAAG,GAAG,QAAQ;AAEhD;AAEA,SAAS,8BACP,GACA,GACA,UACS;AACT,aAAW,OAAO,OAAO,KAAK,CAAC,GAAG;AAChC,QAAI,EAAE,OAAO,MAAM,CAAC,SAAS,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG;AAC5C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;;;ACzBO,SAAS,SACd,KACA,UACyB;AACzB,QAAM,gBAAgB,OAAO,QAAQ,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC;AAC3E,SAAO,OAAO,YAAY,aAAa;AACzC;","names":[]}

package/dist/index.mjs

@@ -0,0 +1,76 @@
+// src/have-same-items.ts
+var TOL = 1e-8;
+function isEqualable(t) {
+  return typeof t === "object" && t !== null && "equals" in t && typeof t.equals === "function";
+}
+var defaultEqualityChecker = (t1, t2, tol = TOL) => {
+  if (isEqualable(t1)) {
+    return t1.equals(t2, tol);
+  } else {
+    return t1 === t2;
+  }
+};
+function haveSameItems(it1, it2, check = defaultEqualityChecker) {
+  if (bothZeroLength(it1, it2)) {
+    return true;
+  }
+  if (diffLength(it1, it2)) {
+    return false;
+  }
+  return haveSameItems_sameLength(it1, it2, check);
+}
+function haveSameItems_sameLength(it1, it2, check) {
+  const arr1 = [...it1];
+  let arr2 = [...it2];
+  for (const item1 of arr1) {
+    const i2 = arr2.findIndex((item2) => check(item1, item2));
+    if (i2 === -1) {
+      return false;
+    } else {
+      arr2 = remoteAtIndex(arr2, i2);
+    }
+  }
+  return true;
+}
+function remoteAtIndex(arr, i2) {
+  const before = arr.slice(0, i2);
+  const after = arr.slice(i2 + 1);
+  return [...before, ...after];
+}
+function diffLength(it1, it2) {
+  return getSize(it1) !== getSize(it2);
+}
+function bothZeroLength(it1, it2) {
+  return getSize(it1) === 0 && getSize(it2) === 0;
+}
+function getSize(it) {
+  return [...it].length;
+}
+
+// src/are-objects-equal.ts
+function areObjectsEqual(a, b, areEqual = defaultEqualityChecker) {
+  return areObjectsEqualInOneDirection(a, b, areEqual) || areObjectsEqualInOneDirection(b, a, areEqual);
+}
+function areObjectsEqualInOneDirection(a, b, areEqual) {
+  for (const key of Object.keys(a)) {
+    if (!(key in b) || !areEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/sort-keys.ts
+function sortKeys(obj, comparer) {
+  const sortedEntries = Object.entries(obj).sort(([a], [b]) => comparer(a, b));
+  return Object.fromEntries(sortedEntries);
+}
+export {
+  TOL,
+  areObjectsEqual,
+  defaultEqualityChecker,
+  haveSameItems,
+  isEqualable,
+  sortKeys
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/have-same-items.ts","../src/are-objects-equal.ts","../src/sort-keys.ts"],"sourcesContent":["// TODO: Break this up\nexport const TOL = 1e-8;\n\nexport type EqualityChecker<T> = (t1: T, t2: T, tol?: number) => boolean;\n\nexport interface Equalable {\n  equals(other: unknown, tol?: number): boolean;\n}\n\nexport function isEqualable(t: unknown): t is Equalable {\n  return (\n    typeof t === 'object' &&\n    t !== null &&\n    'equals' in t &&\n    typeof t.equals === 'function'\n  );\n}\n\nexport const defaultEqualityChecker: EqualityChecker<unknown> = (\n  t1,\n  t2,\n  tol = TOL,\n) => {\n  if (isEqualable(t1)) {\n    return t1.equals(t2, tol);\n  } else {\n    return t1 === t2;\n  }\n};\n\nexport function haveSameItems<T>(\n  it1: Iterable<T>,\n  it2: Iterable<T>,\n  check: EqualityChecker<T> = defaultEqualityChecker,\n): boolean {\n  if (bothZeroLength<T>(it1, it2)) {\n    return true;\n  }\n\n  if (diffLength<T>(it1, it2)) {\n    return false;\n  }\n\n  return haveSameItems_sameLength(it1, it2, check);\n}\n\nfunction haveSameItems_sameLength<T>(\n  it1: Iterable<T>,\n  it2: Iterable<T>,\n  check: EqualityChecker<T>,\n) {\n  const arr1 = [...it1];\n  let arr2 = [...it2];\n\n  for (const item1 of arr1) {\n    const i2 = arr2.findIndex((item2) => check(item1, item2));\n    if (i2 === -1) {\n      return false;\n    } else {\n      arr2 = remoteAtIndex(arr2, i2);\n    }\n  }\n\n  return true;\n}\n\nfunction remoteAtIndex<T>(arr: Array<T>, i2: number): Array<T> {\n  const before = arr.slice(0, i2);\n  const after = arr.slice(i2 + 1);\n\n  return [...before, ...after];\n}\n\nfunction diffLength<T>(it1: Iterable<T>, it2: Iterable<T>) {\n  return getSize(it1) !== getSize(it2);\n}\n\nfunction bothZeroLength<T>(it1: Iterable<T>, it2: Iterable<T>) {\n  return getSize(it1) === 0 && getSize(it2) === 0;\n}\n\nfunction getSize(it: Iterable<unknown>): number {\n  return [...it].length;\n}\n","import { EqualityChecker, defaultEqualityChecker } from './have-same-items';\n\nexport function areObjectsEqual<T>(\n  a: Record<string, T>,\n  b: Record<string, T>,\n  areEqual: EqualityChecker<T> = defaultEqualityChecker,\n): boolean {\n  return (\n    areObjectsEqualInOneDirection(a, b, areEqual) ||\n    areObjectsEqualInOneDirection(b, a, areEqual)\n  );\n}\n\nfunction areObjectsEqualInOneDirection<T>(\n  a: Record<string, T>,\n  b: Record<string, T>,\n  areEqual: EqualityChecker<T>,\n): boolean {\n  for (const key of Object.keys(a)) {\n    if (!(key in b) || !areEqual(a[key], b[key])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","export function sortKeys<T extends Record<string, unknown>>(\n  obj: T,\n  comparer: (a: string, b: string) => number,\n): Record<string, unknown> {\n  const sortedEntries = Object.entries(obj).sort(([a], [b]) => comparer(a, b));\n  return Object.fromEntries(sortedEntries);\n}\n"],"mappings":";AACO,IAAM,MAAM;AAQZ,SAAS,YAAY,GAA4B;AACtD,SACE,OAAO,MAAM,YACb,MAAM,QACN,YAAY,KACZ,OAAO,EAAE,WAAW;AAExB;AAEO,IAAM,yBAAmD,CAC9D,IACA,IACA,MAAM,QACH;AACH,MAAI,YAAY,EAAE,GAAG;AACnB,WAAO,GAAG,OAAO,IAAI,GAAG;AAAA,EAC1B,OAAO;AACL,WAAO,OAAO;AAAA,EAChB;AACF;AAEO,SAAS,cACd,KACA,KACA,QAA4B,wBACnB;AACT,MAAI,eAAkB,KAAK,GAAG,GAAG;AAC/B,WAAO;AAAA,EACT;AAEA,MAAI,WAAc,KAAK,GAAG,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,yBAAyB,KAAK,KAAK,KAAK;AACjD;AAEA,SAAS,yBACP,KACA,KACA,OACA;AACA,QAAM,OAAO,CAAC,GAAG,GAAG;AACpB,MAAI,OAAO,CAAC,GAAG,GAAG;AAElB,aAAW,SAAS,MAAM;AACxB,UAAM,KAAK,KAAK,UAAU,CAAC,UAAU,MAAM,OAAO,KAAK,CAAC;AACxD,QAAI,OAAO,IAAI;AACb,aAAO;AAAA,IACT,OAAO;AACL,aAAO,cAAc,MAAM,EAAE;AAAA,IAC/B;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,cAAiB,KAAe,IAAsB;AAC7D,QAAM,SAAS,IAAI,MAAM,GAAG,EAAE;AAC9B,QAAM,QAAQ,IAAI,MAAM,KAAK,CAAC;AAE9B,SAAO,CAAC,GAAG,QAAQ,GAAG,KAAK;AAC7B;AAEA,SAAS,WAAc,KAAkB,KAAkB;AACzD,SAAO,QAAQ,GAAG,MAAM,QAAQ,GAAG;AACrC;AAEA,SAAS,eAAkB,KAAkB,KAAkB;AAC7D,SAAO,QAAQ,GAAG,MAAM,KAAK,QAAQ,GAAG,MAAM;AAChD;AAEA,SAAS,QAAQ,IAA+B;AAC9C,SAAO,CAAC,GAAG,EAAE,EAAE;AACjB;;;ACjFO,SAAS,gBACd,GACA,GACA,WAA+B,wBACtB;AACT,SACE,8BAA8B,GAAG,GAAG,QAAQ,KAC5C,8BAA8B,GAAG,GAAG,QAAQ;AAEhD;AAEA,SAAS,8BACP,GACA,GACA,UACS;AACT,aAAW,OAAO,OAAO,KAAK,CAAC,GAAG;AAChC,QAAI,EAAE,OAAO,MAAM,CAAC,SAAS,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG;AAC5C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;;;ACzBO,SAAS,SACd,KACA,UACyB;AACzB,QAAM,gBAAgB,OAAO,QAAQ,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC;AAC3E,SAAO,OAAO,YAAY,aAAa;AACzC;","names":[]}

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import base from '@stack-dev/eslint-config/base.mjs';
+
+export default [...base, { ignores: ['**/dist/**'] }];

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@stack-dev/core",
+  "version": "0.1.0",
+  "private": false,
+  "devDependencies": {
+    "eslint": "^9.32.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-organize-imports": "^4.2.0",
+    "tsup": "^7.3.0",
+    "vitest": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@stack-dev/eslint-config": "0.1.0",
+    "@stack-dev/prettier-config": "0.1.0",
+    "@stack-dev/typescript-config": "0.1.0"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "check-types": "tsc --noEmit",
+    "build": "tsup",
+    "lint": "eslint",
+    "format": "prettier . --write",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/prettier.config.mjs

@@ -0,0 +1,3 @@
+import base from '@stack-dev/prettier-config/base.mjs';
+
+export default base;

package/src/are-objects-equal.ts

@@ -0,0 +1,26 @@
+import { EqualityChecker, defaultEqualityChecker } from './have-same-items';
+
+export function areObjectsEqual<T>(
+  a: Record<string, T>,
+  b: Record<string, T>,
+  areEqual: EqualityChecker<T> = defaultEqualityChecker,
+): boolean {
+  return (
+    areObjectsEqualInOneDirection(a, b, areEqual) ||
+    areObjectsEqualInOneDirection(b, a, areEqual)
+  );
+}
+
+function areObjectsEqualInOneDirection<T>(
+  a: Record<string, T>,
+  b: Record<string, T>,
+  areEqual: EqualityChecker<T>,
+): boolean {
+  for (const key of Object.keys(a)) {
+    if (!(key in b) || !areEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/have-same-items.ts

@@ -0,0 +1,84 @@
+// TODO: Break this up
+export const TOL = 1e-8;
+
+export type EqualityChecker<T> = (t1: T, t2: T, tol?: number) => boolean;
+
+export interface Equalable {
+  equals(other: unknown, tol?: number): boolean;
+}
+
+export function isEqualable(t: unknown): t is Equalable {
+  return (
+    typeof t === 'object' &&
+    t !== null &&
+    'equals' in t &&
+    typeof t.equals === 'function'
+  );
+}
+
+export const defaultEqualityChecker: EqualityChecker<unknown> = (
+  t1,
+  t2,
+  tol = TOL,
+) => {
+  if (isEqualable(t1)) {
+    return t1.equals(t2, tol);
+  } else {
+    return t1 === t2;
+  }
+};
+
+export function haveSameItems<T>(
+  it1: Iterable<T>,
+  it2: Iterable<T>,
+  check: EqualityChecker<T> = defaultEqualityChecker,
+): boolean {
+  if (bothZeroLength<T>(it1, it2)) {
+    return true;
+  }
+
+  if (diffLength<T>(it1, it2)) {
+    return false;
+  }
+
+  return haveSameItems_sameLength(it1, it2, check);
+}
+
+function haveSameItems_sameLength<T>(
+  it1: Iterable<T>,
+  it2: Iterable<T>,
+  check: EqualityChecker<T>,
+) {
+  const arr1 = [...it1];
+  let arr2 = [...it2];
+
+  for (const item1 of arr1) {
+    const i2 = arr2.findIndex((item2) => check(item1, item2));
+    if (i2 === -1) {
+      return false;
+    } else {
+      arr2 = remoteAtIndex(arr2, i2);
+    }
+  }
+
+  return true;
+}
+
+function remoteAtIndex<T>(arr: Array<T>, i2: number): Array<T> {
+  const before = arr.slice(0, i2);
+  const after = arr.slice(i2 + 1);
+
+  return [...before, ...after];
+}
+
+function diffLength<T>(it1: Iterable<T>, it2: Iterable<T>) {
+  return getSize(it1) !== getSize(it2);
+}
+
+function bothZeroLength<T>(it1: Iterable<T>, it2: Iterable<T>) {
+  return getSize(it1) === 0 && getSize(it2) === 0;
+}
+
+function getSize(it: Iterable<unknown>): number {
+  return [...it].length;
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './are-objects-equal';
+export * from './have-same-items';
+
+export * from './sort-keys';
+
+export * from './snapshot';

package/src/snapshot.ts

@@ -0,0 +1,11 @@
+export type Snapshot = {
+  [key: string]: SnapshotValue;
+};
+
+export type SnapshotValue =
+  | string
+  | number
+  | boolean
+  | undefined
+  | Snapshot
+  | ReadonlyArray<SnapshotValue>;

package/src/sort-keys.ts

@@ -0,0 +1,7 @@
+export function sortKeys<T extends Record<string, unknown>>(
+  obj: T,
+  comparer: (a: string, b: string) => number,
+): Record<string, unknown> {
+  const sortedEntries = Object.entries(obj).sort(([a], [b]) => comparer(a, b));
+  return Object.fromEntries(sortedEntries);
+}

package/src/spec/are-objects-equal.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+
+import { areObjectsEqual } from '../are-objects-equal';
+
+describe('areObjectsEqual', () => {
+  it('Returns true for both empty.', () => {
+    expect(areObjectsEqual({}, {})).toBe(true);
+  });
+
+  it('Returns false with different keys.', () => {
+    const a = { a: 1, b: 2 };
+    const b = { a: 1, c: 3 };
+
+    expect(areObjectsEqual(a, b)).toBe(false);
+  });
+
+  it('Returns false with different values.', () => {
+    const a = { a: 1, b: 2 };
+    const b = { b: 3, a: 1 };
+
+    expect(areObjectsEqual(a, b)).toBe(false);
+  });
+
+  it('Returns true with same values.', () => {
+    const a = { a: 1, b: 2 };
+    const b = { b: 2, a: 1 };
+
+    expect(areObjectsEqual(a, b)).toBe(true);
+  });
+});

package/src/spec/have-same-items.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import { haveSameItems } from '../have-same-items';
+
+const numsEqual = (n1: number, n2: number) => n1 === n2;
+
+describe('haveSameItems', () => {
+  it('Returns true for empty.', () => {
+    expect(haveSameItems([], [], () => false)).toBe(true);
+  });
+
+  it('Returns false for different sizes', () => {
+    expect(haveSameItems([], [1], () => true)).toBe(false);
+    expect(haveSameItems([1], [], () => true)).toBe(false);
+  });
+
+  it('Returns true for equal in order.', () => {
+    expect(haveSameItems([1, 2, 3], [1, 2, 3], numsEqual)).toBe(true);
+  });
+
+  it('Returns true for same items.', () => {
+    expect(haveSameItems([1, 2, 3], [2, 1, 3], numsEqual)).toBe(true);
+  });
+
+  it('Returns false for different items.', () => {
+    expect(haveSameItems([1, 2, 0], [2, 1, 3], numsEqual)).toBe(false);
+    expect(haveSameItems([1, 1, 1], [2, 1, 1], numsEqual)).toBe(false);
+  });
+});

package/src/spec/sort-keys.spec.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+
+import { areObjectsEqual } from '../are-objects-equal';
+import { sortKeys } from '../sort-keys';
+
+describe('sortKeys', () => {
+  it('sorts keys alphabetically', () => {
+    const input = {
+      z: 1,
+      a: 2,
+      m: 3,
+    };
+
+    const result = sortKeys(input, (a, b) => a.localeCompare(b));
+
+    expect(Object.keys(result)).toEqual(['a', 'm', 'z']);
+  });
+
+  it('prioritizes certain keys using a custom comparer', () => {
+    const input = {
+      scripts: {},
+      version: '1.0.0',
+      name: 'my-package',
+      dependencies: {},
+    };
+
+    function comparer(a: string, b: string) {
+      return getIndex(a) - getIndex(b);
+    }
+
+    function getIndex(s: string): number {
+      switch (s.toLowerCase()) {
+        case 'name':
+          return 1;
+        case 'version':
+          return 2;
+        case 'scripts':
+          return 3;
+        case 'dependencies':
+          return 4;
+        default:
+          return 0;
+      }
+    }
+
+    const result = sortKeys(input, comparer);
+
+    expect(Object.keys(result)).toEqual([
+      'name',
+      'version',
+      'scripts',
+      'dependencies',
+    ]);
+
+    expect(areObjectsEqual(input, result)).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@stack-dev/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'], // Tree-shakable ESM + CommonJS for broader support
+  dts: true, // Emit type declarations
+  sourcemap: true,
+  clean: true,
+  target: 'esnext',
+  outExtension({ format }) {
+    return {
+      js: format === 'esm' ? '.mjs' : '.js',
+    };
+  },
+});

package/vitest.config.mts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    coverage: {
+      provider: 'v8',
+    },
+    environment: 'node',
+  },
+});