valtech-components 2.0.277 → 2.0.278

package/esm2022/lib/services/lang-provider/lang-provider.service.mjs

@@ -1,10 +1,33 @@
 import { Inject, Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
-import { LangOption } from './types';
-import { LocalStorageService } from '../local-storage.service';
+import { BehaviorSubject, distinctUntilChanged, map } from 'rxjs';
 import { LANG } from '../../shared/constants/storage';
+import { LocalStorageService } from '../local-storage.service';
 import { ValtechConfigService } from '../types';
+import { LangOption } from './types';
 import * as i0 from "@angular/core";
+/**
+ * LangService - Reactive language and content management service.
+ *
+ * This service provides reactive content management with Observable-based language switching.
+ * Components can subscribe to content changes and automatically update when the language changes.
+ *
+ * @example Basic usage:
+ * ```typescript
+ * constructor(private langService: LangService) {}
+ *
+ * // Get current language
+ * const currentLang = this.langService.currentLang;
+ *
+ * // Subscribe to language changes
+ * this.langService.currentLang$.subscribe(lang => console.log('Language changed:', lang));
+ *
+ * // Get static text
+ * const text = this.langService.getText('ComponentName', 'textKey');
+ *
+ * // Get reactive text
+ * const text$ = this.langService.getContent('ComponentName', 'textKey');
+ * ```
+ */
 export class LangService {
     constructor(config) {
         this.default = LangOption.ES;
@@ -14,16 +37,103 @@ export class LangService {
         const current = LocalStorageService.get(LANG);
         this.selectedLang = new BehaviorSubject(current || this.default);
     }
-    Text(className) {
-        return this.content[className].Content[this.selectedLang.value];
+    /**
+     * Observable that emits the current language whenever it changes.
+     * Use this to react to language changes in components.
+     */
+    get currentLang$() {
+        return this.selectedLang.asObservable().pipe(distinctUntilChanged());
     }
-    get Lang() {
+    /**
+     * Get the current language synchronously.
+     */
+    get currentLang() {
         return this.selectedLang.value;
     }
-    set Lang(lang) {
+    /**
+     * Set the current language and persist it to local storage.
+     * This will trigger updates in all components subscribed to reactive content.
+     *
+     * @param lang - The language to set
+     */
+    setLang(lang) {
         this.selectedLang.next(lang);
         LocalStorageService.set(LANG, lang);
     }
+    /**
+     * Get all text content for a component class (legacy method for compatibility).
+     *
+     * @param className - The component class name
+     * @returns The language text object for the current language
+     * @deprecated Use getText() or getContent() for better type safety
+     */
+    Text(className) {
+        return this.content[className]?.Content[this.selectedLang.value] || {};
+    }
+    /**
+     * Get a specific text value synchronously for the current language.
+     *
+     * @param className - The component class name
+     * @param key - The text key
+     * @param fallback - Optional fallback text if key is not found
+     * @returns The text string or fallback
+     */
+    getText(className, key, fallback) {
+        const classContent = this.content[className]?.Content[this.selectedLang.value];
+        return classContent?.[key] || fallback || `[${className}.${key}]`;
+    }
+    /**
+     * Get a reactive Observable for a specific text key that updates when language changes.
+     * This is the recommended method for components that need reactive content.
+     *
+     * @param className - The component class name
+     * @param key - The text key
+     * @param fallback - Optional fallback text if key is not found
+     * @returns Observable that emits the text string whenever language changes
+     */
+    getContent(className, key, fallback) {
+        return this.currentLang$.pipe(map(lang => {
+            const classContent = this.content[className]?.Content[lang];
+            return classContent?.[key] || fallback || `[${className}.${key}]`;
+        }), distinctUntilChanged());
+    }
+    /**
+     * Get reactive content for multiple keys at once.
+     *
+     * @param className - The component class name
+     * @param keys - Array of text keys to retrieve
+     * @returns Observable that emits an object with all requested keys
+     */
+    getMultipleContent(className, keys) {
+        return this.currentLang$.pipe(map(lang => {
+            const classContent = this.content[className]?.Content[lang] || {};
+            const result = {};
+            keys.forEach(key => {
+                result[key] = classContent[key] || `[${className}.${key}]`;
+            });
+            return result;
+        }), distinctUntilChanged((prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)));
+    }
+    /**
+     * Check if a content key exists for a component.
+     *
+     * @param className - The component class name
+     * @param key - The text key
+     * @returns True if the key exists in any language
+     */
+    hasContent(className, key) {
+        const classContent = this.content[className];
+        if (!classContent)
+            return false;
+        return Object.values(classContent.Content).some(langContent => langContent && typeof langContent[key] === 'string');
+    }
+    // Legacy getters/setters for backward compatibility
+    get Lang() {
+        return this.currentLang;
+    }
+    set Lang(lang) {
+        this.setLang(lang);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LangService, deps: [{ token: ValtechConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LangService, providedIn: 'root' }); }
 }
@@ -36,4 +146,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     type: Inject,
                     args: [ValtechConfigService]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lang-provider.service.js","sourceRoot":"","sources":["../../../../../../projects/valtech-components/src/lib/services/lang-provider/lang-provider.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable, distinctUntilChanged, map } from 'rxjs';\nimport { LANG } from '../../shared/constants/storage';\nimport { LocalStorageService } from '../local-storage.service';\nimport { ValtechConfig, ValtechConfigService } from '../types';\nimport { Provider } from './content';\nimport { LangOption, LanguageText } from './types';\n\n/**\n * LangService - Reactive language and content management service.\n *\n * This service provides reactive content management with Observable-based language switching.\n * Components can subscribe to content changes and automatically update when the language changes.\n *\n * @example Basic usage:\n * ```typescript\n * constructor(private langService: LangService) {}\n *\n * // Get current language\n * const currentLang = this.langService.currentLang;\n *\n * // Subscribe to language changes\n * this.langService.currentLang$.subscribe(lang => console.log('Language changed:', lang));\n *\n * // Get static text\n * const text = this.langService.getText('ComponentName', 'textKey');\n *\n * // Get reactive text\n * const text$ = this.langService.getContent('ComponentName', 'textKey');\n * ```\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class LangService {\n  private content: Provider;\n  private default = LangOption.ES;\n  private selectedLang: BehaviorSubject<LangOption>;\n  private config: ValtechConfig;\n\n  constructor(@Inject(ValtechConfigService) config: ValtechConfig) {\n    console.log('injected config: ', config);\n    this.content = config.content;\n    this.config = config;\n    const current = LocalStorageService.get<LangOption>(LANG);\n    this.selectedLang = new BehaviorSubject<LangOption>(current || this.default);\n  }\n\n  /**\n   * Observable that emits the current language whenever it changes.\n   * Use this to react to language changes in components.\n   */\n  get currentLang$(): Observable<LangOption> {\n    return this.selectedLang.asObservable().pipe(distinctUntilChanged());\n  }\n\n  /**\n   * Get the current language synchronously.\n   */\n  get currentLang(): LangOption {\n    return this.selectedLang.value;\n  }\n\n  /**\n   * Set the current language and persist it to local storage.\n   * This will trigger updates in all components subscribed to reactive content.\n   *\n   * @param lang - The language to set\n   */\n  setLang(lang: LangOption): void {\n    this.selectedLang.next(lang);\n    LocalStorageService.set<LangOption>(LANG, lang);\n  }\n\n  /**\n   * Get all text content for a component class (legacy method for compatibility).\n   *\n   * @param className - The component class name\n   * @returns The language text object for the current language\n   * @deprecated Use getText() or getContent() for better type safety\n   */\n  Text(className: string): LanguageText {\n    return this.content[className]?.Content[this.selectedLang.value] || {};\n  }\n\n  /**\n   * Get a specific text value synchronously for the current language.\n   *\n   * @param className - The component class name\n   * @param key - The text key\n   * @param fallback - Optional fallback text if key is not found\n   * @returns The text string or fallback\n   */\n  getText(className: string, key: string, fallback?: string): string {\n    const classContent = this.content[className]?.Content[this.selectedLang.value];\n    return classContent?.[key] || fallback || `[${className}.${key}]`;\n  }\n\n  /**\n   * Get a reactive Observable for a specific text key that updates when language changes.\n   * This is the recommended method for components that need reactive content.\n   *\n   * @param className - The component class name\n   * @param key - The text key\n   * @param fallback - Optional fallback text if key is not found\n   * @returns Observable that emits the text string whenever language changes\n   */\n  getContent(className: string, key: string, fallback?: string): Observable<string> {\n    return this.currentLang$.pipe(\n      map(lang => {\n        const classContent = this.content[className]?.Content[lang];\n        return classContent?.[key] || fallback || `[${className}.${key}]`;\n      }),\n      distinctUntilChanged()\n    );\n  }\n\n  /**\n   * Get reactive content for multiple keys at once.\n   *\n   * @param className - The component class name\n   * @param keys - Array of text keys to retrieve\n   * @returns Observable that emits an object with all requested keys\n   */\n  getMultipleContent(className: string, keys: string[]): Observable<Record<string, string>> {\n    return this.currentLang$.pipe(\n      map(lang => {\n        const classContent = this.content[className]?.Content[lang] || {};\n        const result: Record<string, string> = {};\n        keys.forEach(key => {\n          result[key] = classContent[key] || `[${className}.${key}]`;\n        });\n        return result;\n      }),\n      distinctUntilChanged((prev, curr) => JSON.stringify(prev) === JSON.stringify(curr))\n    );\n  }\n\n  /**\n   * Check if a content key exists for a component.\n   *\n   * @param className - The component class name\n   * @param key - The text key\n   * @returns True if the key exists in any language\n   */\n  hasContent(className: string, key: string): boolean {\n    const classContent = this.content[className];\n    if (!classContent) return false;\n\n    return Object.values(classContent.Content).some(\n      langContent => langContent && typeof langContent[key] === 'string'\n    );\n  }\n\n  // Legacy getters/setters for backward compatibility\n  get Lang(): LangOption {\n    return this.currentLang;\n  }\n\n  set Lang(lang: LangOption) {\n    this.setLang(lang);\n  }\n}\n"]}

package/esm2022/lib/shared/utils/content.mjs

@@ -0,0 +1,186 @@
+import { map } from 'rxjs';
+/**
+ * Create a reactive content observable from a content key.
+ * This is the primary utility for the `fromContent` pattern with unified support
+ * for both simple content and content with interpolation.
+ *
+ * @param langService - The language service instance
+ * @param config - Content configuration with optional interpolation
+ * @returns Observable that emits the content string and updates on language change
+ *
+ * @example Simple content:
+ * ```typescript
+ * // Component-specific content
+ * this.title$ = fromContent(this.langService, {
+ *   className: 'HeaderComponent',
+ *   key: 'title',
+ *   fallback: 'Default Title'
+ * });
+ *
+ * // Global content (no className needed)
+ * this.saveButton$ = fromContent(this.langService, {
+ *   key: 'save'
+ * });
+ * ```
+ *
+ * @example Content with interpolation:
+ * ```typescript
+ * // Content: "Hello {name}, you have {count} messages"
+ * this.greeting$ = fromContent(this.langService, {
+ *   className: 'WelcomeComponent',
+ *   key: 'greeting',
+ *   interpolation: { name: 'John', count: 5 }
+ * });
+ * // Results in: "Hello John, you have 5 messages"
+ * ```
+ */
+export function fromContent(langService, config) {
+    // Use _global as default className if not provided
+    const finalClassName = config.className || '_global';
+    const contentObservable = langService.getContent(finalClassName, config.key, config.fallback);
+    // If interpolation is provided, apply it
+    if (config.interpolation) {
+        return contentObservable.pipe(map(content => interpolateContent(content, config.interpolation)));
+    }
+    return contentObservable;
+}
+/**
+ * Create a reactive content observable with interpolation support.
+ *
+ * @deprecated Use fromContent() with interpolation property instead.
+ * This method is kept for backward compatibility.
+ *
+ * @param langService - The language service instance
+ * @param config - Interpolated content configuration
+ * @returns Observable that emits the interpolated content string
+ *
+ * @example Migration:
+ * ```typescript
+ * // OLD (deprecated):
+ * this.greeting$ = fromContentWithInterpolation(this.langService, {
+ *   className: 'WelcomeComponent',
+ *   key: 'greeting',
+ *   interpolation: { name: 'John', count: 5 }
+ * });
+ *
+ * // NEW (recommended):
+ * this.greeting$ = fromContent(this.langService, {
+ *   className: 'WelcomeComponent',
+ *   key: 'greeting',
+ *   interpolation: { name: 'John', count: 5 }
+ * });
+ * ```
+ */
+export function fromContentWithInterpolation(langService, config) {
+    // Delegate to the unified fromContent method
+    return fromContent(langService, config);
+}
+/**
+ * Create multiple reactive content observables at once.
+ * Useful when a component needs several content strings.
+ *
+ * @param langService - The language service instance
+ * @param className - The component class name
+ * @param keys - Array of content keys to retrieve
+ * @returns Observable that emits an object with all requested content
+ *
+ * @example
+ * ```typescript
+ * this.content$ = fromMultipleContent(this.langService, 'FormComponent', [
+ *   'title', 'submitButton', 'cancelButton'
+ * ]);
+ *
+ * // In template
+ * <ng-container *ngIf="content$ | async as content">
+ *   <h2>{{ content.title }}</h2>
+ *   <button>{{ content.submitButton }}</button>
+ *   <button>{{ content.cancelButton }}</button>
+ * </ng-container>
+ * ```
+ */
+export function fromMultipleContent(langService, className, keys) {
+    return langService.getMultipleContent(className, keys);
+}
+/**
+ * Helper function to interpolate values into a content string.
+ * Replaces placeholders in the format {key} with corresponding values.
+ *
+ * @param content - The content string with placeholders
+ * @param values - Object with values to interpolate
+ * @returns The interpolated string
+ *
+ * @example
+ * ```typescript
+ * const result = interpolateContent("Hello {name}!", { name: "World" });
+ * // Returns: "Hello World!"
+ * ```
+ */
+export function interpolateContent(content, values) {
+    if (!values)
+        return content;
+    return Object.entries(values).reduce((result, [key, value]) => {
+        return result.replace(new RegExp(`\\{${key}\\}`, 'g'), String(value));
+    }, content);
+}
+/**
+ * Factory function to create a content helper bound to a specific component class.
+ * This creates a more convenient API for components that need multiple content strings.
+ *
+ * @param langService - The language service instance
+ * @param className - The component class name
+ * @returns Object with convenient methods for content retrieval
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   private content = createContentHelper(this.langService, 'MyComponent');
+ *
+ *   constructor(private langService: LangService) {}
+ *
+ *   ngOnInit() {
+ *     this.title$ = this.content.get('title');
+ *     this.allContent$ = this.content.getMultiple(['title', 'description']);
+ *   }
+ * }
+ * ```
+ */
+export function createContentHelper(langService, className) {
+    return {
+        /**
+         * Get a single content string reactively.
+         */
+        get(key, fallback) {
+            return fromContent(langService, { className, key, fallback });
+        },
+        /**
+         * Get multiple content strings reactively.
+         */
+        getMultiple(keys) {
+            return fromMultipleContent(langService, className, keys);
+        },
+        /**
+         * Get content with interpolation.
+         */
+        getWithInterpolation(key, interpolation, fallback) {
+            return fromContentWithInterpolation(langService, {
+                className,
+                key,
+                interpolation,
+                fallback,
+            });
+        },
+        /**
+         * Get a single content string synchronously (current language only).
+         */
+        getText(key, fallback) {
+            return langService.getText(className, key, fallback);
+        },
+        /**
+         * Check if a content key exists.
+         */
+        hasContent(key) {
+            return langService.hasContent(className, key);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content.js","sourceRoot":"","sources":["../../../../../../projects/valtech-components/src/lib/shared/utils/content.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,GAAG,EAAE,MAAM,MAAM,CAAC;AAqCvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,WAAW,CAAC,WAAwB,EAAE,MAAqB;IACzE,mDAAmD;IACnD,MAAM,cAAc,GAAG,MAAM,CAAC,SAAS,IAAI,SAAS,CAAC;IAErD,MAAM,iBAAiB,GAAG,WAAW,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE9F,yCAAyC;IACzC,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;QACzB,OAAO,iBAAiB,CAAC,IAAI,CAC3B,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC,CAClE,CAAC;IACJ,CAAC;IAED,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,4BAA4B,CAC1C,WAAwB,EACxB,MAAiC;IAEjC,6CAA6C;IAC7C,OAAO,WAAW,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,mBAAmB,CACjC,WAAwB,EACxB,SAAiB,EACjB,IAAc;IAEd,OAAO,WAAW,CAAC,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAe,EACf,MAAwC;IAExC,IAAI,CAAC,MAAM;QAAE,OAAO,OAAO,CAAC;IAE5B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QAC5D,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,KAAK,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACxE,CAAC,EAAE,OAAO,CAAC,CAAC;AACd,CAAC;AAsBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,mBAAmB,CAAC,WAAwB,EAAE,SAAiB;IAC7E,OAAO;QACL;;WAEG;QACH,GAAG,CAAC,GAAW,EAAE,QAAiB;YAChC,OAAO,WAAW,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;QAChE,CAAC;QAED;;WAEG;QACH,WAAW,CAAC,IAAc;YACxB,OAAO,mBAAmB,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QAC3D,CAAC;QAED;;WAEG;QACH,oBAAoB,CAClB,GAAW,EACX,aAA8C,EAC9C,QAAiB;YAEjB,OAAO,4BAA4B,CAAC,WAAW,EAAE;gBAC/C,SAAS;gBACT,GAAG;gBACH,aAAa;gBACb,QAAQ;aACT,CAAC,CAAC;QACL,CAAC;QAED;;WAEG;QACH,OAAO,CAAC,GAAW,EAAE,QAAiB;YACpC,OAAO,WAAW,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;QACvD,CAAC;QAED;;WAEG;QACH,UAAU,CAAC,GAAW;YACpB,OAAO,WAAW,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAChD,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { Observable, map } from 'rxjs';\nimport { LangService } from '../../services/lang-provider/lang-provider.service';\n\n/**\n * Content utilities for reactive text binding in components.\n *\n * These utilities provide a convenient way to bind component properties\n * to language content that automatically updates when the language changes.\n */\n\n/**\n * Unified configuration for content binding with optional interpolation.\n * Supports both simple content retrieval and content with dynamic values.\n */\nexport interface ContentConfig {\n  /**\n   * The component class name (used for content lookup).\n   * If omitted, searches in global content (_global namespace).\n   */\n  className?: string;\n  /** The content key to retrieve */\n  key: string;\n  /** Optional fallback text if content is not found */\n  fallback?: string;\n  /** Optional object with values to interpolate into the content string */\n  interpolation?: Record<string, string | number>;\n}\n\n/**\n * @deprecated Use ContentConfig with interpolation property instead.\n * This interface is kept for backward compatibility.\n */\nexport interface InterpolatedContentConfig extends ContentConfig {\n  /** Object with values to interpolate into the content string */\n  interpolation?: Record<string, string | number>;\n}\n\n/**\n * Create a reactive content observable from a content key.\n * This is the primary utility for the `fromContent` pattern with unified support\n * for both simple content and content with interpolation.\n *\n * @param langService - The language service instance\n * @param config - Content configuration with optional interpolation\n * @returns Observable that emits the content string and updates on language change\n *\n * @example Simple content:\n * ```typescript\n * // Component-specific content\n * this.title$ = fromContent(this.langService, {\n *   className: 'HeaderComponent',\n *   key: 'title',\n *   fallback: 'Default Title'\n * });\n *\n * // Global content (no className needed)\n * this.saveButton$ = fromContent(this.langService, {\n *   key: 'save'\n * });\n * ```\n *\n * @example Content with interpolation:\n * ```typescript\n * // Content: \"Hello {name}, you have {count} messages\"\n * this.greeting$ = fromContent(this.langService, {\n *   className: 'WelcomeComponent',\n *   key: 'greeting',\n *   interpolation: { name: 'John', count: 5 }\n * });\n * // Results in: \"Hello John, you have 5 messages\"\n * ```\n */\nexport function fromContent(langService: LangService, config: ContentConfig): Observable<string> {\n  // Use _global as default className if not provided\n  const finalClassName = config.className || '_global';\n\n  const contentObservable = langService.getContent(finalClassName, config.key, config.fallback);\n\n  // If interpolation is provided, apply it\n  if (config.interpolation) {\n    return contentObservable.pipe(\n      map(content => interpolateContent(content, config.interpolation))\n    );\n  }\n\n  return contentObservable;\n}\n\n/**\n * Create a reactive content observable with interpolation support.\n *\n * @deprecated Use fromContent() with interpolation property instead.\n * This method is kept for backward compatibility.\n *\n * @param langService - The language service instance\n * @param config - Interpolated content configuration\n * @returns Observable that emits the interpolated content string\n *\n * @example Migration:\n * ```typescript\n * // OLD (deprecated):\n * this.greeting$ = fromContentWithInterpolation(this.langService, {\n *   className: 'WelcomeComponent',\n *   key: 'greeting',\n *   interpolation: { name: 'John', count: 5 }\n * });\n *\n * // NEW (recommended):\n * this.greeting$ = fromContent(this.langService, {\n *   className: 'WelcomeComponent',\n *   key: 'greeting',\n *   interpolation: { name: 'John', count: 5 }\n * });\n * ```\n */\nexport function fromContentWithInterpolation(\n  langService: LangService,\n  config: InterpolatedContentConfig\n): Observable<string> {\n  // Delegate to the unified fromContent method\n  return fromContent(langService, config);\n}\n\n/**\n * Create multiple reactive content observables at once.\n * Useful when a component needs several content strings.\n *\n * @param langService - The language service instance\n * @param className - The component class name\n * @param keys - Array of content keys to retrieve\n * @returns Observable that emits an object with all requested content\n *\n * @example\n * ```typescript\n * this.content$ = fromMultipleContent(this.langService, 'FormComponent', [\n *   'title', 'submitButton', 'cancelButton'\n * ]);\n *\n * // In template\n * <ng-container *ngIf=\"content$ | async as content\">\n *   <h2>{{ content.title }}</h2>\n *   <button>{{ content.submitButton }}</button>\n *   <button>{{ content.cancelButton }}</button>\n * </ng-container>\n * ```\n */\nexport function fromMultipleContent(\n  langService: LangService,\n  className: string,\n  keys: string[]\n): Observable<Record<string, string>> {\n  return langService.getMultipleContent(className, keys);\n}\n\n/**\n * Helper function to interpolate values into a content string.\n * Replaces placeholders in the format {key} with corresponding values.\n *\n * @param content - The content string with placeholders\n * @param values - Object with values to interpolate\n * @returns The interpolated string\n *\n * @example\n * ```typescript\n * const result = interpolateContent(\"Hello {name}!\", { name: \"World\" });\n * // Returns: \"Hello World!\"\n * ```\n */\nexport function interpolateContent(\n  content: string,\n  values?: Record<string, string | number>\n): string {\n  if (!values) return content;\n\n  return Object.entries(values).reduce((result, [key, value]) => {\n    return result.replace(new RegExp(`\\\\{${key}\\\\}`, 'g'), String(value));\n  }, content);\n}\n\n/**\n * Type-safe content key builder for better IDE support.\n * This is a utility type that can be used to ensure content keys exist.\n *\n * @example\n * ```typescript\n * // Define your component's content keys\n * interface MyComponentContent {\n *   title: string;\n *   description: string;\n *   submitButton: string;\n * }\n *\n * // Use with type safety\n * const titleKey: ContentKey<MyComponentContent> = 'title'; // ✓ Valid\n * const invalidKey: ContentKey<MyComponentContent> = 'invalid'; // ✗ Type error\n * ```\n */\nexport type ContentKey<T> = keyof T & string;\n\n/**\n * Factory function to create a content helper bound to a specific component class.\n * This creates a more convenient API for components that need multiple content strings.\n *\n * @param langService - The language service instance\n * @param className - The component class name\n * @returns Object with convenient methods for content retrieval\n *\n * @example\n * ```typescript\n * export class MyComponent {\n *   private content = createContentHelper(this.langService, 'MyComponent');\n *\n *   constructor(private langService: LangService) {}\n *\n *   ngOnInit() {\n *     this.title$ = this.content.get('title');\n *     this.allContent$ = this.content.getMultiple(['title', 'description']);\n *   }\n * }\n * ```\n */\nexport function createContentHelper(langService: LangService, className: string) {\n  return {\n    /**\n     * Get a single content string reactively.\n     */\n    get(key: string, fallback?: string): Observable<string> {\n      return fromContent(langService, { className, key, fallback });\n    },\n\n    /**\n     * Get multiple content strings reactively.\n     */\n    getMultiple(keys: string[]): Observable<Record<string, string>> {\n      return fromMultipleContent(langService, className, keys);\n    },\n\n    /**\n     * Get content with interpolation.\n     */\n    getWithInterpolation(\n      key: string,\n      interpolation: Record<string, string | number>,\n      fallback?: string\n    ): Observable<string> {\n      return fromContentWithInterpolation(langService, {\n        className,\n        key,\n        interpolation,\n        fallback,\n      });\n    },\n\n    /**\n     * Get a single content string synchronously (current language only).\n     */\n    getText(key: string, fallback?: string): string {\n      return langService.getText(className, key, fallback);\n    },\n\n    /**\n     * Check if a content key exists.\n     */\n    hasContent(key: string): boolean {\n      return langService.hasContent(className, key);\n    },\n  };\n}\n"]}

package/esm2022/public-api.mjs

@@ -43,6 +43,8 @@ export * from './lib/components/molecules/expandable-text/types';
 export * from './lib/components/molecules/file-input/file-input.component';
 export * from './lib/components/molecules/hint/hint.component';
 export * from './lib/components/molecules/hour-input/hour-input.component';
+export * from './lib/components/molecules/layered-card/layered-card.component';
+export * from './lib/components/molecules/layered-card/types';
 export * from './lib/components/molecules/link/link.component';
 export * from './lib/components/molecules/link/types';
 export * from './lib/components/molecules/links-cake/links-cake.component';
@@ -57,14 +59,12 @@ export * from './lib/components/molecules/progress-status/types';
 export * from './lib/components/molecules/prompter/prompter.component';
 export * from './lib/components/molecules/prompter/types';
 export * from './lib/components/molecules/radio-input/radio-input.component';
-export * from './lib/components/molecules/select-search/select-search.component';
 export * from './lib/components/molecules/searchbar/searchbar.component';
 export * from './lib/components/molecules/select-input/select-input.component';
+export * from './lib/components/molecules/select-search/select-search.component';
 export * from './lib/components/molecules/text-input/text-input.component';
 export * from './lib/components/molecules/title-block/title-block.component';
 export * from './lib/components/molecules/title-block/types';
-export * from './lib/components/molecules/layered-card/layered-card.component';
-export * from './lib/components/molecules/layered-card/types';
 export * from './lib/components/organisms/banner/banner.component';
 export * from './lib/components/organisms/banner/types';
 export * from './lib/components/organisms/footer/footer.component';
@@ -85,6 +85,10 @@ export * from './lib/components/organisms/wizard/wizard.component';
 export * from './lib/components/templates/layout/layout.component';
 export * from './lib/components/templates/simple/simple.component';
 export * from './lib/components/templates/simple/types';
+// Examples
+export * from './lib/components/_examples/global-content-example.component';
+export * from './lib/components/_examples/reactive-content-example.component';
+export * from './lib/services/content.service';
 export * from './lib/services/download.service';
 export * from './lib/services/icons.service';
 export * from './lib/services/in-app-browser.service';
@@ -96,7 +100,9 @@ export * from './lib/services/theme.service';
 export * from './lib/services/toast.service';
 export * from './lib/services/types';
 export * from './lib/components/types';
+export * from './lib/shared/utils/content';
 export * from './lib/shared/utils/dom';
-export * from './lib/shared/utils/text';
+export * from './lib/shared/utils/form-defaults';
 export * from './lib/shared/utils/styles';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../projects/valtech-components/src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of valtech-components\n */\n\n/*\n * Public API Surface of valtech-components\n */\n\nexport * from './lib/components/atoms/avatar/avatar.component';\nexport * from './lib/components/atoms/avatar/types';\nexport * from './lib/components/atoms/box/box.component';\nexport * from './lib/components/atoms/box/types';\nexport * from './lib/components/atoms/button/button.component';\nexport * from './lib/components/atoms/button/factory';\nexport * from './lib/components/atoms/display/display.component';\nexport * from './lib/components/atoms/display/types';\nexport * from './lib/components/atoms/divider/divider.component';\nexport * from './lib/components/atoms/divider/types';\nexport * from './lib/components/atoms/href/href.component';\nexport * from './lib/components/atoms/href/types';\nexport * from './lib/components/atoms/icon/icon.component';\nexport * from './lib/components/atoms/icon/types';\nexport * from './lib/components/atoms/image/image.component';\nexport * from './lib/components/atoms/image/types';\nexport * from './lib/components/atoms/progress-bar/progress-bar.component';\nexport * from './lib/components/atoms/progress-bar/types';\nexport * from './lib/components/atoms/text/text.component';\nexport * from './lib/components/atoms/text/types';\nexport * from './lib/components/atoms/title/title.component';\nexport * from './lib/components/atoms/title/types';\n\nexport * from './lib/components/molecules/alert-box/alert-box.component';\nexport * from './lib/components/molecules/alert-box/types';\nexport * from './lib/components/molecules/button-group/button-group.component';\nexport * from './lib/components/molecules/button-group/types';\nexport * from './lib/components/molecules/card/card.component';\nexport * from './lib/components/molecules/card/types';\nexport * from './lib/components/molecules/check-input/check-input.component';\nexport * from './lib/components/molecules/comment-input/comment-input.component';\nexport * from './lib/components/molecules/content-loader/content-loader.component';\nexport * from './lib/components/molecules/content-loader/types';\nexport * from './lib/components/molecules/date-input/date-input.component';\nexport * from './lib/components/molecules/email-input/email-input.component';\nexport * from './lib/components/molecules/expandable-text/expandable-text.component';\nexport * from './lib/components/molecules/expandable-text/types';\nexport * from './lib/components/molecules/file-input/file-input.component';\nexport * from './lib/components/molecules/hint/hint.component';\nexport * from './lib/components/molecules/hour-input/hour-input.component';\nexport * from './lib/components/molecules/link/link.component';\nexport * from './lib/components/molecules/link/types';\nexport * from './lib/components/molecules/links-cake/links-cake.component';\nexport * from './lib/components/molecules/links-cake/types';\nexport * from './lib/components/molecules/notes-box/notes-box.component';\nexport * from './lib/components/molecules/notes-box/types';\nexport * from './lib/components/molecules/number-input/number-input.component';\nexport * from './lib/components/molecules/password-input/password-input.component';\nexport * from './lib/components/molecules/pin-input/pin-input.component';\nexport * from './lib/components/molecules/progress-status/progress-status.component';\nexport * from './lib/components/molecules/progress-status/types';\nexport * from './lib/components/molecules/prompter/prompter.component';\nexport * from './lib/components/molecules/prompter/types';\nexport * from './lib/components/molecules/radio-input/radio-input.component';\nexport * from './lib/components/molecules/select-search/select-search.component';\nexport * from './lib/components/molecules/searchbar/searchbar.component';\nexport * from './lib/components/molecules/select-input/select-input.component';\nexport * from './lib/components/molecules/text-input/text-input.component';\nexport * from './lib/components/molecules/title-block/title-block.component';\nexport * from './lib/components/molecules/title-block/types';\nexport * from './lib/components/molecules/layered-card/layered-card.component';\nexport * from './lib/components/molecules/layered-card/types';\n\nexport * from './lib/components/organisms/banner/banner.component';\nexport * from './lib/components/organisms/banner/types';\nexport * from './lib/components/organisms/footer/footer.component';\nexport * from './lib/components/organisms/form/factory';\nexport * from './lib/components/organisms/form/form-footer/form-footer.component';\nexport * from './lib/components/organisms/form/form.component';\nexport * from './lib/components/organisms/header/header.component';\nexport * from './lib/components/organisms/header/types';\nexport * from './lib/components/organisms/item-list/item-list.component';\nexport * from './lib/components/organisms/item-list/types';\nexport * from './lib/components/organisms/no-content/no-content.component';\nexport * from './lib/components/organisms/no-content/types';\nexport * from './lib/components/organisms/toolbar/toolbar.component';\nexport * from './lib/components/organisms/toolbar/types';\nexport * from './lib/components/organisms/wizard/types';\nexport * from './lib/components/organisms/wizard/wizard-footer/wizard-footer.component';\nexport * from './lib/components/organisms/wizard/wizard.component';\n\nexport * from './lib/components/templates/layout/layout.component';\nexport * from './lib/components/templates/simple/simple.component';\nexport * from './lib/components/templates/simple/types';\n\nexport * from './lib/services/download.service';\nexport * from './lib/services/icons.service';\nexport * from './lib/services/in-app-browser.service';\nexport * from './lib/services/lang-provider/lang-provider.service';\nexport * from './lib/services/lang-provider/types';\nexport * from './lib/services/local-storage.service';\nexport * from './lib/services/navigation.service';\nexport * from './lib/services/theme.service';\nexport * from './lib/services/toast.service';\nexport * from './lib/services/types';\n\nexport * from './lib/components/types';\nexport * from './lib/shared/utils/dom';\nexport * from './lib/shared/utils/text';\nexport * from './lib/shared/utils/styles';\n"]}
+export * from './lib/shared/utils/text';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../projects/valtech-components/src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of valtech-components\n */\n\n/*\n * Public API Surface of valtech-components\n */\n\nexport * from './lib/components/atoms/avatar/avatar.component';\nexport * from './lib/components/atoms/avatar/types';\nexport * from './lib/components/atoms/box/box.component';\nexport * from './lib/components/atoms/box/types';\nexport * from './lib/components/atoms/button/button.component';\nexport * from './lib/components/atoms/button/factory';\nexport * from './lib/components/atoms/display/display.component';\nexport * from './lib/components/atoms/display/types';\nexport * from './lib/components/atoms/divider/divider.component';\nexport * from './lib/components/atoms/divider/types';\nexport * from './lib/components/atoms/href/href.component';\nexport * from './lib/components/atoms/href/types';\nexport * from './lib/components/atoms/icon/icon.component';\nexport * from './lib/components/atoms/icon/types';\nexport * from './lib/components/atoms/image/image.component';\nexport * from './lib/components/atoms/image/types';\nexport * from './lib/components/atoms/progress-bar/progress-bar.component';\nexport * from './lib/components/atoms/progress-bar/types';\nexport * from './lib/components/atoms/text/text.component';\nexport * from './lib/components/atoms/text/types';\nexport * from './lib/components/atoms/title/title.component';\nexport * from './lib/components/atoms/title/types';\n\nexport * from './lib/components/molecules/alert-box/alert-box.component';\nexport * from './lib/components/molecules/alert-box/types';\nexport * from './lib/components/molecules/button-group/button-group.component';\nexport * from './lib/components/molecules/button-group/types';\nexport * from './lib/components/molecules/card/card.component';\nexport * from './lib/components/molecules/card/types';\nexport * from './lib/components/molecules/check-input/check-input.component';\nexport * from './lib/components/molecules/comment-input/comment-input.component';\nexport * from './lib/components/molecules/content-loader/content-loader.component';\nexport * from './lib/components/molecules/content-loader/types';\nexport * from './lib/components/molecules/date-input/date-input.component';\nexport * from './lib/components/molecules/email-input/email-input.component';\nexport * from './lib/components/molecules/expandable-text/expandable-text.component';\nexport * from './lib/components/molecules/expandable-text/types';\nexport * from './lib/components/molecules/file-input/file-input.component';\nexport * from './lib/components/molecules/hint/hint.component';\nexport * from './lib/components/molecules/hour-input/hour-input.component';\nexport * from './lib/components/molecules/layered-card/layered-card.component';\nexport * from './lib/components/molecules/layered-card/types';\nexport * from './lib/components/molecules/link/link.component';\nexport * from './lib/components/molecules/link/types';\nexport * from './lib/components/molecules/links-cake/links-cake.component';\nexport * from './lib/components/molecules/links-cake/types';\nexport * from './lib/components/molecules/notes-box/notes-box.component';\nexport * from './lib/components/molecules/notes-box/types';\nexport * from './lib/components/molecules/number-input/number-input.component';\nexport * from './lib/components/molecules/password-input/password-input.component';\nexport * from './lib/components/molecules/pin-input/pin-input.component';\nexport * from './lib/components/molecules/progress-status/progress-status.component';\nexport * from './lib/components/molecules/progress-status/types';\nexport * from './lib/components/molecules/prompter/prompter.component';\nexport * from './lib/components/molecules/prompter/types';\nexport * from './lib/components/molecules/radio-input/radio-input.component';\nexport * from './lib/components/molecules/searchbar/searchbar.component';\nexport * from './lib/components/molecules/select-input/select-input.component';\nexport * from './lib/components/molecules/select-search/select-search.component';\nexport * from './lib/components/molecules/text-input/text-input.component';\nexport * from './lib/components/molecules/title-block/title-block.component';\nexport * from './lib/components/molecules/title-block/types';\n\nexport * from './lib/components/organisms/banner/banner.component';\nexport * from './lib/components/organisms/banner/types';\nexport * from './lib/components/organisms/footer/footer.component';\nexport * from './lib/components/organisms/form/factory';\nexport * from './lib/components/organisms/form/form-footer/form-footer.component';\nexport * from './lib/components/organisms/form/form.component';\nexport * from './lib/components/organisms/header/header.component';\nexport * from './lib/components/organisms/header/types';\nexport * from './lib/components/organisms/item-list/item-list.component';\nexport * from './lib/components/organisms/item-list/types';\nexport * from './lib/components/organisms/no-content/no-content.component';\nexport * from './lib/components/organisms/no-content/types';\nexport * from './lib/components/organisms/toolbar/toolbar.component';\nexport * from './lib/components/organisms/toolbar/types';\nexport * from './lib/components/organisms/wizard/types';\nexport * from './lib/components/organisms/wizard/wizard-footer/wizard-footer.component';\nexport * from './lib/components/organisms/wizard/wizard.component';\n\nexport * from './lib/components/templates/layout/layout.component';\nexport * from './lib/components/templates/simple/simple.component';\nexport * from './lib/components/templates/simple/types';\n\n// Examples\nexport * from './lib/components/_examples/global-content-example.component';\nexport * from './lib/components/_examples/reactive-content-example.component';\n\nexport * from './lib/services/content.service';\nexport * from './lib/services/download.service';\nexport * from './lib/services/icons.service';\nexport * from './lib/services/in-app-browser.service';\nexport * from './lib/services/lang-provider/lang-provider.service';\nexport * from './lib/services/lang-provider/types';\nexport * from './lib/services/local-storage.service';\nexport * from './lib/services/navigation.service';\nexport * from './lib/services/theme.service';\nexport * from './lib/services/toast.service';\nexport * from './lib/services/types';\n\nexport * from './lib/components/types';\nexport * from './lib/shared/utils/content';\nexport * from './lib/shared/utils/dom';\nexport * from './lib/shared/utils/form-defaults';\nexport * from './lib/shared/utils/styles';\nexport * from './lib/shared/utils/text';\n"]}