@naturalcycles/js-lib 14.149.3 → 14.150.0

package/dist/index.d.ts

@@ -78,6 +78,7 @@ export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';
+export * from './string/hash.util';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
 import { z, ZodSchema, ZodError, ZodIssue } from 'zod';

package/dist/index.js

@@ -82,6 +82,7 @@ tslib_1.__exportStar(require("./env"), exports);
 tslib_1.__exportStar(require("./http/http.model"), exports);
 tslib_1.__exportStar(require("./http/fetcher"), exports);
 tslib_1.__exportStar(require("./http/fetcher.model"), exports);
+tslib_1.__exportStar(require("./string/hash.util"), exports);
 tslib_1.__exportStar(require("./zod/zod.util"), exports);
 tslib_1.__exportStar(require("./zod/zod.shared.schemas"), exports);
 const zod_1 = require("zod");

package/dist/object/object.util.d.ts

@@ -44,7 +44,7 @@ export declare function _filterObject<T extends AnyObject>(obj: T, predicate: Ob
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.

package/dist/object/object.util.js

@@ -93,7 +93,7 @@ exports._filterObject = _filterObject;
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.

package/dist/string/hash.util.d.ts

@@ -0,0 +1,38 @@
+import { Integer } from '../types';
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+export declare function hashCode16(s: string): string;
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+export declare function hashCode36(s: string): string;
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+export declare function hashCode64(s: string): string;
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+export declare function hashCode(s: string): Integer;

package/dist/string/hash.util.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashCode = exports.hashCode64 = exports.hashCode36 = exports.hashCode16 = void 0;
+const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+// const BASE64 = BASE62 + '+/'
+const BASE64URL = BASE62 + '-_';
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+function hashCode16(s) {
+    return hashCode(s).toString(16);
+}
+exports.hashCode16 = hashCode16;
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+function hashCode36(s) {
+    return hashCode(s).toString(36);
+}
+exports.hashCode36 = hashCode36;
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+function hashCode64(s) {
+    return numberToBase(hashCode(s), BASE64URL);
+}
+exports.hashCode64 = hashCode64;
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+function hashCode(s) {
+    let hash = 0;
+    let i = 0;
+    const len = s.length;
+    while (i < len) {
+        // eslint-disable-next-line no-bitwise, unicorn/prefer-math-trunc, unicorn/prefer-code-point
+        hash = ((hash << 5) - hash + s.charCodeAt(i++)) << 0;
+    }
+    return hash + 2147483647 + 1;
+}
+exports.hashCode = hashCode;
+/**
+ * Source: https://gist.github.com/alkaruno/b84162bae5115f4ca99b
+ */
+function numberToBase(n, alphabet) {
+    const alen = alphabet.length;
+    let result = '';
+    do {
+        result = alphabet.charAt(n % alen) + result;
+        n = Math.floor(n / alen) - 1;
+    } while (n > -1);
+    return result;
+}

package/dist-esm/index.js

@@ -78,6 +78,7 @@ export * from './env';
 export * from './http/http.model';
 export * from './http/fetcher';
 export * from './http/fetcher.model';
+export * from './string/hash.util';
 export * from './zod/zod.util';
 export * from './zod/zod.shared.schemas';
 import { z, ZodSchema, ZodError } from 'zod';

package/dist-esm/object/object.util.js

@@ -82,7 +82,7 @@ export function _filterObject(obj, predicate, mutate = false) {
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.

package/dist-esm/string/hash.util.js

@@ -0,0 +1,67 @@
+const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+// const BASE64 = BASE62 + '+/'
+const BASE64URL = BASE62 + '-_';
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+export function hashCode16(s) {
+    return hashCode(s).toString(16);
+}
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+export function hashCode36(s) {
+    return hashCode(s).toString(36);
+}
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+export function hashCode64(s) {
+    return numberToBase(hashCode(s), BASE64URL);
+}
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+export function hashCode(s) {
+    let hash = 0;
+    let i = 0;
+    const len = s.length;
+    while (i < len) {
+        // eslint-disable-next-line no-bitwise, unicorn/prefer-math-trunc, unicorn/prefer-code-point
+        hash = ((hash << 5) - hash + s.charCodeAt(i++)) << 0;
+    }
+    return hash + 2147483647 + 1;
+}
+/**
+ * Source: https://gist.github.com/alkaruno/b84162bae5115f4ca99b
+ */
+function numberToBase(n, alphabet) {
+    const alen = alphabet.length;
+    let result = '';
+    do {
+        result = alphabet.charAt(n % alen) + result;
+        n = Math.floor(n / alen) - 1;
+    } while (n > -1);
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.149.3",
+  "version": "14.150.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -16,7 +16,9 @@
     "@naturalcycles/dev-lib": "^13.0.1",
     "@naturalcycles/nodejs-lib": "^12.33.4",
     "@naturalcycles/time-lib": "^3.5.1",
+    "@types/crypto-js": "^4.1.1",
     "@types/node": "^20.1.0",
+    "crypto-js": "^4.1.1",
     "jest": "^29.0.0",
     "prettier": "^2.1.2",
     "rxjs": "^7.0.1",

package/src/index.ts

@@ -78,6 +78,7 @@ export * from './env'
 export * from './http/http.model'
 export * from './http/fetcher'
 export * from './http/fetcher.model'
+export * from './string/hash.util'
 export * from './zod/zod.util'
 export * from './zod/zod.shared.schemas'
 import { z, ZodSchema, ZodError, ZodIssue } from 'zod'

package/src/object/object.util.ts

@@ -111,7 +111,7 @@ export function _filterObject<T extends AnyObject>(
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(o) { return o.age; });
+ * _.mapValues(users, function(_key, value) { return value.age; });
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
  * // The `_.property` iteratee shorthand.

package/src/string/hash.util.ts

@@ -0,0 +1,76 @@
+import { Integer } from '../types'
+
+const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+// const BASE64 = BASE62 + '+/'
+const BASE64URL = BASE62 + '-_'
+
+/**
+ * Returns hashCode as hex (radix 16).
+ *
+ * All hash functions here are optimized for:
+ *
+ * 1. Performance
+ * 2. For non-cryptographic use (where accidental collision is not the end-of-the-world)
+ * 3. Compact size (32 bits max, versus 128 in md5; presented in less string json-safe characters)
+ *
+ * Basically, these functions are as simple as they can be, but still "random enough" for
+ * normal non-cryptographic use cases.
+ *
+ * To be run on the ClientSide, as in Node there are plenty of other hash options in `node:crypto`.
+ *
+ * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
+ * hashCode64).
+ */
+export function hashCode16(s: string): string {
+  return hashCode(s).toString(16)
+}
+
+/**
+ * Returns hashCode as "radix 36", using "Base36 alphabet".
+ * 36 is used, because it's the maximum "radix" that Number.toString() can take.
+ *
+ * See the hashCode16 for full description.
+ */
+export function hashCode36(s: string): string {
+  return hashCode(s).toString(36)
+}
+
+/**
+ * Returns hashCode as "radix 64", using Base64url alphabet.
+ * See the hashCode16 for full description.
+ */
+export function hashCode64(s: string): string {
+  return numberToBase(hashCode(s), BASE64URL)
+}
+
+/**
+ * Generates a stable integer hashCode for a given String.
+ * Matches Java implementation (they say), except it ensures a positive Integer
+ * by adding 2147483647 + 1 to the end result.
+ * Source: https://stackoverflow.com/a/33647870/4919972
+ */
+export function hashCode(s: string): Integer {
+  let hash = 0
+  let i = 0
+  const len = s.length
+  while (i < len) {
+    // eslint-disable-next-line no-bitwise, unicorn/prefer-math-trunc, unicorn/prefer-code-point
+    hash = ((hash << 5) - hash + s.charCodeAt(i++)) << 0
+  }
+  return hash + 2147483647 + 1
+}
+
+/**
+ * Source: https://gist.github.com/alkaruno/b84162bae5115f4ca99b
+ */
+function numberToBase(n: number, alphabet: string): string {
+  const alen = alphabet.length
+  let result = ''
+
+  do {
+    result = alphabet.charAt(n % alen) + result
+    n = Math.floor(n / alen) - 1
+  } while (n > -1)
+
+  return result
+}