@gzl10/ts-helpers 4.2.1

package/dist/types/strings.d.ts

@@ -0,0 +1 @@
+export { j as capitalizeEachWord, i as capitalizeFirst, c as cleanJsonChars, o as contains, C as countOccurrences, q as endsWith, e as ensureEndsWith, d as ensureStartsWith, K as envKeyToPath, H as escapeHtmlChars, E as isEmail, D as isEmpty, J as matchPathPattern, v as padEnd, r as padStart, L as pathToEnvKey, G as removeAccents, A as repeatString, B as replaceAllOccurrences, z as reverseString, a as sanitizeString, p as startsWith, b as stripFromEnd, f as stripFromStart, k as toCamelCase, m as toKebabCase, g as toLowerCase, n as toPascalCase, l as toSnakeCase, h as toUpperCase, F as toUrlSlug, w as trim, y as trimEnd, x as trimStart, t as truncateString, I as unescapeHtmlChars, u as unescapeUnicode } from './strings-CiqRPYLL.js';

package/dist/types/tree.d.ts

@@ -0,0 +1,284 @@
+/**
+ * Tree Structure Rendering Utilities
+ *
+ * Provides ASCII/Unicode tree visualization for hierarchical data structures.
+ * Features:
+ * - Customizable box-drawing characters (Unicode or ASCII)
+ * - Flexible label extraction (field name or custom function)
+ * - Recursive rendering with proper indentation
+ * - Multiple root support
+ * - Zero dependencies
+ *
+ * @module tree
+ */
+/**
+ * Configuration options for tree rendering
+ *
+ * Controls the visual appearance and label extraction strategy for ASCII/Unicode tree output.
+ * All options have sensible defaults for immediate use with Unicode box-drawing characters.
+ *
+ * @property labelField - Object property name to use as node label (default: 'name')
+ * @property verticalLine - Character sequence for vertical continuation (default: '│   ')
+ * @property middleBranch - Character sequence for non-last child branch (default: '├── ')
+ * @property lastBranch - Character sequence for last child branch (default: '└── ')
+ * @property emptySpace - Character sequence for empty space after last branch (default: '    ')
+ * @property labelFunction - Custom function to extract/format node labels (overrides labelField)
+ *
+ * @example
+ * ```typescript
+ * // Unicode box-drawing (default)
+ * const unicodeOptions: TreeExportOptions = {
+ *   labelField: 'name',
+ *   verticalLine: '│   ',
+ *   middleBranch: '├── ',
+ *   lastBranch: '└── ',
+ *   emptySpace: '    '
+ * }
+ *
+ * // ASCII alternative (better compatibility)
+ * const asciiOptions: TreeExportOptions = {
+ *   verticalLine: '|   ',
+ *   middleBranch: '+-- ',
+ *   lastBranch: '`-- ',
+ *   emptySpace: '    '
+ * }
+ *
+ * // Custom label function
+ * const customOptions: TreeExportOptions = {
+ *   labelFunction: (node) => `${node.type}: ${node.name} (${node.size})`
+ * }
+ * ```
+ */
+interface TreeExportOptions {
+    labelField?: string;
+    verticalLine?: string;
+    middleBranch?: string;
+    lastBranch?: string;
+    emptySpace?: string;
+    labelFunction?: (node: any) => string;
+}
+/**
+ * Renders hierarchical data as ASCII/Unicode tree visualization
+ *
+ * Converts nested object structures (with `children` arrays) into human-readable tree diagrams.
+ * Supports multiple root nodes and customizable rendering styles.
+ *
+ * Features:
+ * - **Recursive rendering**: Handles arbitrary depth
+ * - **Unicode box-drawing**: Beautiful output by default (│ ├ └)
+ * - **ASCII fallback**: Use simpler characters for compatibility
+ * - **Flexible labels**: Extract from field name or custom function
+ * - **Multiple roots**: Render forests (arrays of trees)
+ *
+ * Node Structure Requirements:
+ * - Each node must have a label (via `labelField` property or `labelFunction`)
+ * - Child nodes stored in `children` array property
+ * - No `children` property = leaf node
+ *
+ * @param data - Array of root nodes (each with optional `children` property)
+ * @param options - Rendering options (characters, label extraction)
+ * @returns String containing the complete tree visualization with newlines
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - Simple file tree
+ * const fileTree = [
+ *   {
+ *     name: 'src',
+ *     children: [
+ *       { name: 'index.ts' },
+ *       { name: 'utils.ts' },
+ *       {
+ *         name: 'components',
+ *         children: [
+ *           { name: 'Button.tsx' },
+ *           { name: 'Input.tsx' }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * ]
+ *
+ * console.log(renderTreeAsText(fileTree))
+ * // Output:
+ * // └── src
+ * //     ├── index.ts
+ * //     ├── utils.ts
+ * //     └── components
+ * //         ├── Button.tsx
+ * //         └── Input.tsx
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple roots - Project structure
+ * const projectTree = [
+ *   {
+ *     name: 'packages',
+ *     children: [
+ *       { name: 'core' },
+ *       { name: 'ui' }
+ *     ]
+ *   },
+ *   {
+ *     name: 'apps',
+ *     children: [
+ *       { name: 'web' },
+ *       { name: 'mobile' }
+ *     ]
+ *   }
+ * ]
+ *
+ * console.log(renderTreeAsText(projectTree))
+ * // Output:
+ * // ├── packages
+ * // │   ├── core
+ * // │   └── ui
+ * // └── apps
+ * //     ├── web
+ * //     └── mobile
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom label field - Organization chart
+ * const orgChart = [
+ *   {
+ *     title: 'CEO',
+ *     children: [
+ *       {
+ *         title: 'CTO',
+ *         children: [
+ *           { title: 'Dev Lead' },
+ *           { title: 'QA Lead' }
+ *         ]
+ *       },
+ *       { title: 'CFO' }
+ *     ]
+ *   }
+ * ]
+ *
+ * console.log(renderTreeAsText(orgChart, { labelField: 'title' }))
+ * // Output:
+ * // └── CEO
+ * //     ├── CTO
+ * //     │   ├── Dev Lead
+ * //     │   └── QA Lead
+ * //     └── CFO
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom label function - Rich formatting
+ * const tasks = [
+ *   {
+ *     name: 'Backend',
+ *     status: 'in-progress',
+ *     assignee: 'Alice',
+ *     children: [
+ *       { name: 'API', status: 'done', assignee: 'Bob' },
+ *       { name: 'Database', status: 'pending', assignee: 'Charlie' }
+ *     ]
+ *   }
+ * ]
+ *
+ * const rendered = renderTreeAsText(tasks, {
+ *   labelFunction: (node) => `[${node.status}] ${node.name} (@${node.assignee})`
+ * })
+ *
+ * console.log(rendered)
+ * // Output:
+ * // └── [in-progress] Backend (@Alice)
+ * //     ├── [done] API (@Bob)
+ * //     └── [pending] Database (@Charlie)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // ASCII characters - Better terminal compatibility
+ * const tree = [
+ *   {
+ *     name: 'root',
+ *     children: [
+ *       { name: 'child1' },
+ *       { name: 'child2' }
+ *     ]
+ *   }
+ * ]
+ *
+ * console.log(renderTreeAsText(tree, {
+ *   verticalLine: '|   ',
+ *   middleBranch: '+-- ',
+ *   lastBranch: '`-- ',
+ *   emptySpace: '    '
+ * }))
+ * // Output:
+ * // `-- root
+ * //     +-- child1
+ * //     `-- child2
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Real-world: File system visualization
+ * async function visualizeDirectory(dirPath: string) {
+ *   const tree = await buildDirectoryTree(dirPath)
+ *
+ *   console.log(`Directory structure of ${dirPath}:`)
+ *   console.log(renderTreeAsText(tree, {
+ *     labelFunction: (node) => {
+ *       const icon = node.type === 'dir' ? '📁' : '📄'
+ *       return `${icon} ${node.name}`
+ *     }
+ *   }))
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Real-world: Dependency tree analysis
+ * function visualizeDependencies(packageName: string) {
+ *   const deps = analyzeDependencies(packageName)
+ *
+ *   console.log(`Dependencies of ${packageName}:`)
+ *   console.log(renderTreeAsText(deps, {
+ *     labelFunction: (node) => `${node.name}@${node.version} (${node.size})`
+ *   }))
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Edge case: Empty tree
+ * console.log(renderTreeAsText([]))  // Returns empty string
+ *
+ * // Edge case: Leaf nodes only
+ * const leaves = [{ name: 'item1' }, { name: 'item2' }]
+ * console.log(renderTreeAsText(leaves))
+ * // Output:
+ * // ├── item1
+ * // └── item2
+ *
+ * // Edge case: Deep nesting
+ * const deep = [
+ *   {
+ *     name: 'level1',
+ *     children: [
+ *       {
+ *         name: 'level2',
+ *         children: [
+ *           { name: 'level3' }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * ]
+ * console.log(renderTreeAsText(deep))
+ * // Handles arbitrary depth correctly
+ * ```
+ *
+ * @see {@link TreeExportOptions} for configuration details
+ */
+declare function renderTreeAsText(data: any[], options?: TreeExportOptions): string;
+
+export { type TreeExportOptions, renderTreeAsText };

