@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
133 lines • 14.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Hashing = exports.DefaultHashingMethod = void 0;
exports.hashCode = hashCode;
exports.hashObj = hashObj;
/**
* @summary Mimics Java's String's Hash implementation
*
* @param {string | number | symbol | Date} obj
* @return {number} hash value of obj
*
* @function hashCode
* @memberOf module:decorator-validation
* @category Model
*/
function hashCode(obj) {
obj = String(obj);
let hash = 0;
for (let i = 0; i < obj.length; i++) {
const character = obj.charCodeAt(i);
hash = (hash << 5) - hash + character;
hash = hash & hash; // Convert to 32bit integer
}
return hash.toString();
}
/**
* @summary Hashes an object by combining the hash of all its properties
*
* @param {Record<string, any>} obj
* @return {string} the resulting hash
*
* @function hashObj
* @memberOf module:decorator-validation
* @category Model
*/
function hashObj(obj) {
const hashReducer = function (h, el) {
const elHash = hashFunction(el);
if (typeof elHash === "string")
return hashFunction((h || "") + hashFunction(el));
h = h || 0;
h = (h << 5) - h + elHash;
return h & h;
};
const func = hashCode;
const hashFunction = function (value) {
if (typeof value === "undefined")
return "";
if (["string", "number", "symbol"].indexOf(typeof value) !== -1)
return func(value.toString());
if (value instanceof Date)
return func(value.getTime());
if (Array.isArray(value))
return value.reduce(hashReducer, undefined);
return Object.values(value).reduce(hashReducer, undefined);
};
const result = Object.values(obj).reduce(hashReducer, 0);
return (typeof result === "number" ? Math.abs(result) : result).toString();
}
exports.DefaultHashingMethod = "default";
/**
* @description Manages hashing methods and provides a unified hashing interface
* @summary A utility class that provides a registry for different hashing functions and methods to hash objects.
* The class maintains a cache of registered hashing functions and allows setting a default hashing method.
* It prevents direct instantiation and provides static methods for registration and hashing.
*
* @class Hashing
* @category Model
*
* @example
* ```typescript
* // Register a custom hashing function
* Hashing.register('md5', (obj) => createMD5Hash(obj), true);
*
* // Hash an object using default method
* const hash1 = Hashing.hash(myObject);
*
* // Hash using specific method
* const hash2 = Hashing.hash(myObject, 'md5');
* ```
*/
class Hashing {
/**
* @description Current default hashing method identifier
* @private
*/
static { this.current = exports.DefaultHashingMethod; }
/**
* @description Cache of registered hashing functions
* @private
*/
static { this.cache = {
default: hashObj,
}; }
constructor() { }
/**
* @description Retrieves a registered hashing function
* @summary Fetches a hashing function from the cache by its key. Throws an error if the method is not registered.
*
* @param {string} key - The identifier of the hashing function to retrieve
* @return {HashingFunction} The requested hashing function
* @private
*/
static get(key) {
if (key in this.cache)
return this.cache[key];
throw new Error(`No hashing method registered under ${key}`);
}
/**
* @description Registers a new hashing function
* @summary Adds a new hashing function to the registry. Optionally sets it as the default method.
* Throws an error if a method with the same key is already registered.
*
* @param {string} key - The identifier for the hashing function
*/
static register(key, func, setDefault = false) {
if (key in this.cache)
throw new Error(`Hashing method ${key} already registered`);
this.cache[key] = func;
if (setDefault)
this.current = key;
}
static hash(obj, method, ...args) {
if (!method)
return this.get(this.current)(obj, ...args);
return this.get(method)(obj, ...args);
}
static setDefault(method) {
this.current = this.get(method);
}
}
exports.Hashing = Hashing;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hashing.js","sourceRoot":"","sources":["../../src/utils/hashing.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @summary Mimics Java's String's Hash implementation\n *\n * @param {string | number | symbol | Date} obj\n * @return {number} hash value of obj\n *\n * @function hashCode\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function hashCode(obj: string | number | symbol | Date): string {\n  obj = String(obj);\n  let hash = 0;\n  for (let i = 0; i < obj.length; i++) {\n    const character = obj.charCodeAt(i);\n    hash = (hash << 5) - hash + character;\n    hash = hash & hash; // Convert to 32bit integer\n  }\n  return hash.toString();\n}\n\n/**\n * @summary Defines teh type for a Hashing function\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type HashingFunction = (value: any, ...args: any[]) => string;\n\n/**\n * @summary Hashes an object by combining the hash of all its properties\n *\n * @param {Record<string, any>} obj\n * @return {string} the resulting hash\n *\n * @function hashObj\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function hashObj(obj: Record<string, any> | any[]): string {\n  const hashReducer = function (h: number | string, el: any): string | number {\n    const elHash = hashFunction(el);\n\n    if (typeof elHash === \"string\")\n      return hashFunction(((h as string) || \"\") + hashFunction(el));\n\n    h = h || 0;\n    h = ((h as number) << 5) - (h as number) + elHash;\n    return h & h;\n  };\n\n  const func: HashingFunction = hashCode;\n\n  const hashFunction = function (value: any): string | number {\n    if (typeof value === \"undefined\") return \"\";\n    if ([\"string\", \"number\", \"symbol\"].indexOf(typeof value) !== -1)\n      return func(value.toString());\n    if (value instanceof Date) return func(value.getTime());\n    if (Array.isArray(value)) return value.reduce(hashReducer, undefined);\n    return (Object.values(value) as (string | number)[]).reduce(\n      hashReducer,\n      undefined as unknown as string | number\n    );\n  };\n\n  const result = Object.values(obj).reduce(hashReducer, 0);\n\n  return (typeof result === \"number\" ? Math.abs(result) : result).toString();\n}\n\nexport const DefaultHashingMethod = \"default\";\n\n/**\n * @description Manages hashing methods and provides a unified hashing interface\n * @summary A utility class that provides a registry for different hashing functions and methods to hash objects.\n * The class maintains a cache of registered hashing functions and allows setting a default hashing method.\n * It prevents direct instantiation and provides static methods for registration and hashing.\n *\n * @class Hashing\n * @category Model\n *\n * @example\n * ```typescript\n * // Register a custom hashing function\n * Hashing.register('md5', (obj) => createMD5Hash(obj), true);\n *\n * // Hash an object using default method\n * const hash1 = Hashing.hash(myObject);\n *\n * // Hash using specific method\n * const hash2 = Hashing.hash(myObject, 'md5');\n * ```\n */\nexport class Hashing {\n  /**\n   * @description Current default hashing method identifier\n   * @private\n   */\n  private static current: string = DefaultHashingMethod;\n\n  /**\n   * @description Cache of registered hashing functions\n   * @private\n   */\n  private static cache: Record<string, HashingFunction> = {\n    default: hashObj,\n  };\n\n  private constructor() {}\n\n  /**\n   * @description Retrieves a registered hashing function\n   * @summary Fetches a hashing function from the cache by its key. Throws an error if the method is not registered.\n   *\n   * @param {string} key - The identifier of the hashing function to retrieve\n   * @return {HashingFunction} The requested hashing function\n   * @private\n   */\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No hashing method registered under ${key}`);\n  }\n\n  /**\n   * @description Registers a new hashing function\n   * @summary Adds a new hashing function to the registry. Optionally sets it as the default method.\n   * Throws an error if a method with the same key is already registered.\n   *\n   * @param {string} key - The identifier for the hashing function\n   */\n  static register(\n    key: string,\n    func: HashingFunction,\n    setDefault = false\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Hashing method ${key} already registered`);\n    this.cache[key] = func;\n    if (setDefault) this.current = key;\n  }\n\n  static hash(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current)(obj, ...args);\n    return this.get(method)(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n"]}