cr-static-shared-components 9.9.0

package/src/crypto.js

@@ -0,0 +1,216 @@
+'use strict';
+
+/**
+ * Cryptography & Hashing Utilities Module
+ * Secure hashing, encoding, and basic cryptographic operations
+ *
+ * @module crypto
+ */
+
+const crypto = require('crypto');
+
+/**
+ * Hash data with specified algorithm
+ */
+function hash(data, algorithm = 'sha256', encoding = 'hex') {
+  return crypto
+    .createHash(algorithm)
+    .update(data)
+    .digest(encoding);
+}
+
+/**
+ * MD5 hash
+ */
+function md5(data) {
+  return hash(data, 'md5');
+}
+
+/**
+ * SHA1 hash
+ */
+function sha1(data) {
+  return hash(data, 'sha1');
+}
+
+/**
+ * SHA256 hash
+ */
+function sha256(data) {
+  return hash(data, 'sha256');
+}
+
+/**
+ * SHA512 hash
+ */
+function sha512(data) {
+  return hash(data, 'sha512');
+}
+
+/**
+ * HMAC with specified algorithm
+ */
+function hmac(data, secret, algorithm = 'sha256', encoding = 'hex') {
+  return crypto
+    .createHmac(algorithm, secret)
+    .update(data)
+    .digest(encoding);
+}
+
+/**
+ * Generate random bytes
+ */
+function randomBytes(size = 16, encoding = 'hex') {
+  return crypto.randomBytes(size).toString(encoding);
+}
+
+/**
+ * Generate UUID v4
+ */
+function uuid() {
+  return randomBytes(16, 'hex').replace(
+    /^(.{8})(.{4})(.{4})(.{4})(.{12})$/,
+    '$1-$2-$3-$4-$5'
+  );
+}
+
+/**
+ * Generate random string
+ */
+function randomString(length = 32, charset = 'alphanumeric') {
+  const charsets = {
+    alphanumeric: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+    alpha: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+    numeric: '0123456789',
+    hex: '0123456789abcdef'
+  };
+
+  const chars = charsets[charset] || charsets.alphanumeric;
+  let result = '';
+
+  for (let i = 0; i < length; i++) {
+    const randomIndex = crypto.randomInt(0, chars.length);
+    result += chars[randomIndex];
+  }
+
+  return result;
+}
+
+/**
+ * Encrypt data with AES-256-CBC
+ */
+function encrypt(data, key) {
+  const iv = crypto.randomBytes(16);
+  const keyBuffer = crypto.scryptSync(key, 'salt', 32);
+  const cipher = crypto.createCipheriv('aes-256-cbc', keyBuffer, iv);
+
+  let encrypted = cipher.update(data, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  return `${iv.toString('hex')}:${encrypted}`;
+}
+
+/**
+ * Decrypt data with AES-256-CBC
+ */
+function decrypt(encrypted, key) {
+  const [ivHex, encryptedData] = encrypted.split(':');
+  const iv = Buffer.from(ivHex, 'hex');
+  const keyBuffer = crypto.scryptSync(key, 'salt', 32);
+  const decipher = crypto.createDecipheriv('aes-256-cbc', keyBuffer, iv);
+
+  let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+
+  return decrypted;
+}
+
+/**
+ * Base64 encode
+ */
+function base64Encode(data) {
+  return Buffer.from(data).toString('base64');
+}
+
+/**
+ * Base64 decode
+ */
+function base64Decode(data) {
+  return Buffer.from(data, 'base64').toString('utf8');
+}
+
+/**
+ * URL-safe Base64 encode
+ */
+function base64URLEncode(data) {
+  return base64Encode(data)
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+}
+
+/**
+ * URL-safe Base64 decode
+ */
+function base64URLDecode(data) {
+  let padded = data.replace(/-/g, '+').replace(/_/g, '/');
+  while (padded.length % 4) {
+    padded += '=';
+  }
+  return base64Decode(padded);
+}
+
+/**
+ * Constant-time string comparison
+ */
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+
+/**
+ * Hash password with bcrypt-like algorithm (PBKDF2)
+ */
+function hashPassword(password, salt = null, iterations = 100000) {
+  const saltBuffer = salt ? Buffer.from(salt, 'hex') : crypto.randomBytes(16);
+  const hash = crypto.pbkdf2Sync(password, saltBuffer, iterations, 64, 'sha512');
+
+  return `${saltBuffer.toString('hex')}:${hash.toString('hex')}`;
+}
+
+/**
+ * Verify password hash
+ */
+function verifyPassword(password, hashedPassword) {
+  const [salt, hash] = hashedPassword.split(':');
+  const verifyHash = crypto.pbkdf2Sync(password, Buffer.from(salt, 'hex'), 100000, 64, 'sha512');
+
+  return timingSafeEqual(hash, verifyHash.toString('hex'));
+}
+
+module.exports = {
+  hash,
+  md5,
+  sha1,
+  sha256,
+  sha512,
+  hmac,
+  randomBytes,
+  uuid,
+  randomString,
+  encrypt,
+  decrypt,
+  base64Encode,
+  base64Decode,
+  base64URLEncode,
+  base64URLDecode,
+  timingSafeEqual,
+  hashPassword,
+  verifyPassword
+};

package/src/errors.js

@@ -0,0 +1,79 @@
+'use strict';
+
+/**
+ * Error Handling Module
+ * Provides structured error types and handling utilities
+ *
+ * @module errors
+ */
+
+/**
+ * Validation Error
+ */
+class ValidationError extends Error {
+  constructor(message, errors = []) {
+    super(message);
+    this.name = 'ValidationError';
+    this.errors = errors;
+    Error.captureStackTrace(this, ValidationError);
+  }
+}
+
+/**
+ * Format Error
+ */
+class FormatError extends Error {
+  constructor(message, value) {
+    super(message);
+    this.name = 'FormatError';
+    this.value = value;
+    Error.captureStackTrace(this, FormatError);
+  }
+}
+
+/**
+ * Transform Error
+ */
+class TransformError extends Error {
+  constructor(message, input) {
+    super(message);
+    this.name = 'TransformError';
+    this.input = input;
+    Error.captureStackTrace(this, TransformError);
+  }
+}
+
+/**
+ * Error handler
+ */
+function handle(error) {
+  const response = {
+    code: error.name || 'Error',
+    message: error.message
+  };
+
+  if (error instanceof ValidationError) {
+    response.errors = error.errors;
+  }
+
+  if (error instanceof FormatError) {
+    response.value = error.value;
+  }
+
+  if (error instanceof TransformError) {
+    response.input = error.input;
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    response.stack = error.stack;
+  }
+
+  return response;
+}
+
+module.exports = {
+  ValidationError,
+  FormatError,
+  TransformError,
+  handle
+};

package/src/formatting.js

@@ -0,0 +1,299 @@
+'use strict';
+
+/**
+ * Formatting Module
+ * Provides utilities for formatting dates, numbers, currency, and other data types
+ *
+ * @module formatting
+ */
+
+/**
+ * Date formatting with timezone support
+ */
+function date(input, pattern = 'YYYY-MM-DD', timezone = null) {
+  const d = input instanceof Date ? input : new Date(input);
+
+  if (isNaN(d.getTime())) {
+    throw new Error('Invalid date input');
+  }
+
+  // Timezone offset adjustment
+  let workingDate = new Date(d);
+  if (timezone) {
+    // Simple timezone offset (real implementation would use Intl.DateTimeFormat)
+    const offset = getTimezoneOffset(timezone);
+    workingDate = new Date(d.getTime() + offset * 60000);
+  }
+
+  const tokens = {
+    'YYYY': workingDate.getFullYear(),
+    'YY': String(workingDate.getFullYear()).slice(-2),
+    'MM': String(workingDate.getMonth() + 1).padStart(2, '0'),
+    'M': workingDate.getMonth() + 1,
+    'DD': String(workingDate.getDate()).padStart(2, '0'),
+    'D': workingDate.getDate(),
+    'HH': String(workingDate.getHours()).padStart(2, '0'),
+    'H': workingDate.getHours(),
+    'hh': String(workingDate.getHours() % 12 || 12).padStart(2, '0'),
+    'h': workingDate.getHours() % 12 || 12,
+    'mm': String(workingDate.getMinutes()).padStart(2, '0'),
+    'm': workingDate.getMinutes(),
+    'ss': String(workingDate.getSeconds()).padStart(2, '0'),
+    's': workingDate.getSeconds(),
+    'SSS': String(workingDate.getMilliseconds()).padStart(3, '0'),
+    'A': workingDate.getHours() >= 12 ? 'PM' : 'AM',
+    'a': workingDate.getHours() >= 12 ? 'pm' : 'am'
+  };
+
+  let formatted = pattern;
+  for (const [token, value] of Object.entries(tokens)) {
+    formatted = formatted.replace(new RegExp(token, 'g'), String(value));
+  }
+
+  return formatted;
+}
+
+/**
+ * Get timezone offset (simplified)
+ */
+function getTimezoneOffset(timezone) {
+  // Simplified mapping - real implementation would use proper timezone database
+  const offsets = {
+    'UTC': 0,
+    'America/New_York': -300,
+    'America/Chicago': -360,
+    'America/Denver': -420,
+    'America/Los_Angeles': -480,
+    'Europe/London': 0,
+    'Europe/Paris': 60,
+    'Asia/Tokyo': 540,
+    'Australia/Sydney': 660
+  };
+
+  return offsets[timezone] || 0;
+}
+
+/**
+ * Currency formatting
+ */
+function currency(amount, currencyCode = 'USD', locale = 'en-US') {
+  if (typeof amount !== 'number' || isNaN(amount)) {
+    throw new Error('Invalid amount');
+  }
+
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency: currencyCode
+    }).format(amount);
+  } catch (e) {
+    // Fallback
+    const symbols = {
+      'USD': '$',
+      'EUR': '€',
+      'GBP': '£',
+      'JPY': '¥',
+      'CNY': '¥'
+    };
+
+    const symbol = symbols[currencyCode] || currencyCode;
+    return `${symbol}${amount.toFixed(2)}`;
+  }
+}
+
+/**
+ * Number formatting
+ */
+function number(value, options = {}) {
+  if (typeof value !== 'number' || isNaN(value)) {
+    throw new Error('Invalid number');
+  }
+
+  const defaults = {
+    precision: 2,
+    grouping: true,
+    percentage: false
+  };
+
+  const opts = { ...defaults, ...options };
+
+  let formatted = value;
+
+  if (opts.percentage) {
+    formatted = value * 100;
+  }
+
+  if (opts.precision !== null) {
+    formatted = formatted.toFixed(opts.precision);
+  }
+
+  if (opts.grouping) {
+    const parts = String(formatted).split('.');
+    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    formatted = parts.join('.');
+  }
+
+  if (opts.percentage) {
+    formatted += '%';
+  }
+
+  return formatted;
+}
+
+/**
+ * Bytes formatting
+ */
+function bytes(bytesValue, decimals = 2) {
+  if (typeof bytesValue !== 'number' || bytesValue < 0) {
+    throw new Error('Invalid bytes value');
+  }
+
+  if (bytesValue === 0) return '0 Bytes';
+
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+  const i = Math.floor(Math.log(bytesValue) / Math.log(k));
+
+  return parseFloat((bytesValue / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+
+/**
+ * Percentage formatting
+ */
+function percentage(value, decimals = 2) {
+  if (typeof value !== 'number' || isNaN(value)) {
+    throw new Error('Invalid percentage value');
+  }
+
+  return (value * 100).toFixed(decimals) + '%';
+}
+
+/**
+ * Ordinal number formatting (1st, 2nd, 3rd, etc.)
+ */
+function ordinal(value) {
+  if (typeof value !== 'number' || !Number.isInteger(value)) {
+    throw new Error('Invalid ordinal value');
+  }
+
+  const suffixes = ['th', 'st', 'nd', 'rd'];
+  const v = value % 100;
+
+  return value + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
+}
+
+/**
+ * Duration formatting (milliseconds to human-readable)
+ */
+function duration(ms) {
+  if (typeof ms !== 'number' || ms < 0) {
+    throw new Error('Invalid duration');
+  }
+
+  const units = {
+    day: 86400000,
+    hour: 3600000,
+    minute: 60000,
+    second: 1000,
+    millisecond: 1
+  };
+
+  const parts = [];
+  let remaining = ms;
+
+  for (const [unit, value] of Object.entries(units)) {
+    const count = Math.floor(remaining / value);
+    if (count > 0) {
+      parts.push(`${count} ${unit}${count > 1 ? 's' : ''}`);
+      remaining %= value;
+    }
+  }
+
+  return parts.length > 0 ? parts.join(', ') : '0 milliseconds';
+}
+
+/**
+ * Pluralize words
+ */
+function pluralize(count, singular, plural = null) {
+  if (typeof count !== 'number') {
+    throw new Error('Invalid count');
+  }
+
+  const word = count === 1 ? singular : (plural || singular + 's');
+  return `${count} ${word}`;
+}
+
+/**
+ * Titlecase formatting
+ */
+function titleCase(str) {
+  if (typeof str !== 'string') {
+    throw new Error('Invalid string');
+  }
+
+  const smallWords = ['a', 'an', 'and', 'as', 'at', 'but', 'by', 'for', 'if', 'in', 'of', 'on', 'or', 'the', 'to', 'via'];
+
+  return str.toLowerCase().split(' ').map((word, index) => {
+    if (index === 0 || !smallWords.includes(word)) {
+      return word.charAt(0).toUpperCase() + word.slice(1);
+    }
+    return word;
+  }).join(' ');
+}
+
+/**
+ * Truncate string with ellipsis
+ */
+function truncate(str, maxLength, suffix = '...') {
+  if (typeof str !== 'string') {
+    throw new Error('Invalid string');
+  }
+
+  if (str.length <= maxLength) {
+    return str;
+  }
+
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+
+/**
+ * Pad string
+ */
+function pad(str, length, char = ' ', direction = 'right') {
+  if (typeof str !== 'string') {
+    str = String(str);
+  }
+
+  if (str.length >= length) {
+    return str;
+  }
+
+  const padding = char.repeat(length - str.length);
+
+  if (direction === 'left') {
+    return padding + str;
+  } else if (direction === 'center') {
+    const leftPad = Math.floor(padding.length / 2);
+    const rightPad = padding.length - leftPad;
+    return char.repeat(leftPad) + str + char.repeat(rightPad);
+  }
+
+  return str + padding;
+}
+
+module.exports = {
+  date,
+  currency,
+  number,
+  bytes,
+  percentage,
+  ordinal,
+  duration,
+  pluralize,
+  titleCase,
+  truncate,
+  pad
+};