@excom/hash-object 0.1.0

package/.rush/temp/chunked-rush-logs/hash-object.apply-exports.chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: cd \"$RUSH_PROJECT_FOLDER\" && node ../heft-rig/scripts/apply-exports.mjs \n"}

package/.rush/temp/chunked-rush-logs/hash-object.build_package-metas.chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs \n"}

package/.rush/temp/operation/apply-exports/all.log

@@ -0,0 +1 @@
+Invoking: cd "$RUSH_PROJECT_FOLDER" && node ../heft-rig/scripts/apply-exports.mjs 

package/.rush/temp/operation/apply-exports/log-chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: cd \"$RUSH_PROJECT_FOLDER\" && node ../heft-rig/scripts/apply-exports.mjs \n"}

package/.rush/temp/operation/apply-exports/state.json

@@ -0,0 +1,3 @@
+{
+  "nonCachedDurationMs": 37.18405299999995
+}

package/.rush/temp/operation/build_package-metas/all.log

@@ -0,0 +1 @@
+Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs 

package/.rush/temp/operation/build_package-metas/log-chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs \n"}

package/.rush/temp/operation/build_package-metas/state.json

@@ -0,0 +1,3 @@
+{
+  "nonCachedDurationMs": 60.61758499999996
+}

package/.rush/temp/shrinkwrap-deps.json

@@ -0,0 +1,3 @@
+{
+  "../../packages/hash-object": "../../packages/hash-object:DpFAJ6l9NZ7PxsGv74etlzI4VS4IyRu5jGEhInb3gEw=:"
+}

package/config/rig.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/rig-package/rig.schema.json",
+  "rigPackageName": "@excom/heft-rig",
+  "rigProfile": "default"
+}
+

package/index.ts