package/dist/types/validation-core-DfHF8rCG.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Core validation utilities - Universal (Browser + Node.js compatible)
+ * NO crypto dependencies - safe for all environments
+ */
+/**
+ * Generates a random integer between min and max (inclusive)
+ * @param min - Minimum value (default: 0)
+ * @param max - Maximum value (default: 100)
+ * @returns Random integer between min and max
+ * @example
+ * ```ts
+ * const dice = generateRandomInteger(1, 6) // 1, 2, 3, 4, 5, or 6
+ * const percent = generateRandomInteger(0, 100) // 0 to 100
+ * const id = generateRandomInteger(1000, 9999) // 4-digit ID
+ * ```
+ */
+declare const generateRandomInteger: (min?: number, max?: number) => number;
+/**
+ * Generates a random alphabetic string (letters only)
+ * @param options - Configuration object
+ * @param options.length - Length of the string (default: 10)
+ * @param options.casing - Case transformation: 'upper', 'lower', or undefined
+ * @returns Random alphabetic string
+ * @example
+ * ```ts
+ * const name = generateAlphaString({ length: 8 }) // "AbCdEfGh"
+ * const upper = generateAlphaString({ length: 5, casing: 'upper' }) // "ABCDE"
+ * const lower = generateAlphaString({ length: 3, casing: 'lower' }) // "abc"
+ * ```
+ */
+declare const generateAlphaString: (options?: {
+    length?: number;
+    casing?: "upper" | "lower" | undefined;
+}) => string;
+/**
+ * Generates a random alphanumeric string (letters and numbers)
+ * @param options - Configuration object
+ * @param options.length - Length of the string (default: 10)
+ * @param options.casing - Case transformation: 'upper', 'lower', or undefined
+ * @returns Random alphanumeric string
+ * @example
+ * ```ts
+ * const token = generateAlphaNumericString({ length: 12 }) // "aB3cD4eF5gH6"
+ * const code = generateAlphaNumericString({ length: 6, casing: 'upper' }) // "A1B2C3"
+ * const key = generateAlphaNumericString({ length: 8, casing: 'lower' }) // "a1b2c3d4"
+ * ```
+ */
+declare const generateAlphaNumericString: (options?: {
+    length?: number;
+    casing?: "upper" | "lower" | undefined;
+}) => string;
+/**
+ * Generates a random complex string with all characters (letters, numbers, symbols)
+ * @param options - Configuration object
+ * @param options.length - Length of the string (default: 10)
+ * @param options.casing - Case transformation (currently not applied to symbols)
+ * @returns Random complex string
+ * @example
+ * ```ts
+ * const password = generateComplexString({ length: 16 }) // "aB3#cD4$eF5%gH6"
+ * const secret = generateComplexString({ length: 32 }) // Complex 32-char string
+ * const temp = generateComplexString() // 10 characters by default
+ * ```
+ */
+declare const generateComplexString: (options?: {
+    length?: number;
+    casing?: "upper" | "lower" | undefined;
+}) => string;
+/**
+ * Generates a username from an email address
+ * @param email - Email address to extract username from
+ * @param randomDigits - Number of random digits to append (default: 1)
+ * @returns Username derived from email with random suffix
+ * @example
+ * ```ts
+ * const user1 = generateUsernameFromEmail('john.doe@example.com', 2) // "johndoe47"
+ * const user2 = generateUsernameFromEmail('maria-garcia@test.org', 3) // "mariagarcia823"
+ * const fallback = generateUsernameFromEmail('invalid-email', 2) // "user42"
+ * ```
+ */
+declare const generateUsernameFromEmail: (email: string, randomDigits?: number) => string;
+/**
+ * Generates a random username with adjective + noun pattern
+ * @param separator - Character to separate adjective and noun (default: '')
+ * @param randomDigits - Number of random digits to append (default: 1)
+ * @param length - Maximum length of username (default: 8)
+ * @returns Random username like "coolcat5" or "brave_wolf3"
+ * @example
+ * ```ts
+ * const user1 = generateUsername() // "coolcat5"
+ * const user2 = generateUsername('_', 2) // "brave_wolf83"
+ * const user3 = generateUsername('-', 3, 15) // "smart-eagle247"
+ * ```
+ */
+declare const generateUsername: (separator?: string, randomDigits?: number, length?: number) => string;
+/**
+ * Generates a valid Spanish NIF (Número de Identificación Fiscal)
+ * @returns A valid NIF string in format '12345678Z'
+ * @example
+ * ```ts
+ * const nif1 = generateSpanishNIF() // "87654321T"
+ * const nif2 = generateSpanishNIF() // "12345678Z"
+ *
+ * // Verify it's valid
+ * const nif = generateSpanishNIF()
+ * console.log(validateNIF(nif)) // true
+ * ```
+ */
+declare const generateSpanishNIF: () => string;
+/**
+ * Generates a valid Spanish NIE (Número de Identidad de Extranjero)
+ * @returns A valid NIE string in format 'X1234567L'
+ * @example
+ * ```ts
+ * const nie1 = generateSpanishNIE() // "X1234567L"
+ * const nie2 = generateSpanishNIE() // "Y9876543R"
+ * const nie3 = generateSpanishNIE() // "Z2468135T"
+ *
+ * // Verify it's valid
+ * const nie = generateSpanishNIE()
+ * console.log(isValidNIE(nie)) // true
+ * ```
+ */
+declare const generateSpanishNIE: () => string;
+/**
+ * Generates a valid Spanish CIF (Código de Identificación Fiscal)
+ * @returns A valid CIF string in format 'A12345674' or 'B87654321'
+ * @example
+ * ```ts
+ * const cif1 = generateSpanishCIF() // "A12345674"
+ * const cif2 = generateSpanishCIF() // "B87654321"
+ * const cif3 = generateSpanishCIF() // "G28456789"
+ *
+ * // Verify it's valid
+ * const cif = generateSpanishCIF()
+ * console.log(isValidCIF(cif)) // true
+ *
+ * // Different organization types
+ * // A,B,E,H = Sociedades Anónimas/Limitadas
+ * // G,U = Fundaciones, asociaciones
+ * // N,P,Q,R,S,W = Organismos públicos
+ * ```
+ */
+declare const generateSpanishCIF: () => string;
+declare const generateSpanishPostalCode: () => string;
+declare const generateSpanishIBAN: () => string;
+declare const generateEmail: (domain?: string) => string;
+declare const generatePassword: (options?: {
+    length?: number;
+    includeUppercase?: boolean;
+    includeLowercase?: boolean;
+    includeNumbers?: boolean;
+    includeSymbols?: boolean;
+}) => string;
+declare const generateHexColor: (shortFormat?: boolean) => string;
+/**
+ * Validates a Spanish NIF (Número de Identificación Fiscal)
+ * @param nif - The NIF string to validate
+ * @returns true if the NIF is valid, false otherwise
+ * @example
+ * ```ts
+ * console.log(isValidNIF('12345678Z')) // true
+ * console.log(isValidNIF('87654321T')) // true
+ * console.log(isValidNIF('12345678A')) // false (wrong letter)
+ * console.log(isValidNIF('1234567Z'))  // false (wrong length)
+ * console.log(isValidNIF(''))          // false (empty)
+ *
+ * // Case insensitive and handles whitespace
+ * console.log(isValidNIF('  12345678z  ')) // true
+ * ```
+ */
+declare const isValidNIF: (nif: string) => boolean;
+/**
+ * Alias for isValidNIF - validates a Spanish NIF
+ * @param nif - The NIF string to validate
+ * @returns true if the NIF is valid, false otherwise
+ * @example
+ * ```ts
+ * console.log(validateNIF('12345678Z')) // true
+ * // Same functionality as isValidNIF
+ * ```
+ */
+declare const validateNIF: (nif: string) => boolean;
+/**
+ * Validates a Spanish NIE (Número de Identidad de Extranjero)
+ * @param nie - The NIE string to validate
+ * @returns true if the NIE is valid, false otherwise
+ * @example
+ * ```ts
+ * console.log(isValidNIE('X1234567L')) // true
+ * console.log(isValidNIE('Y9876543R')) // true
+ * console.log(isValidNIE('Z2468135T')) // true
+ * console.log(isValidNIE('X1234567A')) // false (wrong letter)
+ * console.log(isValidNIE('W1234567L')) // false (invalid prefix)
+ * console.log(isValidNIE('X123456L'))  // false (wrong length)
+ *
+ * // Case insensitive and handles whitespace
+ * console.log(isValidNIE('  x1234567l  ')) // true
+ * ```
+ */
+declare const isValidNIE: (nie: string) => boolean;
+declare const isValidCIF: (cif: string) => boolean;
+declare const isValidSpanishPostalCode: (postalCode: string) => boolean;
+declare const isValidSpanishPhone: (phone: string) => boolean;
+declare const isValidEmail: (email: string) => boolean;
+declare const isValidURL: (url: string) => boolean;
+declare const isValidJSON: (str: string) => boolean;
+declare const isValidSpanishIBAN: (iban: string) => boolean;
+
+declare const validationCore_generateAlphaNumericString: typeof generateAlphaNumericString;
+declare const validationCore_generateAlphaString: typeof generateAlphaString;
+declare const validationCore_generateComplexString: typeof generateComplexString;
+declare const validationCore_generateEmail: typeof generateEmail;
+declare const validationCore_generateHexColor: typeof generateHexColor;
+declare const validationCore_generatePassword: typeof generatePassword;
+declare const validationCore_generateRandomInteger: typeof generateRandomInteger;
+declare const validationCore_generateSpanishCIF: typeof generateSpanishCIF;
+declare const validationCore_generateSpanishIBAN: typeof generateSpanishIBAN;
+declare const validationCore_generateSpanishNIE: typeof generateSpanishNIE;
+declare const validationCore_generateSpanishNIF: typeof generateSpanishNIF;
+declare const validationCore_generateSpanishPostalCode: typeof generateSpanishPostalCode;
+declare const validationCore_generateUsername: typeof generateUsername;
+declare const validationCore_generateUsernameFromEmail: typeof generateUsernameFromEmail;
+declare const validationCore_isValidCIF: typeof isValidCIF;
+declare const validationCore_isValidEmail: typeof isValidEmail;
+declare const validationCore_isValidJSON: typeof isValidJSON;
+declare const validationCore_isValidNIE: typeof isValidNIE;
+declare const validationCore_isValidNIF: typeof isValidNIF;
+declare const validationCore_isValidSpanishIBAN: typeof isValidSpanishIBAN;
+declare const validationCore_isValidSpanishPhone: typeof isValidSpanishPhone;
+declare const validationCore_isValidSpanishPostalCode: typeof isValidSpanishPostalCode;
+declare const validationCore_isValidURL: typeof isValidURL;
+declare const validationCore_validateNIF: typeof validateNIF;
+declare namespace validationCore {
+  export { validationCore_generateAlphaNumericString as generateAlphaNumericString, validationCore_generateAlphaString as generateAlphaString, validationCore_generateComplexString as generateComplexString, validationCore_generateEmail as generateEmail, validationCore_generateHexColor as generateHexColor, validationCore_generatePassword as generatePassword, validationCore_generateRandomInteger as generateRandomInteger, validationCore_generateSpanishCIF as generateSpanishCIF, validationCore_generateSpanishIBAN as generateSpanishIBAN, validationCore_generateSpanishNIE as generateSpanishNIE, validationCore_generateSpanishNIF as generateSpanishNIF, validationCore_generateSpanishPostalCode as generateSpanishPostalCode, validationCore_generateUsername as generateUsername, validationCore_generateUsernameFromEmail as generateUsernameFromEmail, validationCore_isValidCIF as isValidCIF, validationCore_isValidEmail as isValidEmail, validationCore_isValidJSON as isValidJSON, validationCore_isValidNIE as isValidNIE, validationCore_isValidNIF as isValidNIF, validationCore_isValidSpanishIBAN as isValidSpanishIBAN, validationCore_isValidSpanishPhone as isValidSpanishPhone, validationCore_isValidSpanishPostalCode as isValidSpanishPostalCode, validationCore_isValidURL as isValidURL, validationCore_validateNIF as validateNIF };
+}
+
+export { generateAlphaString as a, generateAlphaNumericString as b, generateComplexString as c, generateUsernameFromEmail as d, generateUsername as e, generateSpanishNIF as f, generateRandomInteger as g, generateSpanishNIE as h, generateSpanishCIF as i, generateSpanishPostalCode as j, generateSpanishIBAN as k, generateEmail as l, generatePassword as m, generateHexColor as n, isValidNIF as o, validateNIF as p, isValidNIE as q, isValidCIF as r, isValidSpanishPostalCode as s, isValidSpanishPhone as t, isValidEmail as u, validationCore as v, isValidURL as w, isValidJSON as x, isValidSpanishIBAN as y };

