@gzl10/ts-helpers 4.2.1

package/dist/browser/validators.js

@@ -0,0 +1,98 @@
+import "./chunk-NSBPE2FW.js";
+
+// src/validators.ts
+function isValidFilePath(filePath) {
+  if (!filePath || typeof filePath !== "string") return false;
+  if (typeof filePath === "object") return false;
+  if (filePath.length === 0 || filePath.length > 1e3) return false;
+  if (filePath.includes("../") || filePath.includes("..\\")) return false;
+  const suspiciousPatterns = ["//", "\\\\", "//\\", "\\//", "/./", "\\.\\"];
+  if (suspiciousPatterns.some((pattern) => filePath.includes(pattern))) return false;
+  const encodedPatterns = [
+    "%2e%2e%2f",
+    // ../
+    "%2e%2e/",
+    // ../
+    "%2e%2e%5c",
+    // ..\
+    "%252e"
+    // double-encoded
+  ];
+  if (encodedPatterns.some((pattern) => filePath.toLowerCase().includes(pattern))) return false;
+  if (filePath.includes("\0")) return false;
+  const commandChars = [";", "&", "|", "`", "$", "(", ")", "{", "}"];
+  if (commandChars.some((char) => filePath.includes(char))) return false;
+  const sqlPatterns = ["'", '"', "--", "/*", "*/", "DROP", "DELETE", "UNION", "SELECT"];
+  const lowerPath = filePath.toLowerCase();
+  if (sqlPatterns.some(
+    (pattern) => lowerPath.includes(pattern.toLowerCase()) && (pattern === "'" || pattern === '"' || lowerPath.includes(` ${pattern.toLowerCase()}`))
+  ))
+    return false;
+  const dangerousUnicode = [
+    "\u202E",
+    // Right-to-left override
+    "\u200B",
+    // Zero-width space
+    "\u200C",
+    // Zero-width non-joiner
+    "\u200D",
+    // Zero-width joiner
+    "\uFEFF"
+    // Zero-width no-break space
+  ];
+  if (dangerousUnicode.some((char) => filePath.includes(char))) return false;
+  if (/^[A-Za-z]:\\.*\\\.\./.test(filePath)) return false;
+  return true;
+}
+function isValidFileSize(size, maxSize) {
+  return typeof size === "number" && size >= 0 && size <= maxSize;
+}
+function isValidTextContent(content, options = {}) {
+  const { maxLength = 1e6 } = options;
+  if (typeof content !== "string") return false;
+  if (content.length > maxLength) return false;
+  const lowerContent = content.toLowerCase();
+  const scriptPatterns = ["<script", "<\/script", "<scr<script>ipt", "<scr\0ipt"];
+  if (scriptPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  const eventHandlers = [
+    "onerror",
+    "onload",
+    "onclick",
+    "onmouseover",
+    "onfocus",
+    "onblur",
+    "oninput"
+  ];
+  if (eventHandlers.some((handler) => lowerContent.includes(handler))) return false;
+  const protocolPatterns = [
+    "javascript:",
+    "data:text/html",
+    "data:text/javascript",
+    "data:application",
+    "vbscript:",
+    "file:///",
+    "steam://",
+    "slack://"
+  ];
+  if (protocolPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  const encodedPatterns = [
+    "&#60;script",
+    // &#60; = <
+    "%3cscript",
+    // %3c = <
+    "\\x3cscript",
+    // \x3c = <
+    "\\u003cscript"
+    // \u003c = <
+  ];
+  if (encodedPatterns.some((pattern) => lowerContent.includes(pattern))) return false;
+  if (lowerContent.includes("<svg") && lowerContent.includes("onload")) return false;
+  if (lowerContent.includes("<iframe")) return false;
+  return true;
+}
+export {
+  isValidFilePath,
+  isValidFileSize,
+  isValidTextContent
+};
+//# sourceMappingURL=validators.js.map

package/dist/browser/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/validators.ts"],"sourcesContent":["/**\n * File and security validators\n *\n * This module provides validation functions for file operations and content security.\n * Functions implement basic security checks to prevent common attack vectors:\n * - Path traversal attacks (../, ..\\)\n * - XSS injection (script tags, javascript: URLs)\n * - File size limits\n *\n * ⚠️ WARNING: These are basic validations. For production systems, consider:\n * - Additional OS-specific path validation\n * - Symbolic link resolution checking\n * - Comprehensive XSS prevention libraries (e.g., DOMPurify)\n * - Content-Type validation\n * - Virus scanning for uploaded files\n */\n\n/**\n * Validates file path for security vulnerabilities\n *\n * Protects against common path traversal attacks by checking for:\n * - Parent directory references (../, ..\\)\n * - Mixed path separators (//\\, \\\\)\n * - Excessive path length (>1000 chars)\n * - Empty or null paths\n *\n * ⚠️ SECURITY NOTE: This is basic validation. For production use, consider:\n * - Validating against an allowed directory whitelist\n * - Resolving symbolic links\n * - OS-specific path rules (Windows vs Unix)\n * - Canonicalization before validation\n *\n * @param filePath - File path string to validate\n * @returns True if path appears safe, false if potentially dangerous\n *\n * @example\n * ```typescript\n * // Safe paths - Allowed\n * isValidFilePath('./data/users.json')        // true\n * isValidFilePath('data/users.json')          // true\n * isValidFilePath('/absolute/path/file.txt')  // true\n * isValidFilePath('C:\\\\Users\\\\data\\\\file.txt') // true\n *\n * // Dangerous paths - Path traversal attacks\n * isValidFilePath('../../../etc/passwd')      // false\n * isValidFilePath('data/../../../etc/passwd') // false\n * isValidFilePath('..\\\\..\\\\..\\\\windows\\\\system32\\\\config') // false\n * isValidFilePath('data//\\\\..//config')       // false\n *\n * // Invalid paths - Malformed\n * isValidFilePath('')                         // false\n * isValidFilePath(null as any)                // false\n * isValidFilePath(undefined as any)           // false\n * isValidFilePath('x'.repeat(1001))          // false (too long)\n *\n * // Real-world usage in file operations\n * async function readUserFile(userPath: string) {\n *   if (!isValidFilePath(userPath)) {\n *     throw new Error('Invalid or unsafe file path detected')\n *   }\n *\n *   // Additional check: ensure path is within allowed directory\n *   const allowedDir = '/var/app/uploads'\n *   const fullPath = path.join(allowedDir, userPath)\n *\n *   return fs.readFile(fullPath, 'utf-8')\n * }\n * ```\n *\n * @see {@link isValidTextContent} for content security validation\n * @see {@link isValidFileSize} for file size validation\n */\nexport function isValidFilePath(filePath: string): boolean {\n  // ✅ Type and null checks\n  if (!filePath || typeof filePath !== 'string') return false\n\n  // ✅ Handle type coercion attempts\n  if (typeof filePath === 'object') return false\n\n  // ✅ Length limits (DoS prevention)\n  if (filePath.length === 0 || filePath.length > 1000) return false\n\n  // ✅ Path traversal patterns (Unix and Windows)\n  // Reject parent directory traversal (..)\n  if (filePath.includes('../') || filePath.includes('..\\\\')) return false\n\n  // Reject mixed/double slashes (but allow ./ and .\\ at start for relative paths)\n  const suspiciousPatterns = ['//', '\\\\\\\\', '//\\\\', '\\\\//', '/./', '\\\\.\\\\']\n  if (suspiciousPatterns.some(pattern => filePath.includes(pattern))) return false\n\n  // ✅ URL-encoded path traversal\n  const encodedPatterns = [\n    '%2e%2e%2f', // ../\n    '%2e%2e/', // ../\n    '%2e%2e%5c', // ..\\\n    '%252e', // double-encoded\n  ]\n  if (encodedPatterns.some(pattern => filePath.toLowerCase().includes(pattern))) return false\n\n  // ✅ Null byte injection\n  if (filePath.includes('\\x00')) return false\n\n  // ✅ Command injection characters\n  const commandChars = [';', '&', '|', '`', '$', '(', ')', '{', '}']\n  if (commandChars.some(char => filePath.includes(char))) return false\n\n  // ✅ SQL injection attempts\n  const sqlPatterns = [\"'\", '\"', '--', '/*', '*/', 'DROP', 'DELETE', 'UNION', 'SELECT']\n  const lowerPath = filePath.toLowerCase()\n  if (\n    sqlPatterns.some(\n      pattern =>\n        lowerPath.includes(pattern.toLowerCase()) &&\n        (pattern === \"'\" || pattern === '\"' || lowerPath.includes(` ${pattern.toLowerCase()}`))\n    )\n  )\n    return false\n\n  // ✅ Unicode attacks (RTL override, zero-width)\n  const dangerousUnicode = [\n    '\\u202E', // Right-to-left override\n    '\\u200B', // Zero-width space\n    '\\u200C', // Zero-width non-joiner\n    '\\u200D', // Zero-width joiner\n    '\\uFEFF', // Zero-width no-break space\n  ]\n  if (dangerousUnicode.some(char => filePath.includes(char))) return false\n\n  // ✅ Absolute Windows paths trying to escape\n  if (/^[A-Za-z]:\\\\.*\\\\\\.\\./.test(filePath)) return false\n\n  return true\n}\n\n/**\n * Validates file size against a maximum limit\n *\n * Checks if a file size is valid (non-negative) and within acceptable limits.\n * Used to prevent:\n * - Denial of Service (DoS) attacks via large file uploads\n * - Disk space exhaustion\n * - Memory overflow during file processing\n *\n * @param size - File size in bytes to validate\n * @param maxSize - Maximum allowed size in bytes\n * @returns True if size is valid and within limit, false otherwise\n *\n * @example\n * ```typescript\n * // Common size limits\n * const KB = 1024\n * const MB = 1024 * KB\n * const GB = 1024 * MB\n *\n * // Image upload validation (5 MB limit)\n * const imageSize = 4 * MB\n * isValidFileSize(imageSize, 5 * MB)  // true\n *\n * // Document upload validation (10 MB limit)\n * const docSize = 12 * MB\n * isValidFileSize(docSize, 10 * MB)  // false (exceeds limit)\n *\n * // Video upload validation (1 GB limit)\n * const videoSize = 500 * MB\n * isValidFileSize(videoSize, 1 * GB)  // true\n *\n * // Invalid sizes\n * isValidFileSize(-100, 1 * MB)      // false (negative size)\n * isValidFileSize(NaN, 1 * MB)       // false (invalid number)\n * isValidFileSize('1000' as any, 1 * MB) // false (not a number)\n *\n * // Real-world usage in file upload handler\n * app.post('/upload', (req, res) => {\n *   const file = req.files.document\n *   const maxSize = 10 * 1024 * 1024 // 10 MB\n *\n *   if (!isValidFileSize(file.size, maxSize)) {\n *     return res.status(413).json({\n *       error: 'File too large',\n *       maxSize: '10 MB',\n *       received: `${(file.size / (1024 * 1024)).toFixed(2)} MB`\n *     })\n *   }\n *\n *   // Process file...\n * })\n * ```\n *\n * @see {@link isValidFilePath} for path security validation\n */\nexport function isValidFileSize(size: number, maxSize: number): boolean {\n  return typeof size === 'number' && size >= 0 && size <= maxSize\n}\n\n/**\n * Validates text content for security vulnerabilities and size limits\n *\n * Performs basic security checks on text content to detect common XSS attack vectors:\n * - Script tags (<script>)\n * - JavaScript URLs (javascript:)\n * - Data URLs with HTML (data:text/html)\n * - VBScript URLs (vbscript:)\n *\n * Also enforces maximum content length to prevent DoS attacks.\n *\n * ⚠️ WARNING: This is basic XSS detection. For production systems:\n * - Use dedicated sanitization libraries (DOMPurify, sanitize-html)\n * - Implement Content Security Policy (CSP)\n * - Apply output encoding based on context (HTML, JS, URL)\n * - Validate against allowlists, not just blocklists\n *\n * @param content - Text content to validate\n * @param options - Validation options\n * @param options.maxLength - Maximum content length in characters (default: 1,000,000)\n * @returns True if content appears safe, false if dangerous patterns detected\n *\n * @example\n * ```typescript\n * // Safe content - Allowed\n * isValidTextContent('Hello, world!')           // true\n * isValidTextContent('User input: <b>bold</b>') // true\n * isValidTextContent('Email: user@example.com') // true\n *\n * // Dangerous content - XSS vectors detected\n * isValidTextContent('<script>alert(\"XSS\")</script>')     // false\n * isValidTextContent('<img src=x onerror=\"alert(1)\">')    // false (contains 'script' in onerror)\n * isValidTextContent('<a href=\"javascript:void(0)\">')     // false\n * isValidTextContent('<iframe src=\"data:text/html,...\"') // false\n * isValidTextContent('vbscript:msgbox(\"XSS\")')           // false\n *\n * // Size limit validation\n * isValidTextContent('x'.repeat(999_999))              // true (under default 1M limit)\n * isValidTextContent('x'.repeat(1_000_001))            // false (exceeds default limit)\n * isValidTextContent('x'.repeat(5000), { maxLength: 1000 }) // false (custom limit)\n *\n * // Edge cases\n * isValidTextContent('')                     // true (empty is valid)\n * isValidTextContent(null as any)            // false (not a string)\n * isValidTextContent(undefined as any)       // false (not a string)\n * isValidTextContent(123 as any)             // false (not a string)\n *\n * // Real-world usage in comment system\n * app.post('/api/comments', (req, res) => {\n *   const { content } = req.body\n *\n *   if (!isValidTextContent(content, { maxLength: 5000 })) {\n *     return res.status(400).json({\n *       error: 'Invalid comment content',\n *       details: 'Content contains dangerous patterns or exceeds 5000 characters'\n *     })\n *   }\n *\n *   // Additional sanitization recommended\n *   const sanitized = DOMPurify.sanitize(content)\n *\n *   // Save to database...\n * })\n * ```\n *\n * @example\n * ```typescript\n * // Form validation with custom limits\n * function validateUserBio(bio: string): { valid: boolean; error?: string } {\n *   if (!isValidTextContent(bio, { maxLength: 500 })) {\n *     return {\n *       valid: false,\n *       error: 'Bio must be less than 500 characters and cannot contain scripts'\n *     }\n *   }\n *   return { valid: true }\n * }\n * ```\n *\n * @see {@link isValidFilePath} for file path validation\n * @see sanitizeHtml from validation module for HTML sanitization\n */\nexport function isValidTextContent(content: string, options: { maxLength?: number } = {}): boolean {\n  const { maxLength = 1_000_000 } = options\n\n  // ✅ Type validation\n  if (typeof content !== 'string') return false\n\n  // ✅ Length validation (DoS prevention)\n  if (content.length > maxLength) return false\n\n  const lowerContent = content.toLowerCase()\n\n  // ✅ Script tag detection (case-insensitive, with variants)\n  const scriptPatterns = ['<script', '</script', '<scr<script>ipt', '<scr\\x00ipt']\n  if (scriptPatterns.some(pattern => lowerContent.includes(pattern))) return false\n\n  // ✅ Event handler attributes (XSS vectors)\n  const eventHandlers = [\n    'onerror',\n    'onload',\n    'onclick',\n    'onmouseover',\n    'onfocus',\n    'onblur',\n    'oninput',\n  ]\n  if (eventHandlers.some(handler => lowerContent.includes(handler))) return false\n\n  // ✅ Protocol handlers (javascript:, data:, vbscript:, file:)\n  const protocolPatterns = [\n    'javascript:',\n    'data:text/html',\n    'data:text/javascript',\n    'data:application',\n    'vbscript:',\n    'file:///',\n    'steam://',\n    'slack://',\n  ]\n  if (protocolPatterns.some(pattern => lowerContent.includes(pattern))) return false\n\n  // ✅ Encoded script attempts\n  const encodedPatterns = [\n    '&#60;script', // &#60; = <\n    '%3cscript', // %3c = <\n    '\\\\x3cscript', // \\x3c = <\n    '\\\\u003cscript', // \\u003c = <\n  ]\n  if (encodedPatterns.some(pattern => lowerContent.includes(pattern))) return false\n\n  // ✅ SVG-based XSS\n  if (lowerContent.includes('<svg') && lowerContent.includes('onload')) return false\n\n  // ✅ iframe injection\n  if (lowerContent.includes('<iframe')) return false\n\n  return true\n}\n"],"mappings":";;;AAwEO,SAAS,gBAAgB,UAA2B;AAEzD,MAAI,CAAC,YAAY,OAAO,aAAa,SAAU,QAAO;AAGtD,MAAI,OAAO,aAAa,SAAU,QAAO;AAGzC,MAAI,SAAS,WAAW,KAAK,SAAS,SAAS,IAAM,QAAO;AAI5D,MAAI,SAAS,SAAS,KAAK,KAAK,SAAS,SAAS,MAAM,EAAG,QAAO;AAGlE,QAAM,qBAAqB,CAAC,MAAM,QAAQ,QAAQ,QAAQ,OAAO,OAAO;AACxE,MAAI,mBAAmB,KAAK,aAAW,SAAS,SAAS,OAAO,CAAC,EAAG,QAAO;AAG3E,QAAM,kBAAkB;AAAA,IACtB;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EACF;AACA,MAAI,gBAAgB,KAAK,aAAW,SAAS,YAAY,EAAE,SAAS,OAAO,CAAC,EAAG,QAAO;AAGtF,MAAI,SAAS,SAAS,IAAM,EAAG,QAAO;AAGtC,QAAM,eAAe,CAAC,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AACjE,MAAI,aAAa,KAAK,UAAQ,SAAS,SAAS,IAAI,CAAC,EAAG,QAAO;AAG/D,QAAM,cAAc,CAAC,KAAK,KAAK,MAAM,MAAM,MAAM,QAAQ,UAAU,SAAS,QAAQ;AACpF,QAAM,YAAY,SAAS,YAAY;AACvC,MACE,YAAY;AAAA,IACV,aACE,UAAU,SAAS,QAAQ,YAAY,CAAC,MACvC,YAAY,OAAO,YAAY,OAAO,UAAU,SAAS,IAAI,QAAQ,YAAY,CAAC,EAAE;AAAA,EACzF;AAEA,WAAO;AAGT,QAAM,mBAAmB;AAAA,IACvB;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EACF;AACA,MAAI,iBAAiB,KAAK,UAAQ,SAAS,SAAS,IAAI,CAAC,EAAG,QAAO;AAGnE,MAAI,uBAAuB,KAAK,QAAQ,EAAG,QAAO;AAElD,SAAO;AACT;AA0DO,SAAS,gBAAgB,MAAc,SAA0B;AACtE,SAAO,OAAO,SAAS,YAAY,QAAQ,KAAK,QAAQ;AAC1D;AAoFO,SAAS,mBAAmB,SAAiB,UAAkC,CAAC,GAAY;AACjG,QAAM,EAAE,YAAY,IAAU,IAAI;AAGlC,MAAI,OAAO,YAAY,SAAU,QAAO;AAGxC,MAAI,QAAQ,SAAS,UAAW,QAAO;AAEvC,QAAM,eAAe,QAAQ,YAAY;AAGzC,QAAM,iBAAiB,CAAC,WAAW,aAAY,mBAAmB,WAAa;AAC/E,MAAI,eAAe,KAAK,aAAW,aAAa,SAAS,OAAO,CAAC,EAAG,QAAO;AAG3E,QAAM,gBAAgB;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,MAAI,cAAc,KAAK,aAAW,aAAa,SAAS,OAAO,CAAC,EAAG,QAAO;AAG1E,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,MAAI,iBAAiB,KAAK,aAAW,aAAa,SAAS,OAAO,CAAC,EAAG,QAAO;AAG7E,QAAM,kBAAkB;AAAA,IACtB;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EACF;AACA,MAAI,gBAAgB,KAAK,aAAW,aAAa,SAAS,OAAO,CAAC,EAAG,QAAO;AAG5E,MAAI,aAAa,SAAS,MAAM,KAAK,aAAa,SAAS,QAAQ,EAAG,QAAO;AAG7E,MAAI,aAAa,SAAS,SAAS,EAAG,QAAO;AAE7C,SAAO;AACT;","names":[]}

package/dist/cjs/async.js

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/async.ts
+var async_exports = {};
+__export(async_exports, {
+  handleOperation: () => handleOperation,
+  runBatch: () => runBatch,
+  sleep: () => sleep,
+  wait: () => wait
+});
+module.exports = __toCommonJS(async_exports);
+
+// src/errors.ts
+var TsHelpersError = class _TsHelpersError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "TsHelpersError";
+    this.code = options.code;
+    this.data = options.data;
+    this.cause = options.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TsHelpersError);
+    }
+  }
+};
+
+// src/async.ts
+var sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+var wait = (ms) => sleep(ms);
+async function runBatch(jobs, batchSize = 50) {
+  if (batchSize <= 0) {
+    throw new TsHelpersError("Batch size must be greater than 0", {
+      code: "INVALID_OPERATION" /* INVALID_OPERATION */,
+      data: { batchSize }
+    });
+  }
+  const results = [];
+  const batches = Math.ceil(jobs.length / batchSize);
+  for (let i = 0; i < batches; i++) {
+    const batchStart = i * batchSize;
+    const batchEnd = batchStart + batchSize;
+    const batch = jobs.slice(batchStart, batchEnd);
+    const batchResults = await Promise.all(batch.map((job) => job));
+    results.push(...batchResults);
+  }
+  return results;
+}
+function handleOperation(target, operation, ...args) {
+  if (operation.includes("/")) {
+    const [parentOp, childOp] = operation.split("/");
+    if (!target[parentOp] || !target[parentOp][childOp]) {
+      throw new TsHelpersError(`Operation [${operation}] does not exist`, {
+        code: "INVALID_OPERATION" /* INVALID_OPERATION */,
+        data: { operation, parentOp, childOp }
+      });
+    }
+    return target[parentOp][childOp](...args);
+  }
+  if (!target[operation]) {
+    throw new TsHelpersError(`Operation [${operation}] does not exist`, {
+      code: "INVALID_OPERATION" /* INVALID_OPERATION */,
+      data: { operation }
+    });
+  }
+  return target[operation](...args);
+}
+//# sourceMappingURL=async.js.map

