@futdevpro/fsm-dynamo 1.16.7 → 1.16.10

package/src/_collections/utils/string-case.util.ts

@@ -1,362 +1,362 @@
-/**
- * String casing típusok enum
- */
-export enum DyFM_StringCase_Type {
-  camelCase = 'camel-case',
-  PascalCase = 'pascal-case',
-  kebabCase = 'kebab-case',
-  snake_case = 'snake-case',
-}
-
-/**
- * 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: string): string[] {
-    if (!input || input.trim().length === 0) {
-      return [];
-    }
-
-    // Normalizálás: különböző separator-eket space-re cseréljük
-    const normalized: string = input
-      .replace(/[\s_\-]+/g, ' ')
-      .replace(/[^a-zA-Z0-9\s]/g, ' ')
-      .trim();
-
-    // Split by spaces first
-    const spaceSegments: string[] = normalized.split(/\s+/).filter((s: string): boolean => s.length > 0);
-    const allSegments: string[] = [];
-
-    // 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: number[] = [0]; // First character is always a word start
-      
-      for (let i = 1; i < segment.length; i++) {
-        const char: string = segment[i];
-        const prevChar: string = segment[i - 1];
-        const nextChar: string = i < segment.length - 1 ? segment[i + 1] : '';
-        
-        const isUppercase: boolean = /[A-Z]/.test(char);
-        const isLowercase: boolean = /[a-z]/.test(char);
-        const isLetter: boolean = /[a-zA-Z]/.test(char);
-        const isDigit: boolean = /[0-9]/.test(char);
-        const prevIsUppercase: boolean = /[A-Z]/.test(prevChar);
-        const prevIsLowercase: boolean = /[a-z]/.test(prevChar);
-        const prevIsDigit: boolean = /[0-9]/.test(prevChar);
-        const nextIsLowercase: boolean = /[a-z]/.test(nextChar);
-        const nextIsUppercase: boolean = /[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: number = 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: number = 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: boolean = 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: number = wordStarts[i];
-        const end: number = i < wordStarts.length - 1 ? wordStarts[i + 1] : segment.length;
-        const word: string = 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: string): string {
-    const words: string[] = this.parseWords(input);
-    if (words.length === 0) {
-      return '';
-    }
-
-    return words
-      .map((word: string, index: number): string => {
-        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: string): string {
-    const words: string[] = this.parseWords(input);
-    if (words.length === 0) {
-      return '';
-    }
-
-    return words
-      .map((word: string): string => 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: string): string {
-    const words: string[] = 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: string): string {
-    const words: string[] = 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: string, targetCase: DyFM_StringCase_Type): string {
-    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: string, targetCase: string): string {
-    const normalizedTarget: string = 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: string, needle: string): boolean {
-    if (!haystack || !needle) {
-      return false;
-    }
-
-    // Különböző casing formátumokban keresünk
-    const cases: string[] = [
-      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: string[] = 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: string = 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: string = 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: string): string {
-    if (!name || name.trim().length === 0) {
-      return '';
-    }
-
-    const words: string[] = this.parseWords(name);
-
-    // Extract first letter of each segment, uppercase, and join
-    return words
-      .filter((segment: string): boolean => segment.length > 0)
-      .map((segment: string): string => {
-        // Get first letter (handles cases where segment might start with non-letter)
-        const firstLetter: string | undefined = segment.match(/[a-zA-Z]/)?.[0];
-        return firstLetter ? firstLetter.toUpperCase() : '';
-      })
-      .join('');
-  }
-}
+/**
+ * String casing típusok enum
+ */
+export enum DyFM_StringCase_Type {
+  camelCase = 'camel-case',
+  PascalCase = 'pascal-case',
+  kebabCase = 'kebab-case',
+  snake_case = 'snake-case',
+}
+
+/**
+ * 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: string): string[] {
+    if (!input || input.trim().length === 0) {
+      return [];
+    }
+
+    // Normalizálás: különböző separator-eket space-re cseréljük
+    const normalized: string = input
+      .replace(/[\s_\-]+/g, ' ')
+      .replace(/[^a-zA-Z0-9\s]/g, ' ')
+      .trim();
+
+    // Split by spaces first
+    const spaceSegments: string[] = normalized.split(/\s+/).filter((s: string): boolean => s.length > 0);
+    const allSegments: string[] = [];
+
+    // 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: number[] = [0]; // First character is always a word start
+      
+      for (let i = 1; i < segment.length; i++) {
+        const char: string = segment[i];
+        const prevChar: string = segment[i - 1];
+        const nextChar: string = i < segment.length - 1 ? segment[i + 1] : '';
+        
+        const isUppercase: boolean = /[A-Z]/.test(char);
+        const isLowercase: boolean = /[a-z]/.test(char);
+        const isLetter: boolean = /[a-zA-Z]/.test(char);
+        const isDigit: boolean = /[0-9]/.test(char);
+        const prevIsUppercase: boolean = /[A-Z]/.test(prevChar);
+        const prevIsLowercase: boolean = /[a-z]/.test(prevChar);
+        const prevIsDigit: boolean = /[0-9]/.test(prevChar);
+        const nextIsLowercase: boolean = /[a-z]/.test(nextChar);
+        const nextIsUppercase: boolean = /[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: number = 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: number = 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: boolean = 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: number = wordStarts[i];
+        const end: number = i < wordStarts.length - 1 ? wordStarts[i + 1] : segment.length;
+        const word: string = 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: string): string {
+    const words: string[] = this.parseWords(input);
+    if (words.length === 0) {
+      return '';
+    }
+
+    return words
+      .map((word: string, index: number): string => {
+        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: string): string {
+    const words: string[] = this.parseWords(input);
+    if (words.length === 0) {
+      return '';
+    }
+
+    return words
+      .map((word: string): string => 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: string): string {
+    const words: string[] = 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: string): string {
+    const words: string[] = 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: string, targetCase: DyFM_StringCase_Type): string {
+    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: string, targetCase: string): string {
+    const normalizedTarget: string = 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: string, needle: string): boolean {
+    if (!haystack || !needle) {
+      return false;
+    }
+
+    // Különböző casing formátumokban keresünk
+    const cases: string[] = [
+      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: string[] = 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: string = 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: string = 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: string): string {
+    if (!name || name.trim().length === 0) {
+      return '';
+    }
+
+    const words: string[] = this.parseWords(name);
+
+    // Extract first letter of each segment, uppercase, and join
+    return words
+      .filter((segment: string): boolean => segment.length > 0)
+      .map((segment: string): string => {
+        // Get first letter (handles cases where segment might start with non-letter)
+        const firstLetter: string | undefined = segment.match(/[a-zA-Z]/)?.[0];
+        return firstLetter ? firstLetter.toUpperCase() : '';
+      })
+      .join('');
+  }
+}