@@ -0,0 +1,194 @@
+// e.g. hashObject({a: 1.1, b: "hello world", c: [{f: 2}], d: false, e: null}) => "31eh9pr0sbb82"
+export function hashObject(value: unknown): string {
+  // 64-bit FNV-1a
+  let h1 = 0xcbf29ce4,
+    h2 = 0x84222325; // offset basis (split hi/lo 32s)
+
+  const seen = new Map<any, number>();
+  let seenId = 0;
+
+  const u8 = (n: number) => {
+    // hash one byte
+    h2 ^= n & 0xff;
+    // multiply by FNV prime 0x100000001b3 (64-bit) using 32-bit pieces
+    const a = (h2 >>> 0) * 0x1b3;
+    const b = (h1 >>> 0) * 0x1b3 + a / 0x100000000;
+    h2 = a >>> 0;
+    h1 = b >>> 0;
+  };
+
+  const u32 = (n: number) => {
+    u8(n);
+    u8(n >>> 8);
+    u8(n >>> 16);
+    u8(n >>> 24);
+  };
+  const str = (s: string) => {
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      u8(c);
+      u8(c >>> 8);
+    }
+    u8(0);
+  };
+
+  const num = (x: number) => {
+    // canonicalize tricky numerics
+    if (Number.isNaN(x)) {
+      u8(0x4e);
+      return;
+    } // 'N'
+    if (x === 0) {
+      u8(0);
+      u8(1 / x < 0 ? 1 : 0);
+      return;
+    } // distinguish -0
+    if (!Number.isFinite(x)) {
+      u8(0x49);
+      u8(x < 0 ? 1 : 0);
+      return;
+    } // 'I'
+    // hash IEEE754 bytes
+    const f = new Float64Array(1);
+    f[0] = x;
+    const b = new Uint8Array(f.buffer);
+    for (let i = 0; i < 8; i++) u8(b[i]);
+  };
+
+  const tag = (t: number) => u8(t);
+
+  const walk = (v: any) => {
+    const t = typeof v;
+
+    if (v === null) {
+      tag(0);
+      return;
+    }
+    if (t === "undefined") {
+      tag(1);
+      return;
+    }
+    if (t === "boolean") {
+      tag(2);
+      u8(v ? 1 : 0);
+      return;
+    }
+    if (t === "number") {
+      tag(3);
+      num(v);
+      return;
+    }
+    if (t === "bigint") {
+      tag(4);
+      str(v.toString(10));
+      return;
+    }
+    if (t === "string") {
+      tag(5);
+      str(v);
+      return;
+    }
+    if (t === "symbol") {
+      tag(6);
+      str(String(v.description ?? ""));
+      return;
+    }
+    if (t === "function") {
+      tag(7);
+      str(v.name || "");
+      return;
+    } // intentionally shallow for fns
+
+    // objects
+    const prev = seen.get(v);
+    if (prev !== undefined) {
+      tag(8);
+      u32(prev);
+      return;
+    } // cycle ref
+    seen.set(v, ++seenId);
+
+    // special cases
+    if (v instanceof Date) {
+      tag(9);
+      num(v.getTime());
+      return;
+    }
+    if (v instanceof RegExp) {
+      tag(10);
+      str(v.source);
+      str(v.flags);
+      return;
+    }
+
+    if (ArrayBuffer.isView(v)) {
+      tag(11);
+      str(v.constructor?.name || "View");
+      const bytes = new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+      u32(bytes.length);
+      for (let i = 0; i < bytes.length; i++) u8(bytes[i]);
+      return;
+    }
+    if (v instanceof ArrayBuffer) {
+      tag(12);
+      const bytes = new Uint8Array(v);
+      u32(bytes.length);
+      for (let i = 0; i < bytes.length; i++) u8(bytes[i]);
+      return;
+    }
+
+    if (v instanceof Map) {
+      tag(13);
+      // stable: hash entries then sort by entry-hash
+      const entries: { k: any; val: any; hk: string }[] = [];
+      v.forEach((val, k) => {
+        const hk = hashObject([k, val]); // small reuse for ordering
+        entries.push({ k, val, hk });
+      });
+      entries.sort((a, b) => (a.hk < b.hk ? -1 : a.hk > b.hk ? 1 : 0));
+      u32(entries.length);
+      for (const e of entries) {
+        walk(e.k);
+        walk(e.val);
+      }
+      return;
+    }
+
+    if (v instanceof Set) {
+      tag(14);
+      const items: { v: any; hv: string }[] = [];
+      v.forEach((x) => items.push({ v: x, hv: hashObject(x) }));
+      items.sort((a, b) => (a.hv < b.hv ? -1 : a.hv > b.hv ? 1 : 0));
+      u32(items.length);
+      for (const it of items) walk(it.v);
+      return;
+    }
+
+    if (Array.isArray(v)) {
+      tag(15);
+      u32(v.length);
+      for (let i = 0; i < v.length; i++) walk(v[i]);
+      return;
+    }
+
+    // plain-ish object: stable key ordering
+    tag(16);
+    const proto = Object.getPrototypeOf(v);
+    str(proto && proto.constructor ? proto.constructor.name : "");
+    const keys = Object.keys(v).sort();
+    u32(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      str(k);
+      walk(v[k]);
+    }
+  };
+
+  walk(value);
+
+  // base36 from 64-bit (hi/lo)
+  const hi = h1 >>> 0,
+    lo = h2 >>> 0;
+  const asBig = (BigInt(hi) << 32n) | BigInt(lo);
+  return asBig.toString(36);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@excom/hash-object",
+  "version": "0.1.0",
+  "description": "hash-object library",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.13.0"
+  },
+  "type": "module",
+  "dependencies": {},
+  "peerDependencies": {},
+  "devDependencies": {
+    "@excom/heft-rig": "^0.1.0"
+  },
+  "repository": {
+    "url": "excom-dev/nucleus",
+    "directory": "packages/hash-object"
+  },
+  "homepage": "https://github.com/excom-dev/nucleus/tree/main/packages/hash-object/support/docs/README.md",
+  "bugs": "https://github.com/excom-dev/nucleus/issues",
+  "keywords": [
+    "hash-object"
+  ],
+  "excom": {
+    "packageType": "library"
+  },
+  "scripts": {
+    "build": "node node_modules/@excom/heft-rig/scripts/vite-build.mjs",
+    "build:watch": "node node_modules/@excom/heft-rig/scripts/vite-build-watch.mjs",
+    "format": "node node_modules/@excom/heft-rig/scripts/format.mjs",
+    "test": "node node_modules/@excom/heft-rig/scripts/vitest.mjs",
+    "coverage": "node node_modules/@excom/heft-rig/scripts/coverage.mjs",
+    "build:package-metas": "node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs"
+  }
+}

package/rush-logs/hash-object.apply-exports.cache.log

@@ -0,0 +1 @@
+Caching has been disabled for this project's "apply-exports" command.

package/rush-logs/hash-object.apply-exports.log

@@ -0,0 +1 @@
+Invoking: cd "$RUSH_PROJECT_FOLDER" && node ../heft-rig/scripts/apply-exports.mjs 

package/rush-logs/hash-object.build_package-metas.cache.log

@@ -0,0 +1 @@
+This project does not define the caching behavior of the "build:package-metas" command, so caching has been disabled.

