@vnejs/helpers.hash-sha256 0.2.1

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const hashSha256: (value: unknown, maxLength?: number) => Promise<string>;

package/dist/index.js

@@ -0,0 +1,19 @@
+const canonicalize = (value) => {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    return Object.keys(value)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = canonicalize(value[key]);
+        return acc;
+    }, {});
+};
+const toHex = (buffer) => [...new Uint8Array(buffer)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+export const hashSha256 = async (value, maxLength) => {
+    const bytes = new TextEncoder().encode(JSON.stringify(canonicalize(value)));
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    const hex = toHex(digest);
+    return maxLength === undefined ? hex : hex.slice(0, maxLength);
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@vnejs/helpers.hash-sha256",
+  "version": "0.2.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "test": "npx @vnejs/monorepo test",
+    "build": "npx @vnejs/monorepo package",
+    "publish:major:plugin": "npm run publish:major",
+    "publish:minor:plugin": "npm run publish:minor",
+    "publish:patch:plugin": "npm run publish:patch",
+    "publish:major": "npx @vnejs/monorepo publish major --access public",
+    "publish:minor": "npx @vnejs/monorepo publish minor --access public",
+    "publish:patch": "npx @vnejs/monorepo publish patch --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@vnejs/configs.ts-common": "~0.2.0",
+    "@vnejs/configs.vitest": "~0.2.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+const canonicalize = (value: unknown): unknown => {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(canonicalize);
+
+  return Object.keys(value as Record<string, unknown>)
+    .sort()
+    .reduce<Record<string, unknown>>((acc, key) => {
+      acc[key] = canonicalize((value as Record<string, unknown>)[key]);
+      return acc;
+    }, {});
+};
+
+const toHex = (buffer: ArrayBuffer) =>
+  [...new Uint8Array(buffer)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+export const hashSha256 = async (value: unknown, maxLength?: number) => {
+  const bytes = new TextEncoder().encode(JSON.stringify(canonicalize(value)));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  const hex = toHex(digest);
+
+  return maxLength === undefined ? hex : hex.slice(0, maxLength);
+};

package/src/tests/hash-sha256.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+
+import { hashSha256 } from "../index.js";
+
+describe("hashSha256", () => {
+  it("returns the same hash for objects with different key order", async () => {
+    const left = await hashSha256({ a: 1, b: 2 });
+    const right = await hashSha256({ b: 2, a: 1 });
+
+    expect(left).toBe(right);
+    expect(left).toHaveLength(64);
+  });
+
+  it("returns a different hash for different values", async () => {
+    await expect(hashSha256({ a: 1 })).resolves.not.toBe(await hashSha256({ a: 2 }));
+  });
+
+  it("truncates hash to maxLength", async () => {
+    const hash = await hashSha256({ a: 1 }, 8);
+
+    expect(hash).toHaveLength(8);
+    expect(await hashSha256({ a: 1 })).toMatch(new RegExp(`^${hash}`));
+  });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "@vnejs/configs.ts-common/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "dist",
+    "node_modules",
+    "src/tests"
+  ]
+}