package/dist/cjs/async.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/async.ts","../../src/errors.ts"],"sourcesContent":["/**\n * Asynchronous utilities and operations\n * Consolidated from core/async module\n */\n\n/* eslint-disable no-await-in-loop */\n\nimport { TsHelpersError, TsHelpersErrorCode } from './errors'\n\n// =============================================================================\n// DELAY UTILITIES\n// =============================================================================\n\n/**\n * Creates an asynchronous delay for the specified number of milliseconds\n *\n * Pauses async execution without blocking the event loop. Uses Promise with setTimeout\n * internally to schedule resumption after the specified delay.\n *\n * Common use cases:\n * - Rate limiting API calls\n * - Retry delays with exponential backoff\n * - Animation/transition timing\n * - Polling intervals\n * - Debouncing operations\n *\n * @param ms - Milliseconds to sleep (delay duration)\n * @returns Promise that resolves after the specified delay\n *\n * @example\n * ```typescript\n * // Basic delay\n * console.log('Starting...')\n * await sleep(2000)  // Wait 2 seconds\n * console.log('Done!')\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Rate-limited API calls\n * async function fetchAllUsers(userIds: string[]): Promise<User[]> {\n *   const users: User[] = []\n *\n *   for (const id of userIds) {\n *     const user = await api.getUser(id)\n *     users.push(user)\n *\n *     // Rate limit: 100ms between requests (max 10 req/sec)\n *     await sleep(100)\n *   }\n *\n *   return users\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Exponential backoff retry\n * async function fetchWithRetry(url: string, maxRetries = 3): Promise<Response> {\n *   let lastError: Error | null = null\n *\n *   for (let attempt = 0; attempt < maxRetries; attempt++) {\n *     try {\n *       return await fetch(url)\n *     } catch (error) {\n *       lastError = error as Error\n *       const delay = Math.pow(2, attempt) * 1000  // 1s, 2s, 4s\n *       console.log(`Retry ${attempt + 1}/${maxRetries} in ${delay}ms`)\n *       await sleep(delay)\n *     }\n *   }\n *\n *   throw lastError\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Polling with timeout\n * async function pollUntilReady(\n *   checkFn: () => Promise<boolean>,\n *   timeoutMs = 30000\n * ): Promise<boolean> {\n *   const startTime = Date.now()\n *\n *   while (Date.now() - startTime < timeoutMs) {\n *     if (await checkFn()) {\n *       return true\n *     }\n *     await sleep(1000)  // Poll every second\n *   }\n *\n *   throw new Error('Timeout waiting for ready state')\n * }\n *\n * // Usage: Wait for service to be ready\n * await pollUntilReady(async () => {\n *   const response = await fetch('/health')\n *   return response.ok\n * })\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Animated progress bar\n * async function animateProgress(element: HTMLElement): Promise<void> {\n *   for (let i = 0; i <= 100; i += 5) {\n *     element.style.width = `${i}%`\n *     await sleep(50)  // 50ms per step = 1 second total\n *   }\n * }\n * ```\n *\n * @see {@link wait} for alias with same functionality\n * @see {@link runBatch} for controlled concurrent execution\n */\nexport const sleep = (ms: number): Promise<void> => {\n  return new Promise(resolve => setTimeout(resolve, ms))\n}\n\n/**\n * Simple alias for sleep - Pauses execution for specified milliseconds\n *\n * Identical to {@link sleep}, provided for semantic clarity in code.\n * Use `wait` when the context emphasizes waiting for a condition or event.\n *\n * @param ms - Milliseconds to wait\n * @returns Promise that resolves after the specified delay\n *\n * @example\n * ```typescript\n * // Semantically clearer in some contexts\n * await wait(1000)  // Wait 1 second before continuing\n *\n * // vs sleep (implies intentional delay)\n * await sleep(1000)  // Sleep for 1 second\n * ```\n *\n * @see {@link sleep} for full documentation and examples\n */\nexport const wait = (ms: number): Promise<void> => sleep(ms)\n\n// =============================================================================\n// BATCH PROCESSING\n// =============================================================================\n\n/**\n * Executes an array of Promises in batches to control concurrency\n *\n * Processes promises in sequential batches, waiting for each batch to complete before\n * starting the next. Prevents overwhelming systems with too many concurrent requests.\n *\n * Algorithm:\n * 1. Divide promises into batches of size `batchSize`\n * 2. Execute each batch with Promise.all (parallel within batch)\n * 3. Wait for batch completion before starting next batch\n * 4. Collect and return all results in original order\n *\n * Use cases:\n * - Rate-limited API calls (respect API quotas)\n * - Database bulk operations (avoid connection pool exhaustion)\n * - File system operations (prevent file descriptor limits)\n * - Memory-intensive operations (control memory usage)\n *\n * @param jobs - Array of Promises to execute\n * @param batchSize - Number of promises to execute concurrently per batch (default: 50)\n * @returns Promise resolving to array of all results in original order\n *\n * @example\n * ```typescript\n * // Basic batch processing\n * const urls = ['url1', 'url2', ..., 'url100']  // 100 URLs\n * const fetchPromises = urls.map(url => fetch(url))\n *\n * // Execute 10 at a time instead of all 100 simultaneously\n * const responses = await runBatch(fetchPromises, 10)\n * // Batch 1: urls 0-9 (parallel)\n * // Batch 2: urls 10-19 (parallel) - starts after batch 1 completes\n * // ... 10 batches total\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Bulk user data fetch respecting API rate limits\n * async function fetchUsersInBatches(userIds: string[]): Promise<User[]> {\n *   console.log(`Fetching ${userIds.length} users in batches of 20...`)\n *\n *   const fetchPromises = userIds.map(id =>\n *     fetch(`/api/users/${id}`).then(res => res.json())\n *   )\n *\n *   const users = await runBatch(fetchPromises, 20)\n *\n *   console.log(`✅ Fetched ${users.length} users`)\n *   return users\n * }\n *\n * // Fetches 1000 users: 50 batches of 20, not 1000 simultaneous requests\n * const allUsers = await fetchUsersInBatches(userIdArray)\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Database bulk insert with connection pool limits\n * async function bulkInsertUsers(users: User[]): Promise<void> {\n *   // Database pool has 10 connections, use batch size of 5 for safety\n *   const insertPromises = users.map(user =>\n *     db.query('INSERT INTO users VALUES ($1, $2)', [user.name, user.email])\n *   )\n *\n *   await runBatch(insertPromises, 5)\n *   console.log(`✅ Inserted ${users.length} users`)\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Image processing pipeline\n * async function processImages(imagePaths: string[]): Promise<Buffer[]> {\n *   console.log(`Processing ${imagePaths.length} images...`)\n *\n *   const processingPromises = imagePaths.map(async path => {\n *     const img = await loadImage(path)\n *     const resized = await resize(img, { width: 800, height: 600 })\n *     const compressed = await compress(resized, { quality: 80 })\n *     return compressed\n *   })\n *\n *   // Process 3 images at a time to avoid memory exhaustion\n *   const processed = await runBatch(processingPromises, 3)\n *\n *   console.log(`✅ Processed ${processed.length} images`)\n *   return processed\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Parallel file uploads with progress tracking\n * async function uploadFilesWithProgress(\n *   files: File[]\n * ): Promise<UploadResult[]> {\n *   let completed = 0\n *\n *   const uploadPromises = files.map(async file => {\n *     const result = await uploadToS3(file)\n *     completed++\n *     console.log(`Progress: ${completed}/${files.length} (${((completed/files.length)*100).toFixed(1)}%)`)\n *     return result\n *   })\n *\n *   // Upload 5 files at a time\n *   return await runBatch(uploadPromises, 5)\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Scraping with politeness delay\n * async function scrapeWebsites(urls: string[]): Promise<ScrapedData[]> {\n *   const scrapePromises = urls.map(async url => {\n *     const html = await fetch(url).then(r => r.text())\n *     const data = parseHTML(html)\n *\n *     // Polite delay between requests in same batch\n *     await sleep(200)\n *\n *     return data\n *   })\n *\n *   // Only 3 concurrent requests to avoid overwhelming target server\n *   return await runBatch(scrapePromises, 3)\n * }\n * ```\n *\n * @see {@link sleep} for adding delays between operations\n * @see {@link handleOperation} for dynamic operation execution\n */\nexport async function runBatch<T>(jobs: Promise<T>[], batchSize: number = 50): Promise<T[]> {\n  if (batchSize <= 0) {\n    throw new TsHelpersError('Batch size must be greater than 0', {\n      code: TsHelpersErrorCode.INVALID_OPERATION,\n      data: { batchSize },\n    })\n  }\n\n  const results: T[] = []\n  const batches = Math.ceil(jobs.length / batchSize)\n\n  for (let i = 0; i < batches; i++) {\n    const batchStart = i * batchSize\n    const batchEnd = batchStart + batchSize\n    const batch = jobs.slice(batchStart, batchEnd)\n\n    const batchResults = await Promise.all(batch.map(job => job))\n    results.push(...batchResults)\n  }\n\n  return results\n}\n\n// =============================================================================\n// DYNAMIC OPERATION UTILITIES\n// =============================================================================\n\n/**\n * Dynamically executes an operation on a target object by name\n *\n * Invokes methods on objects using string-based operation names. Supports nested\n * method access using 'parent/child' slash notation for organized operation namespacing.\n *\n * Features:\n * - Dynamic method invocation by string name\n * - Nested method access with '/' separator (e.g., 'api/getUser')\n * - Automatic error handling with descriptive messages\n * - Type-safe return value with generics\n *\n * Use cases:\n * - Dynamic API route handlers\n * - Plugin architectures with string-based commands\n * - RPC (Remote Procedure Call) implementations\n * - Command pattern implementations\n * - Configuration-driven operations\n *\n * @param target - Object containing methods to execute\n * @param operation - Method name or 'parent/child' path to execute\n * @param args - Arguments to pass to the operation\n * @returns Promise resolving to operation result\n * @throws {TsHelpersError} If operation doesn't exist on target\n *\n * @example\n * ```typescript\n * // Basic operation execution\n * const api = {\n *   getUser: async (id: string) => ({ id, name: 'John' }),\n *   createUser: async (data: any) => ({ id: '123', ...data })\n * }\n *\n * const user = await handleOperation<User>(api, 'getUser', 'user-123')\n * // { id: 'user-123', name: 'John' }\n * ```\n *\n * @example\n * ```typescript\n * // Nested operations with slash notation\n * const service = {\n *   users: {\n *     list: async () => [{ id: '1' }, { id: '2' }],\n *     create: async (data: any) => ({ id: 'new', ...data }),\n *     delete: async (id: string) => ({ success: true })\n *   },\n *   posts: {\n *     list: async () => [{ id: 'post-1' }],\n *     create: async (data: any) => ({ id: 'new-post', ...data })\n *   }\n * }\n *\n * // Execute nested operation\n * const users = await handleOperation(service, 'users/list')\n * const newUser = await handleOperation(service, 'users/create', { name: 'Alice' })\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Dynamic API router\n * interface ApiRequest {\n *   operation: string\n *   params: any[]\n * }\n *\n * const apiHandlers = {\n *   user: {\n *     get: async (id: string) => db.users.findById(id),\n *     create: async (data: UserInput) => db.users.create(data),\n *     update: async (id: string, data: Partial<UserInput>) =>\n *       db.users.update(id, data),\n *     delete: async (id: string) => db.users.delete(id)\n *   },\n *   product: {\n *     search: async (query: string) => db.products.search(query),\n *     list: async (page: number) => db.products.list(page)\n *   }\n * }\n *\n * async function handleApiRequest(req: ApiRequest): Promise<any> {\n *   try {\n *     return await handleOperation(\n *       apiHandlers,\n *       req.operation,\n *       ...req.params\n *     )\n *   } catch (error) {\n *     console.error(`Failed to execute ${req.operation}:`, error)\n *     throw error\n *   }\n * }\n *\n * // Usage\n * await handleApiRequest({ operation: 'user/get', params: ['user-123'] })\n * await handleApiRequest({ operation: 'product/search', params: ['laptop'] })\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: Plugin system with dynamic commands\n * interface Plugin {\n *   name: string\n *   commands: Record<string, (...args: any[]) => Promise<any>>\n * }\n *\n * class PluginManager {\n *   private plugins: Map<string, Plugin> = new Map()\n *\n *   register(plugin: Plugin): void {\n *     this.plugins.set(plugin.name, plugin)\n *   }\n *\n *   async executeCommand(\n *     pluginName: string,\n *     command: string,\n *     ...args: any[]\n *   ): Promise<any> {\n *     const plugin = this.plugins.get(pluginName)\n *     if (!plugin) throw new Error(`Plugin ${pluginName} not found`)\n *\n *     return handleOperation(plugin.commands, command, ...args)\n *   }\n * }\n *\n * // Register plugins\n * const manager = new PluginManager()\n * manager.register({\n *   name: 'fileOps',\n *   commands: {\n *     read: async (path: string) => fs.readFile(path, 'utf-8'),\n *     write: async (path: string, content: string) =>\n *       fs.writeFile(path, content)\n *   }\n * })\n *\n * // Execute plugin commands dynamically\n * await manager.executeCommand('fileOps', 'read', './config.json')\n * ```\n *\n * @example\n * ```typescript\n * // Real-world: RPC-style service calls\n * const rpcService = {\n *   math: {\n *     add: async (a: number, b: number) => a + b,\n *     multiply: async (a: number, b: number) => a * b\n *   },\n *   string: {\n *     reverse: async (s: string) => s.split('').reverse().join(''),\n *     uppercase: async (s: string) => s.toUpperCase()\n *   }\n * }\n *\n * async function rpcCall(method: string, ...params: any[]): Promise<any> {\n *   console.log(`RPC Call: ${method}(${params.join(', ')})`)\n *   const result = await handleOperation(rpcService, method, ...params)\n *   console.log(`RPC Result: ${result}`)\n *   return result\n * }\n *\n * await rpcCall('math/add', 5, 3)           // RPC Result: 8\n * await rpcCall('string/reverse', 'hello')  // RPC Result: olleh\n * ```\n *\n * @example\n * ```typescript\n * // Error handling\n * try {\n *   await handleOperation(api, 'nonexistent/method')\n * } catch (error) {\n *   console.error(error.message)\n *   // \"Operation [nonexistent/method] does not exist\"\n *   console.error(error.code)\n *   // TsHelpersErrorCode.INVALID_OPERATION\n * }\n * ```\n *\n * @see {@link TsHelpersError} for error structure\n * @see {@link TsHelpersErrorCode} for error codes\n */\nexport function handleOperation<T>(\n  target: Record<string, any>,\n  operation: string,\n  ...args: any[]\n): Promise<T> {\n  if (operation.includes('/')) {\n    const [parentOp, childOp] = operation.split('/')\n\n    if (!target[parentOp] || !target[parentOp][childOp]) {\n      throw new TsHelpersError(`Operation [${operation}] does not exist`, {\n        code: TsHelpersErrorCode.INVALID_OPERATION,\n        data: { operation, parentOp, childOp },\n      })\n    }\n\n    return target[parentOp][childOp](...args)\n  }\n\n  if (!target[operation]) {\n    throw new TsHelpersError(`Operation [${operation}] does not exist`, {\n      code: TsHelpersErrorCode.INVALID_OPERATION,\n      data: { operation },\n    })\n  }\n\n  return target[operation](...args)\n}\n","/**\n * Error handling utilities with specific error types and codes\n * Provides structured error handling for validation, data processing, and environment issues\n */\n\n/**\n * Enumeration of specific error codes for different failure scenarios\n * @example\n * ```ts\n * // Using error codes for type-safe error handling\n * try {\n *   validateNIF('invalid')\n * } catch (error) {\n *   if (error.code === TsHelpersErrorCode.VALIDATION_FAILED) {\n *     console.log('Validation error:', error.data)\n *   }\n * }\n * ```\n */\nexport enum TsHelpersErrorCode {\n  /** Validation of input data failed (NIF, email, etc.) */\n  VALIDATION_FAILED = 'VALIDATION_FAILED',\n  /** Error processing data (CSV, JSON, aggregations, etc.) */\n  DATA_PROCESSING_FAILED = 'DATA_PROCESSING_FAILED',\n  /** Current environment doesn't support the operation */\n  ENVIRONMENT_NOT_SUPPORTED = 'ENVIRONMENT_NOT_SUPPORTED',\n  /** File format not supported for import/export */\n  UNSUPPORTED_FORMAT = 'UNSUPPORTED_FORMAT',\n  /** File system operation failed */\n  FILE_ERROR = 'FILE_ERROR',\n  /** Network or fetch operation failed */\n  NETWORK_ERROR = 'NETWORK_ERROR',\n  /** Invalid operation or function call */\n  INVALID_OPERATION = 'INVALID_OPERATION',\n  /** Crypto operation failed (hash, token generation) */\n  CRYPTO_ERROR = 'CRYPTO_ERROR',\n  /** Math calculation failed (invalid input, division by zero) */\n  MATH_ERROR = 'MATH_ERROR',\n  /** Generic unknown error */\n  UNKNOWN_ERROR = 'UNKNOWN_ERROR',\n}\n\n/**\n * Options for creating TsHelpersError instances\n */\nexport interface TsHelpersErrorOptions {\n  /** Specific error code for categorization */\n  code?: TsHelpersErrorCode\n  /** Additional data about the error context */\n  data?: any\n  /** Original error that caused this error */\n  cause?: Error\n}\n\n/**\n * Main error class for @g10/ts-helpers with structured error information\n * @example\n * ```ts\n * // Creating structured errors\n * throw new TsHelpersError('Invalid NIF format', {\n *   code: TsHelpersErrorCode.VALIDATION_FAILED,\n *   data: { input: '12345', expected: '8 digits + letter' }\n * })\n *\n * // Error handling with type checking\n * try {\n *   someOperation()\n * } catch (error) {\n *   if (error instanceof TsHelpersError) {\n *     console.log('Error code:', error.code)\n *     console.log('Error data:', error.data)\n *   }\n * }\n * ```\n */\nexport class TsHelpersError extends Error {\n  public readonly code?: TsHelpersErrorCode\n  public readonly data?: any\n  public readonly cause?: Error\n\n  constructor(message: string, options: TsHelpersErrorOptions = {}) {\n    super(message)\n    this.name = 'TsHelpersError'\n    this.code = options.code\n    this.data = options.data\n    this.cause = options.cause\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, TsHelpersError)\n    }\n  }\n}\n\n/**\n * Specialized error class for data processing operations\n * @example\n * ```ts\n * // Data processing errors\n * throw new DataError(\n *   'Failed to parse CSV',\n *   TsHelpersErrorCode.DATA_PROCESSING_FAILED,\n *   { line: 5, column: 'amount' }\n * )\n * ```\n */\nexport class DataError extends TsHelpersError {\n  constructor(message: string, code?: TsHelpersErrorCode, data?: any) {\n    super(message, { code, data })\n    this.name = 'DataError'\n  }\n}\n\n/**\n * Creates a validation error with structured information\n * @param message - Descriptive error message\n * @param field - Field name that failed validation\n * @param value - Value that failed validation\n * @returns TsHelpersError with validation context\n * @example\n * ```ts\n * // Using in validation functions\n * if (!isValidEmail(email)) {\n *   throw createValidationError('Invalid email format', 'email', email)\n * }\n *\n * // Error contains structured data\n * // error.code === TsHelpersErrorCode.VALIDATION_FAILED\n * // error.data === { field: 'email', value: 'invalid-email' }\n * ```\n */\nexport function createValidationError(message: string, field: string, value: any): TsHelpersError {\n  return new TsHelpersError(`Validation failed: ${message}`, {\n    code: TsHelpersErrorCode.VALIDATION_FAILED,\n    data: { field, value },\n  })\n}\n\n/**\n * Creates a crypto operation error\n * @param message - Descriptive error message\n * @param operation - Crypto operation that failed\n * @param details - Additional error details\n * @returns TsHelpersError with crypto context\n * @example\n * ```ts\n * // Using in crypto functions\n * if (!crypto.getRandomValues) {\n *   throw createCryptoError('Web Crypto API not available', 'generateSecureToken', {\n *     environment: 'browser',\n *     fallback: 'Math.random'\n *   })\n * }\n * ```\n */\nexport function createCryptoError(\n  message: string,\n  operation: string,\n  details?: any\n): TsHelpersError {\n  return new TsHelpersError(`Crypto error: ${message}`, {\n    code: TsHelpersErrorCode.CRYPTO_ERROR,\n    data: { operation, details },\n  })\n}\n\n/**\n * Creates a math calculation error\n * @param message - Descriptive error message\n * @param operation - Math operation that failed\n * @param input - Input data that caused the error\n * @returns TsHelpersError with math context\n * @example\n * ```ts\n * // Using in math functions\n * if (values.length === 0) {\n *   throw createMathError('Cannot calculate median of empty array', 'calculateMedian', values)\n * }\n * ```\n */\nexport function createMathError(message: string, operation: string, input?: any): TsHelpersError {\n  return new TsHelpersError(`Math error: ${message}`, {\n    code: TsHelpersErrorCode.MATH_ERROR,\n    data: { operation, input },\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC2EO,IAAM,iBAAN,MAAM,wBAAuB,MAAM;AAAA,EAKxC,YAAY,SAAiB,UAAiC,CAAC,GAAG;AAChE,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;AACpB,SAAK,QAAQ,QAAQ;AAErB,QAAI,MAAM,mBAAmB;AAC3B,YAAM,kBAAkB,MAAM,eAAc;AAAA,IAC9C;AAAA,EACF;AACF;;;ADyBO,IAAM,QAAQ,CAAC,OAA8B;AAClD,SAAO,IAAI,QAAQ,aAAW,WAAW,SAAS,EAAE,CAAC;AACvD;AAsBO,IAAM,OAAO,CAAC,OAA8B,MAAM,EAAE;AA0I3D,eAAsB,SAAY,MAAoB,YAAoB,IAAkB;AAC1F,MAAI,aAAa,GAAG;AAClB,UAAM,IAAI,eAAe,qCAAqC;AAAA,MAC5D;AAAA,MACA,MAAM,EAAE,UAAU;AAAA,IACpB,CAAC;AAAA,EACH;AAEA,QAAM,UAAe,CAAC;AACtB,QAAM,UAAU,KAAK,KAAK,KAAK,SAAS,SAAS;AAEjD,WAAS,IAAI,GAAG,IAAI,SAAS,KAAK;AAChC,UAAM,aAAa,IAAI;AACvB,UAAM,WAAW,aAAa;AAC9B,UAAM,QAAQ,KAAK,MAAM,YAAY,QAAQ;AAE7C,UAAM,eAAe,MAAM,QAAQ,IAAI,MAAM,IAAI,SAAO,GAAG,CAAC;AAC5D,YAAQ,KAAK,GAAG,YAAY;AAAA,EAC9B;AAEA,SAAO;AACT;AA0LO,SAAS,gBACd,QACA,cACG,MACS;AACZ,MAAI,UAAU,SAAS,GAAG,GAAG;AAC3B,UAAM,CAAC,UAAU,OAAO,IAAI,UAAU,MAAM,GAAG;AAE/C,QAAI,CAAC,OAAO,QAAQ,KAAK,CAAC,OAAO,QAAQ,EAAE,OAAO,GAAG;AACnD,YAAM,IAAI,eAAe,cAAc,SAAS,oBAAoB;AAAA,QAClE;AAAA,QACA,MAAM,EAAE,WAAW,UAAU,QAAQ;AAAA,MACvC,CAAC;AAAA,IACH;AAEA,WAAO,OAAO,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI;AAAA,EAC1C;AAEA,MAAI,CAAC,OAAO,SAAS,GAAG;AACtB,UAAM,IAAI,eAAe,cAAc,SAAS,oBAAoB;AAAA,MAClE;AAAA,MACA,MAAM,EAAE,UAAU;AAAA,IACpB,CAAC;AAAA,EACH;AAEA,SAAO,OAAO,SAAS,EAAE,GAAG,IAAI;AAClC;","names":[]}