package/rush-logs/hash-object.build_package-metas.log

@@ -0,0 +1 @@
+Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs 

package/support/package-meta.json

@@ -0,0 +1,29 @@
+{
+  "shortName": "hash-object",
+  "package": {
+    "name": "@excom/hash-object",
+    "version": "0.1.0",
+    "description": "hash-object library",
+    "peerDependencies": {},
+    "excom": {
+      "packageType": "library"
+    }
+  },
+  "demos": {},
+  "installation": {
+    "name": "@excom/hash-object",
+    "shortName": "hash-object",
+    "version": "0.1.0",
+    "description": "hash-object library",
+    "packageType": "library",
+    "install": {
+      "npm": "npm install @excom/hash-object"
+    },
+    "imports": {
+      "js": "import { /* … */ } from \"@excom/hash-object\";"
+    },
+    "peerDependencies": []
+  },
+  "elementApis": [],
+  "exportedFiles": {}
+}

package/support/tests/hash-object.test.ts

@@ -0,0 +1,204 @@
+import { hashObject } from "../../index";
+import { describe, expect, it } from "@excom/heft-rig/node_modules/vitest";
+
+describe("hashObject", () => {
+  it("returns deterministic hashes", () => {
+    const first = hashObject({ a: 1, b: "two" });
+    const second = hashObject({ a: 1, b: "two" });
+    const different = hashObject({ a: 2, b: "two" });
+    expect(first).toBe(second);
+    expect(first).not.toBe(different);
+  });
+
+  it("returns hashes for complex objects", () => {
+    const obj1 = { a: 1, b: "two", c: [{ d: 3 }, { e: 4 }] };
+    const hash1 = hashObject(obj1);
+    const obj2 = { a: 1, b: "two", c: [{ d: 3 }, { e: 4 }] };
+    const hash2 = hashObject(obj2);
+    expect(hash1).toBe(hash2);
+    expect(hash1).not.toBe(
+      hashObject({ a: 1, b: "two", c: [{ d: 3 }, { e: 5 }] }),
+    );
+  });
+
+  it("handles cycles without throwing", () => {
+    const obj: Record<string, unknown> = { a: 1 };
+    obj.self = obj;
+    const result = hashObject(obj);
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it("hashes primitive types distinctly", () => {
+    const results = new Set([
+      hashObject(null),
+      hashObject(undefined),
+      hashObject(true),
+      hashObject(false),
+      hashObject(0),
+      hashObject(1),
+      hashObject(""),
+      hashObject("a"),
+    ]);
+    expect(results.size).toBe(8);
+  });
+
+  it("distinguishes -0 from 0", () => {
+    expect(hashObject(-0)).not.toBe(hashObject(0));
+  });
+
+  it("handles NaN and Infinity", () => {
+    const nan = hashObject(NaN);
+    const posInf = hashObject(Infinity);
+    const negInf = hashObject(-Infinity);
+    expect(nan).not.toBe(posInf);
+    expect(posInf).not.toBe(negInf);
+    expect(hashObject(NaN)).toBe(nan);
+  });
+
+  it("hashes bigint values", () => {
+    const a = hashObject(1n);
+    const b = hashObject(2n);
+    expect(a).not.toBe(b);
+    expect(hashObject(1n)).toBe(a);
+  });
+
+  it("hashes symbols by description", () => {
+    const a = hashObject(Symbol("foo"));
+    const b = hashObject(Symbol("bar"));
+    const c = hashObject(Symbol("foo"));
+    expect(a).toBe(c);
+    expect(a).not.toBe(b);
+  });
+
+  it("hashes functions by name", () => {
+    function myFunc() {}
+    const hash = hashObject(myFunc);
+    expect(typeof hash).toBe("string");
+    expect(hash).toBe(hashObject(myFunc));
+  });
+
+  it("hashes Date objects by timestamp", () => {
+    const d1 = new Date(1700000000000);
+    const d2 = new Date(1700000000000);
+    const d3 = new Date(0);
+    expect(hashObject(d1)).toBe(hashObject(d2));
+    expect(hashObject(d1)).not.toBe(hashObject(d3));
+  });
+
+  it("hashes RegExp by source and flags", () => {
+    expect(hashObject(/abc/g)).toBe(hashObject(/abc/g));
+    expect(hashObject(/abc/g)).not.toBe(hashObject(/abc/i));
+    expect(hashObject(/abc/)).not.toBe(hashObject(/def/));
+  });
+
+  it("hashes Map in stable key order", () => {
+    const m1 = new Map([
+      ["a", 1],
+      ["b", 2],
+    ]);
+    const m2 = new Map([
+      ["b", 2],
+      ["a", 1],
+    ]);
+    expect(hashObject(m1)).toBe(hashObject(m2));
+  });
+
+  it("hashes Set in stable order", () => {
+    const s1 = new Set([1, 2, 3]);
+    const s2 = new Set([3, 1, 2]);
+    expect(hashObject(s1)).toBe(hashObject(s2));
+  });
+
+  it("hashes ArrayBuffer", () => {
+    const buf1 = new Uint8Array([1, 2, 3]).buffer;
+    const buf2 = new Uint8Array([1, 2, 3]).buffer;
+    const buf3 = new Uint8Array([4, 5, 6]).buffer;
+    expect(hashObject(buf1)).toBe(hashObject(buf2));
+    expect(hashObject(buf1)).not.toBe(hashObject(buf3));
+  });
+
+  it("hashes typed arrays", () => {
+    const a = new Uint8Array([10, 20]);
+    const b = new Uint8Array([10, 20]);
+    const c = new Float32Array([10, 20]);
+    expect(hashObject(a)).toBe(hashObject(b));
+    expect(hashObject(a)).not.toBe(hashObject(c));
+  });
+
+  it("produces stable hashes regardless of key order", () => {
+    const a = { z: 1, a: 2, m: 3 };
+    const b = { a: 2, m: 3, z: 1 };
+    expect(hashObject(a)).toBe(hashObject(b));
+  });
+
+  it("distinguishes arrays from objects", () => {
+    expect(hashObject([1, 2])).not.toBe(hashObject({ 0: 1, 1: 2 }));
+  });
+
+  it("distinguishes empty containers", () => {
+    const results = new Set([
+      hashObject([]),
+      hashObject({}),
+      hashObject(new Map()),
+      hashObject(new Set()),
+      hashObject(""),
+      hashObject(null),
+    ]);
+    expect(results.size).toBe(6);
+  });
+});
+
+describe("hashObject (fallback branches)", () => {
+  it("hashes a symbol without a description", () => {
+    const anonymous = hashObject(Symbol());
+    expect(anonymous).toBe(hashObject(Symbol()));
+    expect(anonymous).toBe(hashObject(Symbol("")));
+    expect(anonymous).not.toBe(hashObject(Symbol("named")));
+  });
+
+  it("hashes an anonymous function like an empty name", () => {
+    const anonymous = hashObject([() => {}][0]);
+    expect(anonymous).toBe(hashObject([function () {}][0]));
+    expect(anonymous).not.toBe(hashObject(function named() {}));
+  });
+
+  it("hashes a typed array whose constructor is unavailable", () => {
+    const view = new Uint8Array([1, 2, 3]);
+    Object.defineProperty(view, "constructor", { value: undefined });
+    const hash = hashObject(view);
+    expect(typeof hash).toBe("string");
+    expect(hash).not.toBe(hashObject(new Uint8Array([1, 2, 3])));
+    // same bytes, same missing constructor -> same hash
+    const twin = new Uint8Array([1, 2, 3]);
+    Object.defineProperty(twin, "constructor", { value: undefined });
+    expect(hash).toBe(hashObject(twin));
+  });
+
+  it("orders equal-hashing Map entries and Set items stably", () => {
+    const mapA = new Map<object, number>([
+      [{ k: 1 }, 1],
+      [{ k: 1 }, 1],
+    ]);
+    const mapB = new Map<object, number>([
+      [{ k: 1 }, 1],
+      [{ k: 1 }, 1],
+    ]);
+    expect(hashObject(mapA)).toBe(hashObject(mapB));
+    expect(hashObject(mapA)).not.toBe(hashObject(new Map([[{ k: 1 }, 1]])));
+
+    const setA = new Set([{ k: 1 }, { k: 1 }]);
+    const setB = new Set([{ k: 1 }, { k: 1 }]);
+    expect(hashObject(setA)).toBe(hashObject(setB));
+    expect(hashObject(setA)).not.toBe(hashObject(new Set([{ k: 1 }])));
+  });
+
+  it("hashes null-prototype objects with an empty constructor name", () => {
+    const bare = Object.assign(Object.create(null), { a: 1 });
+    const plain = { a: 1 };
+    expect(hashObject(bare)).toBe(
+      hashObject(Object.assign(Object.create(null), { a: 1 })),
+    );
+    expect(hashObject(bare)).not.toBe(hashObject(plain));
+  });
+});

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@excom/heft-rig/profiles/default/config/tsconfig.json",
+  "include": ["./*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}