package/dist/types/validation-crypto-browser.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Browser-specific validation utilities with Web Crypto API support
+ * Safe for browser environments - uses crypto.getRandomValues() and SubtleCrypto
+ */
+interface PasswordCriteria {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+    maxLength?: number;
+    forbiddenPatterns?: string[];
+}
+interface PasswordValidationResult {
+    isValid: boolean;
+    errors: string[];
+    strength: 'weak' | 'fair' | 'good' | 'strong';
+    score: number;
+}
+declare const validatePassword: (password: string, criteria?: PasswordCriteria) => PasswordValidationResult;
+declare const sanitizeHtml: (html: string) => string;
+declare const isValidJWTFormat: (token: string) => boolean;
+/**
+ * Browser-safe hash function with environment detection
+ * Attempts Web Crypto API first, falls back to simple hash
+ */
+declare const hashString: (input: string, salt?: string) => Promise<string>;
+/**
+ * Synchronous version of hashString for backward compatibility
+ */
+declare const hashStringSync: (input: string, salt?: string) => string;
+/**
+ * Browser-safe secure token generation with comprehensive environment checks
+ * Uses Web Crypto API when available, falls back to Node.js crypto, then Math.random
+ * @param length - Length of the token in characters (default: 32)
+ * @returns A secure hexadecimal token string
+ * @example
+ * ```ts
+ * const token = generateSecureToken(16)
+ * console.log(token) // "a1b2c3d4e5f67890"
+ *
+ * const shortToken = generateSecureToken(8)
+ * console.log(shortToken) // "a1b2c3d4"
+ * ```
+ */
+declare const generateSecureToken: (length?: number) => string;
+declare const isValidBase64: (input: string) => boolean;
+declare const escapeShellCommand: (input: string) => string;
+declare const isSecureUrl: (url: string) => boolean;
+declare const removeDangerousChars: (input: string, replacement?: string) => string;
+/**
+ * Browser-safe nonce generation with comprehensive environment detection
+ */
+declare const generateNonce: (length?: number) => string;
+
+export { type PasswordCriteria, type PasswordValidationResult, escapeShellCommand, generateNonce, generateSecureToken, hashString, hashStringSync, isSecureUrl, isValidBase64, isValidJWTFormat, removeDangerousChars, sanitizeHtml, validatePassword };