package/dist/cjs/dates.js

@@ -0,0 +1,285 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dates.ts
+var dates_exports = {};
+__export(dates_exports, {
+  addDays: () => addDays,
+  addMonths: () => addMonths,
+  addNowDays: () => addNowDays,
+  addNowMonths: () => addNowMonths,
+  addNowSeconds: () => addNowSeconds,
+  addNowYears: () => addNowYears,
+  addSeconds: () => addSeconds,
+  addYears: () => addYears,
+  areDatesEqualWithTolerance: () => areDatesEqualWithTolerance,
+  dayOfWeek: () => dayOfWeek,
+  diffBusinessDays: () => diffBusinessDays,
+  diffDays: () => diffDays,
+  diffMilliSeconds: () => diffMilliSeconds,
+  diffMonths: () => diffMonths,
+  diffYears: () => diffYears,
+  excelToDate: () => excelToDate,
+  format: () => format,
+  formatForMysql: () => formatForMysql,
+  formatNow: () => formatNow,
+  fromNow: () => fromNow,
+  getFirstDayOfYear: () => getFirstDayOfYear,
+  getFirstWorkdayAfterMonths: () => getFirstWorkdayAfterMonths,
+  getFirstWorkdayOfMonth: () => getFirstWorkdayOfMonth,
+  getLastDayOfYear: () => getLastDayOfYear,
+  getLastWorkdayOfMonth: () => getLastWorkdayOfMonth,
+  isDateTime: () => isDateTime,
+  isEqualsDateTimeByDay: () => isEqualsDateTimeByDay,
+  isExpired: () => isExpired,
+  isNew: () => isNew,
+  isWeekday: () => isWeekday,
+  longString: () => longString,
+  now: () => now,
+  toDate: () => toDate,
+  toDateFromString: () => toDateFromString,
+  toISO: () => toISO,
+  weekOfYear: () => weekOfYear
+});
+module.exports = __toCommonJS(dates_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_utc = __toESM(require("dayjs/plugin/utc.js"));
+var import_relativeTime = __toESM(require("dayjs/plugin/relativeTime.js"));
+var import_weekOfYear = __toESM(require("dayjs/plugin/weekOfYear.js"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat.js"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter.js"));
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore.js"));
+var import_weekday = __toESM(require("dayjs/plugin/weekday.js"));
+var import_localeData = __toESM(require("dayjs/plugin/localeData.js"));
+var import_localizedFormat = __toESM(require("dayjs/plugin/localizedFormat.js"));
+var import_es = require("dayjs/locale/es.js");
+var dateValidator = __toESM(require("iso-datestring-validator"));
+var { isValidDate, isValidISODateString } = dateValidator;
+import_dayjs.default.extend(import_utc.default);
+import_dayjs.default.extend(import_relativeTime.default);
+import_dayjs.default.extend(import_weekOfYear.default);
+import_dayjs.default.extend(import_customParseFormat.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_weekday.default);
+import_dayjs.default.extend(import_localeData.default);
+import_dayjs.default.extend(import_localizedFormat.default);
+import_dayjs.default.locale("es");
+var formatNow = (formatStr = "DD/MM/YYYY") => (0, import_dayjs.default)().format(formatStr);
+var format = (value, formatStr = "DD/MM/YYYY") => {
+  if (!value) return "";
+  if (formatStr.toLowerCase() === "gg") return weekOfYear(value);
+  else if (formatStr.toLowerCase() === "gggg") return (0, import_dayjs.default)(value).format("YY") + weekOfYear(value);
+  return (0, import_dayjs.default)(value).format(formatStr);
+};
+var longString = (value = null) => {
+  if (!value) return "";
+  return (0, import_dayjs.default)(value).format("LL");
+};
+var toDate = (value, isUtc) => {
+  if (isUtc === void 0) return (0, import_dayjs.default)(value).toDate();
+  return isUtc ? import_dayjs.default.utc(value).toDate() : (0, import_dayjs.default)(value).toDate();
+};
+var toDateFromString = (dateString, format2) => {
+  const formatRegex = {
+    "DD/MM/YYYY": /^(\d{2})\/(\d{2})\/(\d{4})$/,
+    "YYYY-MM-DD": /^(\d{4})-(\d{2})-(\d{2})$/,
+    "MM/DD/YYYY": /^(\d{2})\/(\d{2})\/(\d{4})$/,
+    "YYYY/MM/DD": /^(\d{4})\/(\d{2})\/(\d{2})$/,
+    "DD-MM-YYYY": /^(\d{2})-(\d{2})-(\d{4})$/,
+    "MM-DD-YYYY": /^(\d{2})-(\d{2})-(\d{4})$/,
+    YYYYMMDD: /^(\d{4})(\d{2})(\d{2})$/,
+    DDMMYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    MMDDYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    "YYYY.MM.DD": /^(\d{4})\.(\d{2})\.(\d{2})$/,
+    "DD.MM.YYYY": /^(\d{2})\.(\d{2})\.(\d{4})$/,
+    "MM.DD.YYYY": /^(\d{2})\.(\d{2})\.(\d{4})$/
+  };
+  const regex = formatRegex[format2];
+  if (!regex) return null;
+  const match = dateString.match(regex);
+  if (match) {
+    let year, month, day;
+    if (format2.startsWith("YYYY")) {
+      year = parseInt(match[1], 10);
+      month = parseInt(match[2], 10) - 1;
+      day = parseInt(match[3], 10);
+    } else if (format2.startsWith("DD")) {
+      day = parseInt(match[1], 10);
+      month = parseInt(match[2], 10) - 1;
+      year = parseInt(match[3], 10);
+    } else if (format2.startsWith("MM")) {
+      month = parseInt(match[1], 10) - 1;
+      day = parseInt(match[2], 10);
+      year = parseInt(match[3], 10);
+    } else {
+      return null;
+    }
+    return new Date(year, month, day);
+  }
+  return null;
+};
+var now = () => (0, import_dayjs.default)().toDate();
+var isNew = (value, daysnew = 1) => (0, import_dayjs.default)().isSameOrBefore((0, import_dayjs.default)(value).add(daysnew, "days"));
+var toISO = (value = null, isUtc = false) => {
+  if (!value) return (0, import_dayjs.default)().toISOString();
+  return isUtc ? import_dayjs.default.utc(value).toISOString() : (0, import_dayjs.default)(value).toISOString();
+};
+var fromNow = (value) => (0, import_dayjs.default)(value).fromNow();
+var dayOfWeek = (value = null) => {
+  if (!value) return (0, import_dayjs.default)().format("d");
+  return (0, import_dayjs.default)(value).format("d");
+};
+var weekOfYear = (value = null) => {
+  if (!value) return (0, import_dayjs.default)().locale("es").week().toString().padStart(2, "0");
+  return (0, import_dayjs.default)(value).locale("es").week().toString().padStart(2, "0");
+};
+var diffDays = (start, end = null, precise = false) => {
+  const v2 = !end ? (0, import_dayjs.default)() : (0, import_dayjs.default)(end);
+  return (0, import_dayjs.default)(start).diff(v2, "days", precise);
+};
+var diffBusinessDays = (start, end = null, precise = false) => {
+  let startDate = (0, import_dayjs.default)(start).startOf("day");
+  let endDate = end ? (0, import_dayjs.default)(end).startOf("day") : (0, import_dayjs.default)().startOf("day");
+  if (startDate.isAfter(endDate)) {
+    ;
+    [startDate, endDate] = [endDate, startDate];
+  }
+  let businessDays = 0;
+  let currentDate = startDate;
+  while (currentDate.isBefore(endDate)) {
+    if (isWeekday(currentDate)) {
+      businessDays++;
+    }
+    currentDate = currentDate.add(1, "day");
+  }
+  if (precise) {
+    const fractionalDay = endDate.diff(currentDate, "hours") / 24;
+    businessDays += fractionalDay;
+  }
+  return businessDays;
+};
+var diffMonths = (value, valueRefOrNow = null, precise = false) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  return (0, import_dayjs.default)(value).diff(v2, "months", precise);
+};
+var diffYears = (value, valueRefOrNow = null, precise = false) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  return (0, import_dayjs.default)(value).diff(v2, "years", precise);
+};
+var diffMilliSeconds = (value, valueRefOrNow = null) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  return (0, import_dayjs.default)(value).diff(v2, "milliseconds", true);
+};
+var addDays = (value, nDays = 1) => (0, import_dayjs.default)(value).add(nDays, "days").toDate();
+var addSeconds = (value, nSeconds = 1) => (0, import_dayjs.default)(value).add(nSeconds, "seconds").toDate();
+var areDatesEqualWithTolerance = (date1, date2) => {
+  const tolerance = 2 * 1e3;
+  return Math.abs((0, import_dayjs.default)(date1).diff((0, import_dayjs.default)(date2))) <= tolerance;
+};
+var addNowDays = (nDays = 1) => (0, import_dayjs.default)().add(nDays, "days").toDate();
+var addNowSeconds = (nSeconds = 60) => (0, import_dayjs.default)().add(nSeconds, "seconds").toDate();
+var addMonths = (value, nMonths = 1) => (0, import_dayjs.default)(value).add(nMonths, "months").toDate();
+var addNowMonths = (nMonths = 1) => (0, import_dayjs.default)().add(nMonths, "months").toDate();
+var addYears = (value, nYears = 1) => (0, import_dayjs.default)(value).add(nYears, "years").toDate();
+var addNowYears = (nYears = 1) => (0, import_dayjs.default)().add(nYears, "years").toDate();
+var excelToDate = (value) => {
+  try {
+    const d = Number(value);
+    if (d >= 18e3 && d <= 3e5) return new Date(Math.round((d - 25569) * 86400 * 1e3));
+    return null;
+  } catch (_err) {
+    return null;
+  }
+};
+var isDateTime = (value) => {
+  try {
+    if (!value) return false;
+    if (typeof value === "number") return false;
+    else if (typeof value === "boolean") return false;
+    else if (typeof value === "string" && !isValidISODateString(value) && !isValidDate(value) && !isValidDate(value, ""))
+      return false;
+    else if (typeof value === "object" && !(value instanceof Date) && !import_dayjs.default.isDayjs(value))
+      return false;
+    return (0, import_dayjs.default)(value).isValid();
+  } catch (_err) {
+    return false;
+  }
+};
+var isEqualsDateTimeByDay = (value1, value2) => {
+  if (!isDateTime(value1)) return false;
+  if (!isDateTime(value2)) return false;
+  return (0, import_dayjs.default)(value1).isSame((0, import_dayjs.default)(value2), "day");
+};
+var isExpired = (value, valueRefOrNow = null) => {
+  const v2 = !valueRefOrNow ? (0, import_dayjs.default)() : (0, import_dayjs.default)(valueRefOrNow);
+  if (isDateTime(value)) {
+    return v2.isAfter(value);
+  }
+  return true;
+};
+var formatForMysql = (fecha) => {
+  if (!fecha) return null;
+  fecha.setMinutes(fecha.getMinutes() - fecha.getTimezoneOffset());
+  return fecha.toISOString().slice(0, 19).replace("T", " ");
+};
+var getFirstWorkdayOfMonth = (month) => {
+  const monthToUse = month === void 0 ? (0, import_dayjs.default)().month() : month;
+  let firstDay = (0, import_dayjs.default)().month(monthToUse).startOf("month");
+  while (firstDay.day() === 0 || firstDay.day() === 6) {
+    firstDay = firstDay.add(1, "day");
+  }
+  return firstDay.toDate();
+};
+var getLastWorkdayOfMonth = (month) => {
+  const monthToUse = month === void 0 ? (0, import_dayjs.default)().month() : month;
+  let lastDay = (0, import_dayjs.default)().month(monthToUse).endOf("month");
+  while (lastDay.day() === 0 || lastDay.day() === 6) {
+    lastDay = lastDay.subtract(1, "day");
+  }
+  return lastDay.toDate();
+};
+var getFirstWorkdayAfterMonths = (initialDate, n) => {
+  const startDate = (0, import_dayjs.default)(initialDate);
+  const monthsToAdd = n;
+  const targetDate = startDate.add(monthsToAdd, "months");
+  let firstWorkday = targetDate.startOf("month");
+  while (firstWorkday.day() === 0 || firstWorkday.day() === 6) {
+    firstWorkday = firstWorkday.add(1, "day");
+  }
+  return firstWorkday.toDate();
+};
+var getFirstDayOfYear = () => (0, import_dayjs.default)().startOf("year").toDate();
+var getLastDayOfYear = () => (0, import_dayjs.default)().endOf("year").toDate();
+var isWeekday = (date) => {
+  const d = (0, import_dayjs.default)(date);
+  const dayOfWeek2 = d.day();
+  return dayOfWeek2 !== 0 && dayOfWeek2 !== 6;
+};
+//# sourceMappingURL=dates.js.map

