mcard-js 1.0.0

package/dist/core/g_time.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.GTime = void 0;
+var _config_constants = require("../config/config_constants.js");
+class GTime {
+  /**
+   * Get current timestamp in ISO format with hash function and region code
+   * @param {string|HashAlgorithm} hashFunction - Hash function to use
+   * @returns {string} Formatted timestamp string
+   */
+  static stampNow(hashFunction) {
+    // Use default hash algorithm if no function is provided
+    if (hashFunction === null || hashFunction === undefined) {
+      hashFunction = _config_constants.HashAlgorithm.DEFAULT;
+    }
+
+    // Convert string to HashAlgorithm if needed
+    let normalizedHashFunction = hashFunction;
+    if (typeof hashFunction === 'string') {
+      const trimmedFunc = hashFunction.toLowerCase().trim();
+      if (!Object.values(_config_constants.HashAlgorithm).filter(func => typeof func === 'string').map(func => func.toLowerCase()).includes(trimmedFunc)) {
+        throw new Error(`Invalid hash function: ${hashFunction}`);
+      }
+      try {
+        normalizedHashFunction = _config_constants.HashAlgorithm[trimmedFunc.toUpperCase()];
+      } catch (error) {
+        throw new Error(`Invalid hash function: ${hashFunction}`);
+      }
+    }
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+
+    // Ensure 6 decimal places for microseconds
+    const microseconds = String(Math.floor(performance.now() % 1 * 1000000)).padStart(6, '0').slice(0, 6);
+    const timestamp = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${microseconds}Z`;
+    const regionCode = Intl.DateTimeFormat().resolvedOptions().timeZone.split('/')[0].toUpperCase();
+    return `${normalizedHashFunction}|${timestamp}|${regionCode}`;
+  }
+
+  /**
+   * Alias for stampNow to maintain backwards compatibility
+   * @param {string|HashAlgorithm} hashFunction - Hash function to use
+   * @returns {string} Formatted timestamp string
+   */
+  static stamp_now(hashFunction) {
+    return this.stampNow(hashFunction);
+  }
+
+  /**
+   * Get the hash function from the formatted string
+   * @param {string} stringValue - Formatted timestamp string
+   * @returns {string} Hash function
+   */
+  static get_hash_function(stringValue) {
+    // Validate input is a non-empty string
+    if (!stringValue || typeof stringValue !== 'string' || stringValue.trim() === '') {
+      throw new Error('Invalid hash function: Empty or non-string input');
+    }
+
+    // Validate exact number of parts
+    const parts = stringValue.split('|');
+    if (parts.length !== 3) {
+      throw new Error('Invalid hash function: Incorrect number of components');
+    }
+
+    // Validate each part is non-empty and has no extra whitespace
+    const [hashFunctionStr, timestamp, regionCode] = parts;
+    if (!hashFunctionStr || !timestamp || !regionCode) {
+      throw new Error('Invalid hash function: Missing components');
+    }
+
+    // Validate hash function format (must be exactly lowercase, no extra whitespace)
+    const trimmedHashFunc = hashFunctionStr.trim();
+    const validLowercaseHashes = Object.values(_config_constants.HashAlgorithm).filter(func => typeof func === 'string').map(func => func.toLowerCase());
+    if (!validLowercaseHashes.includes(trimmedHashFunc) || trimmedHashFunc !== hashFunctionStr) {
+      throw new Error(`Invalid hash function: ${hashFunctionStr}`);
+    }
+
+    // Validate timestamp format (strict ISO 8601 with exactly 6 decimal places)
+    const timestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/;
+    const trimmedTimestamp = timestamp.trim();
+    if (!timestampRegex.test(trimmedTimestamp) || trimmedTimestamp !== timestamp) {
+      throw new Error('Invalid hash function: Incorrect timestamp format');
+    }
+
+    // Validate region code format (must be all uppercase letters, no extra whitespace)
+    const trimmedRegionCode = regionCode.trim();
+    if (!/^[A-Z]+$/.test(trimmedRegionCode) || trimmedRegionCode !== regionCode) {
+      throw new Error('Invalid hash function: Incorrect region code format');
+    }
+    try {
+      return _config_constants.HashAlgorithm[trimmedHashFunc.toUpperCase()];
+    } catch (error) {
+      throw new Error(`Invalid hash function: ${trimmedHashFunc}`);
+    }
+  }
+
+  /**
+   * Get the timestamp from the formatted string
+   * @param {string} stringValue - Formatted timestamp string
+   * @returns {string} Timestamp in ISO format
+   */
+  static get_timestamp(stringValue) {
+    return stringValue.split('|')[1];
+  }
+
+  /**
+   * Get the region code from the formatted string
+   * @param {string} stringValue - Formatted timestamp string
+   * @returns {string} Region code
+   */
+  static get_region_code(stringValue) {
+    return stringValue.split('|')[2];
+  }
+
+  /**
+   * Check if the provided hash function is valid
+   * @param {string|HashAlgorithm} hashFunction - Hash function to validate
+   * @returns {boolean} Whether the hash function is valid
+   */
+  static is_valid_hash_function(hashFunction) {
+    // Strict validation for null or undefined
+    if (hashFunction === null || hashFunction === undefined) {
+      return false;
+    }
+
+    // Reject any non-string, non-object inputs
+    if (typeof hashFunction !== 'string' && typeof hashFunction !== 'object' && typeof hashFunction !== 'boolean') {
+      return false;
+    }
+
+    // Reject non-string objects
+    if (typeof hashFunction === 'object' && !(hashFunction instanceof String)) {
+      return false;
+    }
+
+    // Reject empty strings or whitespace
+    if (typeof hashFunction === 'string' && (hashFunction.trim() === '' || hashFunction !== hashFunction.trim())) {
+      return false;
+    }
+
+    // For string inputs, be extremely strict
+    if (typeof hashFunction === 'string' || hashFunction instanceof String) {
+      // Convert to string 
+      const strFunc = String(hashFunction);
+
+      // All valid hash functions, lowercase
+      const validLowercaseHashes = Object.values(_config_constants.HashAlgorithm).filter(func => typeof func === 'string').map(func => func.toLowerCase());
+
+      // Reject any input that doesn't match exactly
+      const isValid = validLowercaseHashes.includes(strFunc) && strFunc === strFunc.toLowerCase() && strFunc.trim() === strFunc;
+
+      // Extra checks to reject inputs like 'md 5', 'md5 hash', 'SHA-256', 'MD5', etc.
+      if (!isValid || strFunc.includes(' ')) {
+        return false;
+      }
+      return true;
+    }
+
+    // If we reach here, it means the input is a valid HashAlgorithm value
+    return Object.values(_config_constants.HashAlgorithm).includes(hashFunction);
+  }
+
+  /**
+   * Check if the provided region code is valid
+   * @param {string} regionCode - Region code to validate
+   * @returns {boolean} Whether the region code is valid
+   */
+  static is_valid_region_code(regionCode) {
+    if (regionCode === null || regionCode === undefined) {
+      return false;
+    }
+    return typeof regionCode === 'string' && regionCode.trim().length > 0 && regionCode.trim() === regionCode.trim().toUpperCase() && regionCode.trim() === regionCode; // No extra whitespace
+  }
+
+  /**
+   * Check if the provided timestamp is in ISO format
+   * @param {string} timestamp - Timestamp to validate
+   * @returns {boolean} Whether the timestamp is in ISO format
+   */
+  /**
+   * Validate ISO 8601 format with 6 decimal places
+   * @param {string} timestamp
+   * @returns {boolean}
+   */
+  static is_iso_format(timestamp) {
+    const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/;
+    return isoRegex.test(timestamp);
+  }
+}
+exports.GTime = GTime;
+var _default = exports.default = GTime;
+//# sourceMappingURL=g_time.js.map

package/dist/core/g_time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"g_time.js","names":["_config_constants","require","GTime","stampNow","hashFunction","undefined","HashAlgorithm","DEFAULT","normalizedHashFunction","trimmedFunc","toLowerCase","trim","Object","values","filter","func","map","includes","Error","toUpperCase","error","now","Date","year","getFullYear","month","String","getMonth","padStart","day","getDate","hours","getHours","minutes","getMinutes","seconds","getSeconds","microseconds","Math","floor","performance","slice","timestamp","regionCode","Intl","DateTimeFormat","resolvedOptions","timeZone","split","stamp_now","get_hash_function","stringValue","parts","length","hashFunctionStr","trimmedHashFunc","validLowercaseHashes","timestampRegex","trimmedTimestamp","test","trimmedRegionCode","get_timestamp","get_region_code","is_valid_hash_function","strFunc","isValid","is_valid_region_code","is_iso_format","isoRegex","exports","_default","default"],"sources":["../../src/core/g_time.js"],"sourcesContent":["import { HashAlgorithm } from '../config/config_constants.js';\n\nexport class GTime {\n  /**\n   * Get current timestamp in ISO format with hash function and region code\n   * @param {string|HashAlgorithm} hashFunction - Hash function to use\n   * @returns {string} Formatted timestamp string\n   */\n  static stampNow(hashFunction) {\n    // Use default hash algorithm if no function is provided\n    if (hashFunction === null || hashFunction === undefined) {\n      hashFunction = HashAlgorithm.DEFAULT;\n    }\n\n    // Convert string to HashAlgorithm if needed\n    let normalizedHashFunction = hashFunction;\n    if (typeof hashFunction === 'string') {\n      const trimmedFunc = hashFunction.toLowerCase().trim();\n      if (!Object.values(HashAlgorithm).filter(func => typeof func === 'string').map(func => func.toLowerCase()).includes(trimmedFunc)) {\n        throw new Error(`Invalid hash function: ${hashFunction}`);\n      }\n      try {\n        normalizedHashFunction = HashAlgorithm[trimmedFunc.toUpperCase()];\n      } catch (error) {\n        throw new Error(`Invalid hash function: ${hashFunction}`);\n      }\n    }\n\n    const now = new Date();\n    const year = now.getFullYear();\n    const month = String(now.getMonth() + 1).padStart(2, '0');\n    const day = String(now.getDate()).padStart(2, '0');\n    const hours = String(now.getHours()).padStart(2, '0');\n    const minutes = String(now.getMinutes()).padStart(2, '0');\n    const seconds = String(now.getSeconds()).padStart(2, '0');\n    \n    // Ensure 6 decimal places for microseconds\n    const microseconds = String(Math.floor(performance.now() % 1 * 1000000)).padStart(6, '0').slice(0, 6);\n\n    const timestamp = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${microseconds}Z`;\n    const regionCode = Intl.DateTimeFormat().resolvedOptions().timeZone.split('/')[0].toUpperCase();\n\n    return `${normalizedHashFunction}|${timestamp}|${regionCode}`;\n  }\n\n  /**\n   * Alias for stampNow to maintain backwards compatibility\n   * @param {string|HashAlgorithm} hashFunction - Hash function to use\n   * @returns {string} Formatted timestamp string\n   */\n  static stamp_now(hashFunction) {\n    return this.stampNow(hashFunction);\n  }\n\n  /**\n   * Get the hash function from the formatted string\n   * @param {string} stringValue - Formatted timestamp string\n   * @returns {string} Hash function\n   */\n  static get_hash_function(stringValue) {\n    // Validate input is a non-empty string\n    if (!stringValue || typeof stringValue !== 'string' || stringValue.trim() === '') {\n      throw new Error('Invalid hash function: Empty or non-string input');\n    }\n\n    // Validate exact number of parts\n    const parts = stringValue.split('|');\n    if (parts.length !== 3) {\n      throw new Error('Invalid hash function: Incorrect number of components');\n    }\n\n    // Validate each part is non-empty and has no extra whitespace\n    const [hashFunctionStr, timestamp, regionCode] = parts;\n    if (!hashFunctionStr || !timestamp || !regionCode) {\n      throw new Error('Invalid hash function: Missing components');\n    }\n\n    // Validate hash function format (must be exactly lowercase, no extra whitespace)\n    const trimmedHashFunc = hashFunctionStr.trim();\n    const validLowercaseHashes = Object.values(HashAlgorithm).filter(func => typeof func === 'string').map(func => func.toLowerCase());\n    \n    if (!validLowercaseHashes.includes(trimmedHashFunc) || \n        trimmedHashFunc !== hashFunctionStr) {\n      throw new Error(`Invalid hash function: ${hashFunctionStr}`);\n    }\n\n    // Validate timestamp format (strict ISO 8601 with exactly 6 decimal places)\n    const timestampRegex = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{6}Z$/;\n    const trimmedTimestamp = timestamp.trim();\n    \n    if (!timestampRegex.test(trimmedTimestamp) || \n        trimmedTimestamp !== timestamp) {\n      throw new Error('Invalid hash function: Incorrect timestamp format');\n    }\n\n    // Validate region code format (must be all uppercase letters, no extra whitespace)\n    const trimmedRegionCode = regionCode.trim();\n    if (!/^[A-Z]+$/.test(trimmedRegionCode) || \n        trimmedRegionCode !== regionCode) {\n      throw new Error('Invalid hash function: Incorrect region code format');\n    }\n\n    try {\n      return HashAlgorithm[trimmedHashFunc.toUpperCase()];\n    } catch (error) {\n      throw new Error(`Invalid hash function: ${trimmedHashFunc}`);\n    }\n  }\n\n  /**\n   * Get the timestamp from the formatted string\n   * @param {string} stringValue - Formatted timestamp string\n   * @returns {string} Timestamp in ISO format\n   */\n  static get_timestamp(stringValue) {\n    return stringValue.split('|')[1];\n  }\n\n  /**\n   * Get the region code from the formatted string\n   * @param {string} stringValue - Formatted timestamp string\n   * @returns {string} Region code\n   */\n  static get_region_code(stringValue) {\n    return stringValue.split('|')[2];\n  }\n\n  /**\n   * Check if the provided hash function is valid\n   * @param {string|HashAlgorithm} hashFunction - Hash function to validate\n   * @returns {boolean} Whether the hash function is valid\n   */\n  static is_valid_hash_function(hashFunction) {\n    // Strict validation for null or undefined\n    if (hashFunction === null || hashFunction === undefined) {\n      return false;\n    }\n\n    // Reject any non-string, non-object inputs\n    if (typeof hashFunction !== 'string' && \n        typeof hashFunction !== 'object' && \n        typeof hashFunction !== 'boolean') {\n      return false;\n    }\n\n    // Reject non-string objects\n    if (typeof hashFunction === 'object' && \n        !(hashFunction instanceof String)) {\n      return false;\n    }\n\n    // Reject empty strings or whitespace\n    if (typeof hashFunction === 'string' && \n        (hashFunction.trim() === '' || hashFunction !== hashFunction.trim())) {\n      return false;\n    }\n\n    // For string inputs, be extremely strict\n    if (typeof hashFunction === 'string' || hashFunction instanceof String) {\n      // Convert to string \n      const strFunc = String(hashFunction);\n      \n      // All valid hash functions, lowercase\n      const validLowercaseHashes = Object.values(HashAlgorithm).filter(func => typeof func === 'string').map(func => func.toLowerCase());\n      \n      // Reject any input that doesn't match exactly\n      const isValid = validLowercaseHashes.includes(strFunc) && \n                      strFunc === strFunc.toLowerCase() && \n                      strFunc.trim() === strFunc;\n\n      // Extra checks to reject inputs like 'md 5', 'md5 hash', 'SHA-256', 'MD5', etc.\n      if (!isValid || strFunc.includes(' ')) {\n        return false;\n      }\n\n      return true;\n    }\n    \n    // If we reach here, it means the input is a valid HashAlgorithm value\n    return Object.values(HashAlgorithm).includes(hashFunction);\n  }\n\n  /**\n   * Check if the provided region code is valid\n   * @param {string} regionCode - Region code to validate\n   * @returns {boolean} Whether the region code is valid\n   */\n  static is_valid_region_code(regionCode) {\n    if (regionCode === null || regionCode === undefined) {\n      return false;\n    }\n\n    return typeof regionCode === 'string' && \n           regionCode.trim().length > 0 && \n           regionCode.trim() === regionCode.trim().toUpperCase() &&\n           regionCode.trim() === regionCode; // No extra whitespace\n  }\n\n  /**\n   * Check if the provided timestamp is in ISO format\n   * @param {string} timestamp - Timestamp to validate\n   * @returns {boolean} Whether the timestamp is in ISO format\n   */\n  /**\n   * Validate ISO 8601 format with 6 decimal places\n   * @param {string} timestamp\n   * @returns {boolean}\n   */\n  static is_iso_format(timestamp) {\n    const isoRegex = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{6}Z$/;\n    return isoRegex.test(timestamp);\n  }\n}\n\nexport default GTime;\n"],"mappings":"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","ignoreList":[]}

package/dist/core/hash/enums.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.HashAlgorithm = void 0;
+// Hash algorithm enums
+const HashAlgorithm = exports.HashAlgorithm = {
+  MD5: 'md5',
+  SHA1: 'sha1',
+  SHA224: 'sha224',
+  SHA256: 'sha256',
+  SHA384: 'sha384',
+  SHA512: 'sha512'
+};
+var _default = exports.default = {
+  HashAlgorithm
+};
+//# sourceMappingURL=enums.js.map

package/dist/core/hash/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","names":["HashAlgorithm","exports","MD5","SHA1","SHA224","SHA256","SHA384","SHA512","_default","default"],"sources":["../../../src/core/hash/enums.js"],"sourcesContent":["// Hash algorithm enums\nexport const HashAlgorithm = {\n  MD5: 'md5',\n  SHA1: 'sha1',\n  SHA224: 'sha224',\n  SHA256: 'sha256',\n  SHA384: 'sha384',\n  SHA512: 'sha512'\n};\n\nexport default {\n  HashAlgorithm\n};\n"],"mappings":";;;;;;AAAA;AACO,MAAMA,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAG;EAC3BE,GAAG,EAAE,KAAK;EACVC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE,QAAQ;EAChBC,MAAM,EAAE,QAAQ;EAChBC,MAAM,EAAE,QAAQ;EAChBC,MAAM,EAAE;AACV,CAAC;AAAC,IAAAC,QAAA,GAAAP,OAAA,CAAAQ,OAAA,GAEa;EACbT;AACF,CAAC","ignoreList":[]}

package/dist/core/hash/validator.js

@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "HASH_ALGORITHM_HIERARCHY", {
+  enumerable: true,
+  get: function () {
+    return _config_constants.HASH_ALGORITHM_HIERARCHY;
+  }
+});
+Object.defineProperty(exports, "HashAlgorithm", {
+  enumerable: true,
+  get: function () {
+    return _config_constants.HashAlgorithm;
+  }
+});
+Object.defineProperty(exports, "VALID_HASH_FUNCTIONS", {
+  enumerable: true,
+  get: function () {
+    return _config_constants.VALID_HASH_FUNCTIONS;
+  }
+});
+exports.default = void 0;
+var _textEncoderPolyfill = require("../../utils/textEncoderPolyfill.js");
+var _bufferPolyfill = require("../../utils/bufferPolyfill.js");
+var _cryptoPolyfill = require("../../utils/cryptoPolyfill.js");
+var _config_constants = require("../../config/config_constants.js");
+// Replace direct crypto import with environment-aware implementation
+
+// Check if we're in a browser environment
+const isBrowser = typeof window !== 'undefined';
+class HashValidator {
+  /**
+   * Constructor for HashValidator
+   */
+  constructor(content, hashAlgorithm = _config_constants.HashAlgorithm.DEFAULT) {
+    // Convert content to Buffer/Uint8Array if it's a string
+    this.content = _bufferPolyfill.SafeBuffer.isBuffer(content) ? content : (0, _textEncoderPolyfill.encodeText)(content);
+    this.hashAlgorithm = this.normalizeHashAlgorithm(hashAlgorithm);
+
+    // In browser environments, we can't synchronously compute crypto hashes
+    if (isBrowser) {
+      this.hashValue = "computing...";
+      this._computeHashAsync().then(hash => {
+        this.hashValue = hash;
+      });
+    } else {
+      this.hashValue = this.computeHash();
+    }
+  }
+
+  /**
+   * Async computation of hash for browser environments
+   * @private
+   */
+  async _computeHashAsync() {
+    const hash = (0, _cryptoPolyfill.createHash)(this.hashAlgorithm);
+    hash.update(this.content);
+    return await hash.digest('hex');
+  }
+
+  /**
+   * Normalizes the hash algorithm input
+   * @param {string|Object} hashAlgorithm - The hash algorithm to normalize
+   * @returns {string} Normalized hash algorithm
+   */
+  normalizeHashAlgorithm(hashAlgorithm) {
+    // Handle undefined or null input
+    if (hashAlgorithm === undefined || hashAlgorithm === null) {
+      return _config_constants.HashAlgorithm.DEFAULT || 'sha256';
+    }
+
+    // If input is an object, try to extract the type
+    if (typeof hashAlgorithm === 'object') {
+      hashAlgorithm = hashAlgorithm.type || hashAlgorithm.value || _config_constants.HashAlgorithm.DEFAULT || 'sha256';
+    }
+
+    // Convert to lowercase string and remove dashes for consistency
+    const normalizedAlgo = String(hashAlgorithm).toLowerCase().replace(/-/g, '');
+
+    // Validate the hash algorithm
+    if (!HashValidator.isValidHashFunction(normalizedAlgo)) {
+      console.warn(`Invalid hash algorithm: ${normalizedAlgo}, using default instead`);
+      return _config_constants.HashAlgorithm.DEFAULT || 'sha256';
+    }
+    return normalizedAlgo;
+  }
+
+  /**
+   * Validates a hash function
+   * @param {string} hashFunction - Hash function to validate
+   * @returns {boolean} Whether the hash function is valid
+   */
+  static isValidHashFunction(hashFunction) {
+    if (!hashFunction) return false;
+    const normalizedFunc = String(hashFunction).toLowerCase().trim();
+
+    // Accept both formats: with dashes (Web Crypto format) and without dashes (Node.js format)
+    const validAlgorithms = [
+    // Node.js format
+    'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512',
+    // Web Crypto format
+    'sha-1', 'sha-256', 'sha-384', 'sha-512'];
+    return validAlgorithms.includes(normalizedFunc) || validAlgorithms.includes(normalizedFunc.replace(/-/g, ''));
+  }
+
+  /**
+   * Compute hash from content
+   * @returns {string|Promise<string>} Computed hash or promise to hash
+   */
+  computeHash() {
+    try {
+      const hash = (0, _cryptoPolyfill.createHash)(this.hashAlgorithm);
+      hash.update(this.content);
+      const result = hash.digest('hex');
+
+      // Handle the case where result is a Promise
+      if (result instanceof Promise) {
+        return "computing...";
+      }
+      return result;
+    } catch (e) {
+      console.error('Error computing hash:', e);
+      return '';
+    }
+  }
+
+  /**
+   * Getter for hash value
+   * @returns {string} Hash value
+   */
+  getHashValue() {
+    return this.hashValue;
+  }
+
+  /**
+   * Getter for hash algorithm
+   * @returns {string} Hash algorithm
+   */
+  getHashAlgorithm() {
+    return this.hashAlgorithm;
+  }
+
+  /**
+   * Static method to compute hash
+   * @param {string|Buffer} content - Content to hash
+   * @param {string} hashAlgorithm - Algorithm to use
+   * @returns {string|Promise<string>} Computed hash or Promise of hash in browser
+   */
+  static computeHash(content, hashAlgorithm = _config_constants.HashAlgorithm.DEFAULT) {
+    const buffer = _bufferPolyfill.SafeBuffer.isBuffer(content) ? content : (0, _textEncoderPolyfill.encodeText)(content);
+    const hash = (0, _cryptoPolyfill.createHash)(hashAlgorithm);
+    hash.update(buffer);
+    return hash.digest('hex');
+  }
+
+  /**
+   * Validate hash against an expected hash
+   * @param {string} [expectedHash] - Expected hash value
+   * @returns {boolean|Promise<boolean>} True if hash matches, false otherwise
+   */
+  validate(expectedHash) {
+    if (!expectedHash) return false;
+    if (isBrowser) {
+      // In browser, we need to handle async validation
+      return this._computeHashAsync().then(computedHash => {
+        return computedHash === expectedHash;
+      });
+    }
+    return this.hashValue === expectedHash;
+  }
+
+  /**
+   * Return string representation
+   * @returns {string} String representation
+   */
+  toString() {
+    return `HashValidator(alg=${this.hashAlgorithm}, hash=${this.hashValue})`;
+  }
+
+  /**
+   * Gets the strength order of hash algorithms
+   * @returns {string[]} Ordered list of hash algorithms by strength
+   */
+  getHashAlgorithmStrengthOrder() {
+    return [_config_constants.HashAlgorithm.MD5, _config_constants.HashAlgorithm.SHA1, _config_constants.HashAlgorithm.SHA224, _config_constants.HashAlgorithm.SHA256, _config_constants.HashAlgorithm.SHA384, _config_constants.HashAlgorithm.SHA512];
+  }
+
+  /**
+   * Gets the strength index of a hash algorithm
+   * @param {string} algorithm - Hash algorithm
+   * @returns {number} Strength index
+   */
+  getHashAlgorithmStrength(algorithm) {
+    return this.getHashAlgorithmStrengthOrder().indexOf(algorithm);
+  }
+
+  /**
+   * Checks if one hash algorithm is stronger than another
+   * @param {string} current - Current hash algorithm
+   * @param {string} upgrade - Potential upgrade hash algorithm
+   * @returns {boolean} Whether the upgrade is stronger
+   */
+  isStrongerHashAlgorithm(current, upgrade) {
+    return this.getHashAlgorithmStrength(upgrade) > this.getHashAlgorithmStrength(current);
+  }
+
+  /**
+   * Determines the next hash algorithm in the upgrade path
+   * @param {string|Object} currentHashFunction - Current hash function
+   * @returns {string} Next hash algorithm
+   */
+  nextHashFunction(currentHashFunction) {
+    const strengthOrder = this.getHashAlgorithmStrengthOrder();
+
+    // Handle undefined or null input
+    if (currentHashFunction === undefined || currentHashFunction === null) {
+      return _config_constants.HashAlgorithm.MD5;
+    }
+
+    // Extract hash function value if it's an object
+    const currentHash = typeof currentHashFunction === 'object' ? currentHashFunction.value || currentHashFunction.type : currentHashFunction;
+
+    // Normalize to lowercase
+    const normalizedHash = (currentHash || '').toLowerCase();
+
+    // Find current index
+    const currentIndex = strengthOrder.indexOf(normalizedHash);
+
+    // Special case for SHA512 - wrap around to SHA1
+    if (normalizedHash === _config_constants.HashAlgorithm.SHA512) {
+      return _config_constants.HashAlgorithm.SHA1;
+    }
+
+    // If not found or last in order, return default (first hash function)
+    if (currentIndex === -1 || currentIndex === strengthOrder.length - 1) {
+      return _config_constants.HashAlgorithm[strengthOrder[0].toUpperCase()];
+    }
+
+    // Return the next hash function in the order as an enum
+    return _config_constants.HashAlgorithm[strengthOrder[currentIndex + 1].toUpperCase()];
+  }
+
+  /**
+   * Static method to get supported hash algorithms
+   * @returns {string[]} List of supported hash algorithms
+   */
+  static getSupportedAlgorithms() {
+    return [_config_constants.HashAlgorithm.MD5, _config_constants.HashAlgorithm.SHA1, _config_constants.HashAlgorithm.SHA256, _config_constants.HashAlgorithm.SHA512];
+  }
+  static compute_hash(content, hashAlgorithm = _config_constants.HashAlgorithm.DEFAULT) {
+    return HashValidator.computeHash(content, hashAlgorithm);
+  }
+  static HashAlgorithm = _config_constants.HashAlgorithm;
+  static HASH_ALGORITHM_HIERARCHY = _config_constants.HASH_ALGORITHM_HIERARCHY;
+  static VALID_HASH_FUNCTIONS = _config_constants.VALID_HASH_FUNCTIONS;
+}
+exports.default = HashValidator;
+//# sourceMappingURL=validator.js.map

package/dist/core/hash/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","names":["_textEncoderPolyfill","require","_bufferPolyfill","_cryptoPolyfill","_config_constants","isBrowser","window","HashValidator","constructor","content","hashAlgorithm","HashAlgorithm","DEFAULT","SafeBuffer","isBuffer","encodeText","normalizeHashAlgorithm","hashValue","_computeHashAsync","then","hash","computeHash","createHash","update","digest","undefined","type","value","normalizedAlgo","String","toLowerCase","replace","isValidHashFunction","console","warn","hashFunction","normalizedFunc","trim","validAlgorithms","includes","result","Promise","e","error","getHashValue","getHashAlgorithm","buffer","validate","expectedHash","computedHash","toString","getHashAlgorithmStrengthOrder","MD5","SHA1","SHA224","SHA256","SHA384","SHA512","getHashAlgorithmStrength","algorithm","indexOf","isStrongerHashAlgorithm","current","upgrade","nextHashFunction","currentHashFunction","strengthOrder","currentHash","normalizedHash","currentIndex","length","toUpperCase","getSupportedAlgorithms","compute_hash","HASH_ALGORITHM_HIERARCHY","VALID_HASH_FUNCTIONS","exports","default"],"sources":["../../../src/core/hash/validator.js"],"sourcesContent":["// Replace direct crypto import with environment-aware implementation\nimport { encodeText } from '../../utils/textEncoderPolyfill.js';\nimport { SafeBuffer } from '../../utils/bufferPolyfill.js';\nimport { createHash } from '../../utils/cryptoPolyfill.js';\nimport { \n  HashAlgorithm, \n  HASH_ALGORITHM_HIERARCHY, \n  VALID_HASH_FUNCTIONS \n} from '../../config/config_constants.js';\n\n// Check if we're in a browser environment\nconst isBrowser = typeof window !== 'undefined';\n\nexport default class HashValidator {\n  /**\n   * Constructor for HashValidator\n   */\n  constructor(content, hashAlgorithm = HashAlgorithm.DEFAULT) {\n    // Convert content to Buffer/Uint8Array if it's a string\n    this.content = SafeBuffer.isBuffer(content) \n      ? content \n      : encodeText(content);\n    \n    this.hashAlgorithm = this.normalizeHashAlgorithm(hashAlgorithm);\n    \n    // In browser environments, we can't synchronously compute crypto hashes\n    if (isBrowser) {\n      this.hashValue = \"computing...\";\n      this._computeHashAsync().then(hash => {\n        this.hashValue = hash;\n      });\n    } else {\n      this.hashValue = this.computeHash();\n    }\n  }\n  \n  /**\n   * Async computation of hash for browser environments\n   * @private\n   */\n  async _computeHashAsync() {\n    const hash = createHash(this.hashAlgorithm);\n    hash.update(this.content);\n    return await hash.digest('hex');\n  }\n\n  /**\n   * Normalizes the hash algorithm input\n   * @param {string|Object} hashAlgorithm - The hash algorithm to normalize\n   * @returns {string} Normalized hash algorithm\n   */\n  normalizeHashAlgorithm(hashAlgorithm) {\n    // Handle undefined or null input\n    if (hashAlgorithm === undefined || hashAlgorithm === null) {\n      return HashAlgorithm.DEFAULT || 'sha256';\n    }\n    \n    // If input is an object, try to extract the type\n    if (typeof hashAlgorithm === 'object') {\n      hashAlgorithm = hashAlgorithm.type || hashAlgorithm.value || HashAlgorithm.DEFAULT || 'sha256';\n    }\n    \n    // Convert to lowercase string and remove dashes for consistency\n    const normalizedAlgo = String(hashAlgorithm).toLowerCase().replace(/-/g, '');\n    \n    // Validate the hash algorithm\n    if (!HashValidator.isValidHashFunction(normalizedAlgo)) {\n      console.warn(`Invalid hash algorithm: ${normalizedAlgo}, using default instead`);\n      return HashAlgorithm.DEFAULT || 'sha256';\n    }\n    \n    return normalizedAlgo;\n  }\n\n  /**\n   * Validates a hash function\n   * @param {string} hashFunction - Hash function to validate\n   * @returns {boolean} Whether the hash function is valid\n   */\n  static isValidHashFunction(hashFunction) {\n    if (!hashFunction) return false;\n    \n    const normalizedFunc = String(hashFunction).toLowerCase().trim();\n    \n    // Accept both formats: with dashes (Web Crypto format) and without dashes (Node.js format)\n    const validAlgorithms = [\n      // Node.js format\n      'md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512',\n      // Web Crypto format\n      'sha-1', 'sha-256', 'sha-384', 'sha-512'\n    ];\n    \n    return validAlgorithms.includes(normalizedFunc) || \n           validAlgorithms.includes(normalizedFunc.replace(/-/g, ''));\n  }\n\n  /**\n   * Compute hash from content\n   * @returns {string|Promise<string>} Computed hash or promise to hash\n   */\n  computeHash() {\n    try {\n      const hash = createHash(this.hashAlgorithm);\n      hash.update(this.content);\n      const result = hash.digest('hex');\n      \n      // Handle the case where result is a Promise\n      if (result instanceof Promise) {\n        return \"computing...\";\n      }\n      \n      return result;\n    } catch (e) {\n      console.error('Error computing hash:', e);\n      return '';\n    }\n  }\n\n  /**\n   * Getter for hash value\n   * @returns {string} Hash value\n   */\n  getHashValue() {\n    return this.hashValue;\n  }\n\n  /**\n   * Getter for hash algorithm\n   * @returns {string} Hash algorithm\n   */\n  getHashAlgorithm() {\n    return this.hashAlgorithm;\n  }\n\n  /**\n   * Static method to compute hash\n   * @param {string|Buffer} content - Content to hash\n   * @param {string} hashAlgorithm - Algorithm to use\n   * @returns {string|Promise<string>} Computed hash or Promise of hash in browser\n   */\n  static computeHash(content, hashAlgorithm = HashAlgorithm.DEFAULT) {\n    const buffer = SafeBuffer.isBuffer(content) \n      ? content \n      : encodeText(content);\n    \n    const hash = createHash(hashAlgorithm);\n    hash.update(buffer);\n    return hash.digest('hex');\n  }\n\n  /**\n   * Validate hash against an expected hash\n   * @param {string} [expectedHash] - Expected hash value\n   * @returns {boolean|Promise<boolean>} True if hash matches, false otherwise\n   */\n  validate(expectedHash) {\n    if (!expectedHash) return false;\n    \n    if (isBrowser) {\n      // In browser, we need to handle async validation\n      return this._computeHashAsync().then(computedHash => {\n        return computedHash === expectedHash;\n      });\n    }\n    \n    return this.hashValue === expectedHash;\n  }\n\n  /**\n   * Return string representation\n   * @returns {string} String representation\n   */\n  toString() {\n    return `HashValidator(alg=${this.hashAlgorithm}, hash=${this.hashValue})`;\n  }\n\n  /**\n   * Gets the strength order of hash algorithms\n   * @returns {string[]} Ordered list of hash algorithms by strength\n   */\n  getHashAlgorithmStrengthOrder() {\n    return [\n      HashAlgorithm.MD5,\n      HashAlgorithm.SHA1,\n      HashAlgorithm.SHA224,\n      HashAlgorithm.SHA256,\n      HashAlgorithm.SHA384,\n      HashAlgorithm.SHA512\n    ];\n  }\n\n  /**\n   * Gets the strength index of a hash algorithm\n   * @param {string} algorithm - Hash algorithm\n   * @returns {number} Strength index\n   */\n  getHashAlgorithmStrength(algorithm) {\n    return this.getHashAlgorithmStrengthOrder().indexOf(algorithm);\n  }\n\n  /**\n   * Checks if one hash algorithm is stronger than another\n   * @param {string} current - Current hash algorithm\n   * @param {string} upgrade - Potential upgrade hash algorithm\n   * @returns {boolean} Whether the upgrade is stronger\n   */\n  isStrongerHashAlgorithm(current, upgrade) {\n    return this.getHashAlgorithmStrength(upgrade) > this.getHashAlgorithmStrength(current);\n  }\n\n  /**\n   * Determines the next hash algorithm in the upgrade path\n   * @param {string|Object} currentHashFunction - Current hash function\n   * @returns {string} Next hash algorithm\n   */\n  nextHashFunction(currentHashFunction) {\n    const strengthOrder = this.getHashAlgorithmStrengthOrder();\n\n    // Handle undefined or null input\n    if (currentHashFunction === undefined || currentHashFunction === null) {\n      return HashAlgorithm.MD5;\n    }\n\n    // Extract hash function value if it's an object\n    const currentHash = typeof currentHashFunction === 'object' \n      ? currentHashFunction.value || currentHashFunction.type \n      : currentHashFunction;\n\n    // Normalize to lowercase\n    const normalizedHash = (currentHash || '').toLowerCase();\n\n    // Find current index\n    const currentIndex = strengthOrder.indexOf(normalizedHash);\n\n    // Special case for SHA512 - wrap around to SHA1\n    if (normalizedHash === HashAlgorithm.SHA512) {\n      return HashAlgorithm.SHA1;\n    }\n\n    // If not found or last in order, return default (first hash function)\n    if (currentIndex === -1 || currentIndex === strengthOrder.length - 1) {\n      return HashAlgorithm[strengthOrder[0].toUpperCase()];\n    }\n\n    // Return the next hash function in the order as an enum\n    return HashAlgorithm[strengthOrder[currentIndex + 1].toUpperCase()];\n  }\n\n  /**\n   * Static method to get supported hash algorithms\n   * @returns {string[]} List of supported hash algorithms\n   */\n  static getSupportedAlgorithms() {\n    return [\n      HashAlgorithm.MD5,\n      HashAlgorithm.SHA1,\n      HashAlgorithm.SHA256,\n      HashAlgorithm.SHA512\n    ];\n  }\n\n  static compute_hash(content, hashAlgorithm = HashAlgorithm.DEFAULT) {\n    return HashValidator.computeHash(content, hashAlgorithm);\n  }\n\n  static HashAlgorithm = HashAlgorithm;\n  static HASH_ALGORITHM_HIERARCHY = HASH_ALGORITHM_HIERARCHY;\n  static VALID_HASH_FUNCTIONS = VALID_HASH_FUNCTIONS;\n}\n\nexport { HashAlgorithm, HASH_ALGORITHM_HIERARCHY, VALID_HASH_FUNCTIONS };\n"],"mappings":"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","ignoreList":[]}