@futdevpro/fsm-dynamo 1.20.88 → 1.20.93

package/build-esm/_collections/utils/string-case.util.js

@@ -0,0 +1,332 @@
+/**
+ * String casing típusok enum
+ */
+export var DyFM_StringCase_Type;
+(function (DyFM_StringCase_Type) {
+    DyFM_StringCase_Type["camelCase"] = "camel-case";
+    DyFM_StringCase_Type["PascalCase"] = "pascal-case";
+    DyFM_StringCase_Type["kebabCase"] = "kebab-case";
+    DyFM_StringCase_Type["snake_case"] = "snake-case";
+})(DyFM_StringCase_Type || (DyFM_StringCase_Type = {}));
+/**
+ * String casing utility class
+ * Támogatja a különböző casing típusok közötti konverziót
+ */
+export class DyFM_StringCase {
+    /**
+     * Bármilyen casing-ből szavak tömbjét generálja
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @returns Szavak tömbje kisbetűvel
+     *
+     * @example
+     * ```ts
+     * const words = DyFM_StringCase.parseWords('stockItemId');
+     * // Output: ['stock', 'item', 'id']
+     * ```
+     */
+    static parseWords(input) {
+        if (!input || input.trim().length === 0) {
+            return [];
+        }
+        // Normalizálás: különböző separator-eket space-re cseréljük
+        const normalized = input
+            .replace(/[\s_\-]+/g, ' ')
+            .replace(/[^a-zA-Z0-9\s]/g, ' ')
+            .trim();
+        // Split by spaces first
+        const spaceSegments = normalized.split(/\s+/).filter((s) => s.length > 0);
+        const allSegments = [];
+        // Process each space-separated segment to detect camelCase and acronyms
+        for (const segment of spaceSegments) {
+            if (segment.length === 0) {
+                continue;
+            }
+            // Track word boundaries: start of each word
+            const wordStarts = [0]; // First character is always a word start
+            for (let i = 1; i < segment.length; i++) {
+                const char = segment[i];
+                const prevChar = segment[i - 1];
+                const nextChar = i < segment.length - 1 ? segment[i + 1] : '';
+                const isUppercase = /[A-Z]/.test(char);
+                const isLowercase = /[a-z]/.test(char);
+                const isLetter = /[a-zA-Z]/.test(char);
+                const isDigit = /[0-9]/.test(char);
+                const prevIsUppercase = /[A-Z]/.test(prevChar);
+                const prevIsLowercase = /[a-z]/.test(prevChar);
+                const prevIsDigit = /[0-9]/.test(prevChar);
+                const nextIsLowercase = /[a-z]/.test(nextChar);
+                const nextIsUppercase = /[A-Z]/.test(nextChar);
+                // Number followed by letter: new word start
+                // This handles: john2Doe -> john, 2, Doe
+                if (prevIsDigit && isLetter) {
+                    wordStarts.push(i);
+                }
+                // camelCase boundary: lowercase followed by uppercase
+                else if (prevIsLowercase && isUppercase) {
+                    wordStarts.push(i);
+                }
+                // Uppercase followed by uppercase then lowercase: new word start
+                // This handles:
+                // - XMLParser -> XML (acronym ends at L, Parser starts at P) when previous is acronym (multiple uppercase)
+                // - AVery -> A (single letter) + Very (starts at V) when previous is single uppercase
+                // Pattern: ...X Y z... where X and Y are uppercase, z is lowercase
+                else if (isUppercase && prevIsUppercase && nextIsLowercase) {
+                    // Check if previous characters form an acronym (multiple consecutive uppercase) or single uppercase
+                    let acronymStart = i - 1;
+                    while (acronymStart > 0 && /[A-Z]/.test(segment[acronymStart - 1])) {
+                        acronymStart--;
+                    }
+                    // If we have multiple uppercase before this (acronym) OR single uppercase, the new word starts at this uppercase character
+                    if (i - acronymStart >= 1) {
+                        wordStarts.push(i);
+                    }
+                }
+                // Acronym boundary: uppercase sequence followed by lowercase
+                // This handles HTMLDocument -> HTML (acronym) + Document (new word starts at D, not at o)
+                // Pattern: ...L D o... where L is last of acronym, D is start of new word, o is lowercase
+                else if (prevIsUppercase && isLowercase) {
+                    // Check if previous characters form an acronym
+                    let acronymStart = i - 1;
+                    while (acronymStart > 0 && /[A-Z]/.test(segment[acronymStart - 1])) {
+                        acronymStart--;
+                    }
+                    // If we have multiple uppercase before this (acronym), the new word starts at the previous uppercase
+                    // But only if the previous uppercase wasn't already a word start
+                    if (i - acronymStart > 1) {
+                        // Check if the previous uppercase (i-1) is already a word start
+                        const prevIsWordStart = wordStarts.includes(i - 1);
+                        if (!prevIsWordStart) {
+                            // The new word starts at the previous uppercase character (i-1), not at this lowercase
+                            wordStarts.push(i - 1);
+                        }
+                    }
+                }
+            }
+            // Extract words based on word starts
+            for (let i = 0; i < wordStarts.length; i++) {
+                const start = wordStarts[i];
+                const end = i < wordStarts.length - 1 ? wordStarts[i + 1] : segment.length;
+                const word = segment.substring(start, end);
+                if (word.length > 0) {
+                    allSegments.push(word.toLowerCase());
+                }
+            }
+        }
+        return allSegments;
+    }
+    /**
+     * Bármilyen casing-ből camelCase-re konvertál
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @returns camelCase string
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.toCamelCase('stock-item-id');
+     * // Output: 'stockItemId'
+     * ```
+     */
+    static toCamelCase(input) {
+        const words = this.parseWords(input);
+        if (words.length === 0) {
+            return '';
+        }
+        return words
+            .map((word, index) => {
+            if (index === 0) {
+                return word.toLowerCase();
+            }
+            return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+        })
+            .join('');
+    }
+    /**
+     * Bármilyen casing-ből PascalCase-re konvertál
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @returns PascalCase string
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.toPascalCase('stock-item-id');
+     * // Output: 'StockItemId'
+     * ```
+     */
+    static toPascalCase(input) {
+        const words = this.parseWords(input);
+        if (words.length === 0) {
+            return '';
+        }
+        return words
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+    /**
+     * Bármilyen casing-ből kebab-case-re konvertál
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @returns kebab-case string
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.toKebabCase('stockItemId');
+     * // Output: 'stock-item-id'
+     * ```
+     */
+    static toKebabCase(input) {
+        const words = this.parseWords(input);
+        if (words.length === 0) {
+            return '';
+        }
+        return words.join('-');
+    }
+    /**
+     * Bármilyen casing-ből snake_case-re konvertál
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @returns snake_case string
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.toSnakeCase('stockItemId');
+     * // Output: 'stock_item_id'
+     * ```
+     */
+    static toSnakeCase(input) {
+        const words = this.parseWords(input);
+        if (words.length === 0) {
+            return '';
+        }
+        return words.join('_');
+    }
+    /**
+     * Bármilyen casing-ből bármilyen más casing-re konvertál
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @param targetCase - A cél casing típus
+     * @returns A konvertált string a megadott casing formátumban
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.convertTo('stockItemId', DyFM_StringCase_Type.kebabCase);
+     * // Output: 'stock-item-id'
+     * ```
+     */
+    static convertTo(input, targetCase) {
+        switch (targetCase) {
+            case DyFM_StringCase_Type.camelCase:
+                return this.toCamelCase(input);
+            case DyFM_StringCase_Type.PascalCase:
+                return this.toPascalCase(input);
+            case DyFM_StringCase_Type.kebabCase:
+                return this.toKebabCase(input);
+            case DyFM_StringCase_Type.snake_case:
+                return this.toSnakeCase(input);
+            default:
+                return input;
+        }
+    }
+    /**
+     * Bármilyen casing-ből bármilyen más casing-re konvertál (típus nélküli verzió)
+     * @param input - A bemeneti string bármilyen casing formátumban
+     * @param targetCase - A cél casing típus string formátumban
+     * @returns A konvertált string a megadott casing formátumban
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.convertToAny('stockItemId', 'kebab-case');
+     * // Output: 'stock-item-id'
+     * ```
+     */
+    static convertToAny(input, targetCase) {
+        const normalizedTarget = targetCase.toLowerCase().trim();
+        if (normalizedTarget === 'camelcase' || normalizedTarget === 'camel-case') {
+            return this.toCamelCase(input);
+        }
+        if (normalizedTarget === 'pascalcase' || normalizedTarget === 'pascal-case') {
+            return this.toPascalCase(input);
+        }
+        if (normalizedTarget === 'kebabcase' || normalizedTarget === 'kebab-case') {
+            return this.toKebabCase(input);
+        }
+        if (normalizedTarget === 'snakecase' || normalizedTarget === 'snake-case' || normalizedTarget === 'snake_case') {
+            return this.toSnakeCase(input);
+        }
+        // Ha nem ismert típus, visszaadja az eredeti stringet
+        return input;
+    }
+    /**
+     * Ellenőrzi, hogy egy string tartalmazza-e egy másik stringet bármilyen casing formátumban
+     * @param haystack - A string, amiben keresünk
+     * @param needle - A string, amit keresünk (bármilyen casing formátumban)
+     * @returns true, ha a haystack tartalmazza a needle-t bármilyen casing formátumban
+     *
+     * @example
+     * ```ts
+     * const result = DyFM_StringCase.includesIgnoreCase('/:userId/item/delete/:itemId', 'stockItemId');
+     * // Output: true (mert 'itemId' megtalálható)
+     * ```
+     */
+    static includesIgnoreCase(haystack, needle) {
+        if (!haystack || !needle) {
+            return false;
+        }
+        // Különböző casing formátumokban keresünk
+        const cases = [
+            needle,
+            this.toCamelCase(needle),
+            this.toPascalCase(needle),
+            this.toKebabCase(needle),
+            this.toSnakeCase(needle),
+        ];
+        // Különböző variációk: pl. stockItemId -> itemId, stock-item-id -> item-id, stb.
+        const words = this.parseWords(needle);
+        if (words.length > 1) {
+            // Hozzáadunk rövidített verziókat is (pl. stockItemId -> itemId)
+            for (let i = 1; i < words.length; i++) {
+                const suffix = words.slice(i).join('');
+                cases.push(this.toCamelCase(suffix));
+                cases.push(this.toKebabCase(suffix));
+                cases.push(this.toSnakeCase(suffix));
+            }
+        }
+        // Ellenőrizzük, hogy a haystack tartalmazza-e bármelyik variációt
+        const lowerHaystack = haystack.toLowerCase();
+        for (const caseVariant of cases) {
+            if (caseVariant && lowerHaystack.includes(caseVariant.toLowerCase())) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Converts any name to a short code
+     * @param name - The name to convert
+     * @returns The short code
+     * examples:
+     * John Doe -> JD
+     * JohnDoe -> JD
+     * John_Doe -> JD
+     * johnDoe -> JD
+     * john_doe -> JD
+     * john-doe -> JD
+     *
+     * @example
+     * ```ts
+     * const name = 'John Doe';
+     * const shortCode = DyFM_StringCase.anyNameToShortCode(name);
+     * console.log(shortCode);
+     * // Output: 'JD'
+     * ```
+     */
+    static anyNameToShortCode(name) {
+        if (!name || name.trim().length === 0) {
+            return '';
+        }
+        const words = this.parseWords(name);
+        // Extract first letter of each segment, uppercase, and join
+        return words
+            .filter((segment) => segment.length > 0)
+            .map((segment) => {
+            // Get first letter (handles cases where segment might start with non-letter)
+            const firstLetter = segment.match(/[a-zA-Z]/)?.[0];
+            return firstLetter ? firstLetter.toUpperCase() : '';
+        })
+            .join('');
+    }
+}