package/dist/cjs/dates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dates.ts"],"sourcesContent":["/**\n * Date manipulation and formatting utilities\n * Consolidated from specialized/date module\n */\n\nimport dayjs from 'dayjs'\nimport utc from 'dayjs/plugin/utc.js'\nimport relativeTime from 'dayjs/plugin/relativeTime.js'\nimport weekOfYearPlugin from 'dayjs/plugin/weekOfYear.js'\nimport customParseFormat from 'dayjs/plugin/customParseFormat.js'\nimport isSameOrAfter from 'dayjs/plugin/isSameOrAfter.js'\nimport isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js'\nimport weekday from 'dayjs/plugin/weekday.js'\nimport localeData from 'dayjs/plugin/localeData.js'\nimport localizedFormat from 'dayjs/plugin/localizedFormat.js'\nimport 'dayjs/locale/es.js'\nimport * as dateValidator from 'iso-datestring-validator'\nconst { isValidDate, isValidISODateString } = dateValidator\n\n// Configure dayjs plugins\ndayjs.extend(utc)\ndayjs.extend(relativeTime)\ndayjs.extend(weekOfYearPlugin)\ndayjs.extend(customParseFormat)\ndayjs.extend(isSameOrAfter)\ndayjs.extend(isSameOrBefore)\ndayjs.extend(weekday)\ndayjs.extend(localeData)\ndayjs.extend(localizedFormat)\n\n// Set default locale to Spanish\ndayjs.locale('es')\n\n/**\n * Formats current date with specified format\n */\nexport const formatNow = (formatStr = 'DD/MM/YYYY'): string => dayjs().format(formatStr)\n\n/**\n * Formats date with specified format string (Spanish locale by default)\n *\n * Flexible date formatter with special support for week-of-year formats.\n * Uses dayjs Spanish locale for month/day names.\n *\n * @param value - Date value to format (Date, string, timestamp, dayjs)\n * @param formatStr - Format string (default: 'DD/MM/YYYY' for Spanish dates)\n * @returns Formatted date string, empty string if value is null/undefined\n *\n * @example\n * ```typescript\n * const date = new Date('2024-03-15')\n *\n * format(date)                    // '15/03/2024' (Spanish default)\n * format(date, 'DD-MM-YYYY')      // '15-03-2024'\n * format(date, 'YYYY/MM/DD')      // '2024/03/15'\n * format(date, 'DD MMM YYYY')     // '15 mar 2024' (Spanish month)\n * format(date, 'dddd, DD MMMM')   // 'viernes, 15 marzo' (Spanish)\n * format(date, 'gg')              // '11' (week of year)\n * format(date, 'gggg')            // '2411' (year + week)\n * ```\n *\n * @see {@link longString} for localized long format\n * @see {@link formatNow} for current date formatting\n */\nexport const format = (value: any, formatStr = 'DD/MM/YYYY'): string => {\n  if (!value) return ''\n  if (formatStr.toLowerCase() === 'gg') return weekOfYear(value)\n  else if (formatStr.toLowerCase() === 'gggg') return dayjs(value).format('YY') + weekOfYear(value)\n  return dayjs(value).format(formatStr)\n}\n\n/**\n * Converts date to localized long string format (Spanish)\n *\n * Formats date as human-readable string with full month name in Spanish locale.\n * Uses dayjs 'LL' format: \"15 de marzo de 2024\"\n *\n * @param value - Date value to format (null returns empty string)\n * @returns Localized long format date string (e.g., \"15 de marzo de 2024\")\n *\n * @example\n * ```typescript\n * longString(new Date('2024-03-15'))  // \"15 de marzo de 2024\"\n * longString('2024-12-25')            // \"25 de diciembre de 2024\"\n * longString(null)                    // \"\"\n *\n * // Real-world: Document headers\n * const reportDate = longString(new Date())\n * console.log(`Informe generado el ${reportDate}`)\n * // \"Informe generado el 15 de marzo de 2024\"\n * ```\n *\n * @see {@link format} for custom format strings\n */\nexport const longString = (value: any = null) => {\n  if (!value) return ''\n  return dayjs(value).format('LL')\n}\n\n/**\n * Converts value to native JavaScript Date object\n */\nexport const toDate = (value: any, isUtc?: boolean) => {\n  if (isUtc === undefined) return dayjs(value).toDate()\n  return isUtc ? dayjs.utc(value).toDate() : dayjs(value).toDate()\n}\n\ntype DateStringFormat =\n  | 'DD/MM/YYYY'\n  | 'YYYY-MM-DD'\n  | 'MM/DD/YYYY'\n  | 'YYYY/MM/DD'\n  | 'DD-MM-YYYY'\n  | 'MM-DD-YYYY'\n  | 'YYYYMMDD'\n  | 'DDMMYYYY'\n  | 'MMDDYYYY'\n  | 'YYYY.MM.DD'\n  | 'DD.MM.YYYY'\n  | 'MM.DD.YYYY'\n\n/**\n * Parses date string with specific format to native Date object\n *\n * Strict parser that validates format and creates Date from structured date strings.\n * Supports 12 common date formats with validation.\n *\n * @param dateString - Date string to parse\n * @param format - Expected format (DD/MM/YYYY, YYYY-MM-DD, etc.)\n * @returns Date object or null if invalid\n *\n * @example\n * ```typescript\n * toDateFromString('15/03/2024', 'DD/MM/YYYY')  // Date object\n * toDateFromString('2024-03-15', 'YYYY-MM-DD')  // Date object\n * toDateFromString('invalid', 'DD/MM/YYYY')     // null\n * ```\n *\n * @see {@link format} for formatting dates\n */\nexport const toDateFromString = (dateString: string, format: DateStringFormat): Date | null => {\n  const formatRegex: Record<string, RegExp> = {\n    'DD/MM/YYYY': /^(\\d{2})\\/(\\d{2})\\/(\\d{4})$/,\n    'YYYY-MM-DD': /^(\\d{4})-(\\d{2})-(\\d{2})$/,\n    'MM/DD/YYYY': /^(\\d{2})\\/(\\d{2})\\/(\\d{4})$/,\n    'YYYY/MM/DD': /^(\\d{4})\\/(\\d{2})\\/(\\d{2})$/,\n    'DD-MM-YYYY': /^(\\d{2})-(\\d{2})-(\\d{4})$/,\n    'MM-DD-YYYY': /^(\\d{2})-(\\d{2})-(\\d{4})$/,\n    YYYYMMDD: /^(\\d{4})(\\d{2})(\\d{2})$/,\n    DDMMYYYY: /^(\\d{2})(\\d{2})(\\d{4})$/,\n    MMDDYYYY: /^(\\d{2})(\\d{2})(\\d{4})$/,\n    'YYYY.MM.DD': /^(\\d{4})\\.(\\d{2})\\.(\\d{2})$/,\n    'DD.MM.YYYY': /^(\\d{2})\\.(\\d{2})\\.(\\d{4})$/,\n    'MM.DD.YYYY': /^(\\d{2})\\.(\\d{2})\\.(\\d{4})$/,\n  }\n\n  const regex = formatRegex[format]\n  if (!regex) return null\n\n  const match = dateString.match(regex)\n  if (match) {\n    let year: number, month: number, day: number\n\n    if (format.startsWith('YYYY')) {\n      year = parseInt(match[1], 10)\n      month = parseInt(match[2], 10) - 1\n      day = parseInt(match[3], 10)\n    } else if (format.startsWith('DD')) {\n      day = parseInt(match[1], 10)\n      month = parseInt(match[2], 10) - 1\n      year = parseInt(match[3], 10)\n    } else if (format.startsWith('MM')) {\n      month = parseInt(match[1], 10) - 1\n      day = parseInt(match[2], 10)\n      year = parseInt(match[3], 10)\n    } else {\n      return null\n    }\n\n    return new Date(year, month, day)\n  }\n\n  return null\n}\n\n/**\n * Returns current date\n */\nexport const now = () => dayjs().toDate()\n\n/**\n * Checks if date is considered \"new\" based on days threshold\n */\nexport const isNew = (value: any, daysnew = 1) =>\n  dayjs().isSameOrBefore(dayjs(value).add(daysnew, 'days'))\n\n/**\n * Converts date to ISO 8601 string (YYYY-MM-DDTHH:mm:ss.sssZ)\n *\n * Standard ISO format for API communication and storage.\n *\n * @param value - Date to convert (null = now)\n * @param isUtc - Force UTC timezone (default: false, uses local)\n * @returns ISO 8601 formatted string\n *\n * @example\n * ```typescript\n * toISO()  // \"2024-03-15T10:30:00.000+01:00\" (now, local time)\n * toISO(new Date('2024-03-15'))  // \"2024-03-15T00:00:00.000+01:00\"\n * toISO(new Date('2024-03-15'), true)  // \"2024-03-14T23:00:00.000Z\" (UTC)\n * ```\n */\nexport const toISO = (value: any = null, isUtc = false) => {\n  if (!value) return dayjs().toISOString()\n  return isUtc ? dayjs.utc(value).toISOString() : dayjs(value).toISOString()\n}\n\n/**\n * Returns relative time from now in Spanish (e.g., \"hace 2 horas\")\n *\n * @param value - Date to compare with now\n * @returns Relative time string in Spanish\n *\n * @example\n * ```typescript\n * const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000)\n * fromNow(twoHoursAgo)  // \"hace 2 horas\"\n * ```\n */\nexport const fromNow = (value: any) => dayjs(value).fromNow()\n\n/**\n * Returns day of week (0-6, Sunday is 0)\n */\nexport const dayOfWeek = (value: any = null) => {\n  if (!value) return dayjs().format('d')\n  return dayjs(value).format('d')\n}\n\n/**\n * Returns week of year with zero padding\n */\nexport const weekOfYear = (value: any = null) => {\n  if (!value) return dayjs().locale('es').week().toString().padStart(2, '0')\n  return dayjs(value).locale('es').week().toString().padStart(2, '0')\n}\n\n/**\n * Calculates difference in days between two dates\n */\nexport const diffDays = (start: any, end: any = null, precise = false) => {\n  const v2 = !end ? dayjs() : dayjs(end)\n  return dayjs(start).diff(v2, 'days', precise)\n}\n\n/**\n * Calculates difference in business days (weekdays only, excludes weekends)\n *\n * Counts Mon-Fri between two dates, excluding Saturdays and Sundays.\n * Does NOT account for holidays.\n *\n * @param start - Start date\n * @param end - End date (null = now)\n * @param precise - Include fractional days (default: false)\n * @returns Number of business days (Mon-Fri)\n *\n * @example\n * ```typescript\n * // Monday to Friday (same week)\n * diffBusinessDays('2024-03-11', '2024-03-15')  // 4 business days\n *\n * // Including weekend (skip Sat/Sun)\n * diffBusinessDays('2024-03-15', '2024-03-18')  // 1 (Fri to Mon)\n *\n * // Real-world: SLA calculation\n * const ticketCreated = new Date('2024-03-11')\n * const businessDays = diffBusinessDays(ticketCreated)\n * if (businessDays > 5) {\n *   console.log('⚠️ SLA violation: > 5 business days')\n * }\n * ```\n */\nexport const diffBusinessDays = (start: any, end: any = null, precise = false) => {\n  let startDate = dayjs(start).startOf('day')\n  let endDate = end ? dayjs(end).startOf('day') : dayjs().startOf('day')\n\n  if (startDate.isAfter(endDate)) {\n    ;[startDate, endDate] = [endDate, startDate]\n  }\n\n  let businessDays = 0\n  let currentDate = startDate\n\n  while (currentDate.isBefore(endDate)) {\n    if (isWeekday(currentDate)) {\n      businessDays++\n    }\n    currentDate = currentDate.add(1, 'day')\n  }\n\n  if (precise) {\n    const fractionalDay = endDate.diff(currentDate, 'hours') / 24\n    businessDays += fractionalDay\n  }\n\n  return businessDays\n}\n\n/**\n * Calculates difference in months between two dates\n */\nexport const diffMonths = (value: any, valueRefOrNow: any = null, precise = false) => {\n  const v2 = !valueRefOrNow ? dayjs() : dayjs(valueRefOrNow)\n  return dayjs(value).diff(v2, 'months', precise)\n}\n\n/**\n * Calculates difference in years between two dates\n */\nexport const diffYears = (value: any, valueRefOrNow: any = null, precise = false) => {\n  const v2 = !valueRefOrNow ? dayjs() : dayjs(valueRefOrNow)\n  return dayjs(value).diff(v2, 'years', precise)\n}\n\n/**\n * Calculates difference in milliseconds between two dates\n */\nexport const diffMilliSeconds = (value: any, valueRefOrNow: any = null) => {\n  const v2 = !valueRefOrNow ? dayjs() : dayjs(valueRefOrNow)\n  return dayjs(value).diff(v2, 'milliseconds', true)\n}\n\n/**\n * Adds days to a date\n */\nexport const addDays = (value: any, nDays: number = 1) => dayjs(value).add(nDays, 'days').toDate()\n\n/**\n * Adds seconds to a date\n */\nexport const addSeconds = (value: any, nSeconds: number = 1) =>\n  dayjs(value).add(nSeconds, 'seconds').toDate()\n\n/**\n * Compares two dates with ± 2 seconds tolerance\n */\nexport const areDatesEqualWithTolerance = (date1: Date, date2: Date): boolean => {\n  const tolerance = 2 * 1000 // 2 seconds in milliseconds\n  return Math.abs(dayjs(date1).diff(dayjs(date2))) <= tolerance\n}\n\n/**\n * Adds days to current date\n */\nexport const addNowDays = (nDays: number = 1) => dayjs().add(nDays, 'days').toDate()\n\n/**\n * Adds seconds to current date\n */\nexport const addNowSeconds = (nSeconds: number = 60) => dayjs().add(nSeconds, 'seconds').toDate()\n\n/**\n * Adds months to a date\n */\nexport const addMonths = (value: any, nMonths: number = 1) =>\n  dayjs(value).add(nMonths, 'months').toDate()\n\n/**\n * Adds months to current date\n */\nexport const addNowMonths = (nMonths: number = 1) => dayjs().add(nMonths, 'months').toDate()\n\n/**\n * Adds years to a date\n */\nexport const addYears = (value: any, nYears: number = 1) =>\n  dayjs(value).add(nYears, 'years').toDate()\n\n/**\n * Adds years to current date\n */\nexport const addNowYears = (nYears: number = 1) => dayjs().add(nYears, 'years').toDate()\n\n/**\n * Converts Excel serial number to Date\n * JavaScript dates can be constructed by passing milliseconds since Unix epoch\n */\nexport const excelToDate = (value: any) => {\n  try {\n    const d: number = Number(value)\n    if (d >= 18000 && d <= 300000) return new Date(Math.round((d - 25569) * 86400 * 1000))\n    return null\n  } catch (_err) {\n    return null\n  }\n}\n\n/**\n * Detects if a variable contains a valid date\n */\nexport const isDateTime = (value: any): boolean => {\n  try {\n    if (!value) return false\n    if (typeof value === 'number') return false\n    else if (typeof value === 'boolean') return false\n    else if (\n      typeof value === 'string' &&\n      !isValidISODateString(value) &&\n      !isValidDate(value) &&\n      !isValidDate(value, '')\n    )\n      return false\n    else if (typeof value === 'object' && !(value instanceof Date) && !dayjs.isDayjs(value))\n      return false\n    return dayjs(value).isValid()\n  } catch (_err) {\n    return false\n  }\n}\n\n/**\n * Compares dates by day\n */\nexport const isEqualsDateTimeByDay = (value1: any, value2: any): boolean => {\n  if (!isDateTime(value1)) return false\n  if (!isDateTime(value2)) return false\n  return dayjs(value1).isSame(dayjs(value2), 'day')\n}\n\n/**\n * Checks if a date has expired relative to current time\n */\nexport const isExpired = (value: any, valueRefOrNow: any = null): boolean => {\n  const v2 = !valueRefOrNow ? dayjs() : dayjs(valueRefOrNow)\n  if (isDateTime(value)) {\n    return v2.isAfter(value)\n  }\n  return true\n}\n\n/**\n * Formats date for MySQL database\n */\nexport const formatForMysql = (fecha: Date | null) => {\n  if (!fecha) return null\n  fecha.setMinutes(fecha.getMinutes() - fecha.getTimezoneOffset())\n  return fecha.toISOString().slice(0, 19).replace('T', ' ')\n}\n\n/**\n * Gets first workday of month\n */\nexport const getFirstWorkdayOfMonth = (month?: number) => {\n  const monthToUse = month === undefined ? dayjs().month() : month\n  let firstDay = dayjs().month(monthToUse).startOf('month')\n  while (firstDay.day() === 0 || firstDay.day() === 6) {\n    firstDay = firstDay.add(1, 'day')\n  }\n  return firstDay.toDate()\n}\n\n/**\n * Gets last workday of month\n */\nexport const getLastWorkdayOfMonth = (month?: number) => {\n  const monthToUse = month === undefined ? dayjs().month() : month\n  let lastDay = dayjs().month(monthToUse).endOf('month')\n  while (lastDay.day() === 0 || lastDay.day() === 6) {\n    lastDay = lastDay.subtract(1, 'day')\n  }\n  return lastDay.toDate()\n}\n\n/**\n * Gets first workday after adding specified months\n */\nexport const getFirstWorkdayAfterMonths = (initialDate: Date, n: number) => {\n  const startDate = dayjs(initialDate)\n  const monthsToAdd = n\n  const targetDate = startDate.add(monthsToAdd, 'months')\n\n  let firstWorkday = targetDate.startOf('month')\n  while (firstWorkday.day() === 0 || firstWorkday.day() === 6) {\n    firstWorkday = firstWorkday.add(1, 'day')\n  }\n  return firstWorkday.toDate()\n}\n\n/**\n * Gets first day of current year\n */\nexport const getFirstDayOfYear = () => dayjs().startOf('year').toDate()\n\n/**\n * Gets last day of current year\n */\nexport const getLastDayOfYear = () => dayjs().endOf('year').toDate()\n\n/**\n * Checks if date is a weekday (not Saturday or Sunday)\n */\nexport const isWeekday = (date: any) => {\n  const d = dayjs(date)\n  const dayOfWeek = d.day() // 0 = Sunday, 1 = Monday, ..., 6 = Saturday\n  return dayOfWeek !== 0 && dayOfWeek !== 6 // Exclude Saturdays and Sundays\n}\n"],"mappings":"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","names":["dayjs","utc","relativeTime","weekOfYearPlugin","customParseFormat","isSameOrAfter","isSameOrBefore","weekday","localeData","localizedFormat","format","dayOfWeek"]}