package/dist/types/validation-crypto-node.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Node.js-specific validation utilities with crypto support
+ * Uses Node.js crypto module for secure operations
+ */
+interface PasswordCriteria {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+    maxLength?: number;
+    forbiddenPatterns?: string[];
+}
+interface PasswordValidationResult {
+    isValid: boolean;
+    errors: string[];
+    strength: 'weak' | 'fair' | 'good' | 'strong';
+    score: number;
+}
+declare const validatePassword: (password: string, criteria?: PasswordCriteria) => PasswordValidationResult;
+declare const sanitizeHtml: (html: string) => string;
+declare const isValidJWTFormat: (token: string) => boolean;
+declare const hashString: (input: string, salt?: string) => string;
+declare const generateSecureToken: (length?: number) => string;
+declare const isValidBase64: (input: string) => boolean;
+declare const escapeShellCommand: (input: string) => string;
+declare const isSecureUrl: (url: string) => boolean;
+declare const removeDangerousChars: (input: string, replacement?: string) => string;
+declare const generateNonce: (length?: number) => string;
+
+export { type PasswordCriteria, type PasswordValidationResult, escapeShellCommand, generateNonce, generateSecureToken, hashString, isSecureUrl, isValidBase64, isValidJWTFormat, removeDangerousChars, sanitizeHtml, validatePassword };

package/dist/types/validation.d.ts

@@ -0,0 +1 @@
+export { b as generateAlphaNumericString, a as generateAlphaString, c as generateComplexString, l as generateEmail, n as generateHexColor, m as generatePassword, g as generateRandomInteger, i as generateSpanishCIF, k as generateSpanishIBAN, h as generateSpanishNIE, f as generateSpanishNIF, j as generateSpanishPostalCode, e as generateUsername, d as generateUsernameFromEmail, r as isValidCIF, u as isValidEmail, x as isValidJSON, q as isValidNIE, o as isValidNIF, y as isValidSpanishIBAN, t as isValidSpanishPhone, s as isValidSpanishPostalCode, w as isValidURL, p as validateNIF } from './validation-core-DfHF8rCG.js';