@fuzdev/fuz_util 0.48.2 → 0.48.3

package/dist/hash.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hash utilities for content comparison and cache invalidation.
+ *
+ * Provides both secure (cryptographic) and insecure (fast) hash functions.
+ *
+ * @module
+ */
+/**
+ * Computes a cryptographic hash using Web Crypto API.
+ *
+ * @param data - String or binary data to hash. Strings are UTF-8 encoded.
+ * @param algorithm - Hash algorithm. Defaults to SHA-256.
+ * @returns Hexadecimal hash string.
+ */
+export declare const hash_secure: (data: BufferSource | string, algorithm?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<string>;
+/**
+ * Computes a fast non-cryptographic hash using DJB2 algorithm.
+ * Use for content comparison and cache keys, not security.
+ *
+ * Note: Strings use UTF-16 code units, buffers use raw bytes.
+ * For non-ASCII, `hash_insecure(str) !== hash_insecure(encoder.encode(str))`.
+ *
+ * @param data - String or binary data to hash.
+ * @returns 8-character hex-encoded unsigned 32-bit hash.
+ */
+export declare const hash_insecure: (data: BufferSource | string) => string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/hash.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgBH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACvB,MAAM,YAAY,GAAG,MAAM,EAC3B,YAAW,SAAS,GAAG,SAAS,GAAG,SAAqB,KACtD,OAAO,CAAC,MAAM,CAUhB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,YAAY,GAAG,MAAM,KAAG,MAkB3D,CAAC"}

package/dist/hash.js

@@ -0,0 +1,66 @@
+/**
+ * Hash utilities for content comparison and cache invalidation.
+ *
+ * Provides both secure (cryptographic) and insecure (fast) hash functions.
+ *
+ * @module
+ */
+const encoder = new TextEncoder();
+// Lazily computed lookup table for byte to hex conversion
+let byte_to_hex;
+const get_byte_to_hex = () => {
+    if (byte_to_hex === undefined) {
+        byte_to_hex = new Array(256); // 256 possible byte values (0x00-0xff)
+        for (let i = 0; i < 256; i++) {
+            byte_to_hex[i] = i.toString(16).padStart(2, '0');
+        }
+    }
+    return byte_to_hex;
+};
+/**
+ * Computes a cryptographic hash using Web Crypto API.
+ *
+ * @param data - String or binary data to hash. Strings are UTF-8 encoded.
+ * @param algorithm - Hash algorithm. Defaults to SHA-256.
+ * @returns Hexadecimal hash string.
+ */
+export const hash_secure = async (data, algorithm = 'SHA-256') => {
+    const buffer = typeof data === 'string' ? encoder.encode(data) : data;
+    const digested = await crypto.subtle.digest(algorithm, buffer);
+    const bytes = new Uint8Array(digested);
+    const lookup = get_byte_to_hex();
+    let hex = '';
+    for (const byte of bytes) {
+        hex += lookup[byte];
+    }
+    return hex;
+};
+/**
+ * Computes a fast non-cryptographic hash using DJB2 algorithm.
+ * Use for content comparison and cache keys, not security.
+ *
+ * Note: Strings use UTF-16 code units, buffers use raw bytes.
+ * For non-ASCII, `hash_insecure(str) !== hash_insecure(encoder.encode(str))`.
+ *
+ * @param data - String or binary data to hash.
+ * @returns 8-character hex-encoded unsigned 32-bit hash.
+ */
+export const hash_insecure = (data) => {
+    let hash = 5381; // DJB2 initial value, chosen empirically for good distribution
+    if (typeof data === 'string') {
+        for (let i = 0; i < data.length; i++) {
+            hash = (hash << 5) - hash + data.charCodeAt(i);
+        }
+    }
+    else {
+        const bytes = data instanceof Uint8Array
+            ? data
+            : data instanceof ArrayBuffer
+                ? new Uint8Array(data)
+                : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        for (const byte of bytes) {
+            hash = (hash << 5) - hash + byte;
+        }
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_util",
-  "version": "0.48.2",
+  "version": "0.48.3",
   "description": "utility belt for JS",
   "glyph": "🦕",
   "logo": "logo.svg",
@@ -61,9 +61,9 @@
   },
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.1",
-    "@fuzdev/fuz_code": "^0.40.0",
-    "@fuzdev/fuz_css": "^0.44.1",
-    "@fuzdev/fuz_ui": "^0.179.0",
+    "@fuzdev/fuz_code": "^0.41.0",
+    "@fuzdev/fuz_css": "^0.45.0",
+    "@fuzdev/fuz_ui": "^0.180.0",
     "@ryanatkn/eslint-config": "^0.9.0",
     "@ryanatkn/gro": "^0.189.3",
     "@sveltejs/adapter-static": "^3.0.10",
@@ -79,8 +79,8 @@
     "fast-deep-equal": "^3.1.3",
     "prettier": "^3.7.4",
     "prettier-plugin-svelte": "^3.4.1",
-    "svelte": "^5.48.2",
-    "svelte-check": "^4.3.4",
+    "svelte": "^5.48.5",
+    "svelte-check": "^4.3.5",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",

package/src/lib/hash.ts

@@ -0,0 +1,73 @@
+/**
+ * Hash utilities for content comparison and cache invalidation.
+ *
+ * Provides both secure (cryptographic) and insecure (fast) hash functions.
+ *
+ * @module
+ */
+
+const encoder = new TextEncoder();
+
+// Lazily computed lookup table for byte to hex conversion
+let byte_to_hex: Array<string> | undefined;
+const get_byte_to_hex = (): Array<string> => {
+	if (byte_to_hex === undefined) {
+		byte_to_hex = new Array(256); // 256 possible byte values (0x00-0xff)
+		for (let i = 0; i < 256; i++) {
+			byte_to_hex[i] = i.toString(16).padStart(2, '0');
+		}
+	}
+	return byte_to_hex;
+};
+
+/**
+ * Computes a cryptographic hash using Web Crypto API.
+ *
+ * @param data - String or binary data to hash. Strings are UTF-8 encoded.
+ * @param algorithm - Hash algorithm. Defaults to SHA-256.
+ * @returns Hexadecimal hash string.
+ */
+export const hash_secure = async (
+	data: BufferSource | string,
+	algorithm: 'SHA-256' | 'SHA-384' | 'SHA-512' = 'SHA-256',
+): Promise<string> => {
+	const buffer = typeof data === 'string' ? encoder.encode(data) : data;
+	const digested = await crypto.subtle.digest(algorithm, buffer);
+	const bytes = new Uint8Array(digested);
+	const lookup = get_byte_to_hex();
+	let hex = '';
+	for (const byte of bytes) {
+		hex += lookup[byte];
+	}
+	return hex;
+};
+
+/**
+ * Computes a fast non-cryptographic hash using DJB2 algorithm.
+ * Use for content comparison and cache keys, not security.
+ *
+ * Note: Strings use UTF-16 code units, buffers use raw bytes.
+ * For non-ASCII, `hash_insecure(str) !== hash_insecure(encoder.encode(str))`.
+ *
+ * @param data - String or binary data to hash.
+ * @returns 8-character hex-encoded unsigned 32-bit hash.
+ */
+export const hash_insecure = (data: BufferSource | string): string => {
+	let hash = 5381; // DJB2 initial value, chosen empirically for good distribution
+	if (typeof data === 'string') {
+		for (let i = 0; i < data.length; i++) {
+			hash = (hash << 5) - hash + data.charCodeAt(i);
+		}
+	} else {
+		const bytes: Uint8Array =
+			data instanceof Uint8Array
+				? data
+				: data instanceof ArrayBuffer
+					? new Uint8Array(data)
+					: new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		for (const byte of bytes) {
+			hash = (hash << 5) - hash + byte;
+		}
+	}
+	return (hash >>> 0).toString(16).padStart(8, '0');
+};