valtech-components 2.0.276 → 2.0.278

package/esm2022/lib/services/content.service.mjs

@@ -0,0 +1,327 @@
+import { Injectable } from '@angular/core';
+import { createContentHelper, fromContent, fromMultipleContent, interpolateContent, } from '../shared/utils/content';
+import * as i0 from "@angular/core";
+import * as i1 from "./lang-provider/lang-provider.service";
+/**
+ * ContentService - High-level reactive content management service.
+ *
+ * This service provides a clean, convenient API for reactive content management
+ * without requiring direct interaction with LangService. It acts as a facade
+ * that simplifies the most common content operations.
+ *
+ * @example Basic usage:
+ * ```typescript
+ * @Component({})
+ * export class MyComponent {
+ *   content = inject(ContentService);
+ *
+ *   title$ = this.content.fromContent({
+ *     className: 'MyComponent',
+ *     key: 'title'
+ *   });
+ *
+ *   constructor() {}
+ * }
+ * ```
+ */
+export class ContentService {
+    constructor(langService) {
+        this.langService = langService;
+    }
+    /**
+     * Get current language as an observable stream.
+     * Emits whenever the language changes.
+     */
+    get currentLang$() {
+        return this.langService.currentLang$;
+    }
+    /**
+     * Get current language synchronously.
+     */
+    get currentLang() {
+        return this.langService.currentLang;
+    }
+    /**
+     * Set the current language.
+     * This will trigger updates in all reactive content.
+     *
+     * @param lang - The language to set
+     */
+    setLang(lang) {
+        this.langService.setLang(lang);
+    }
+    /**
+     * Create a reactive content observable from a content key.
+     * This is the primary method for reactive content with unified support
+     * for both simple content and content with interpolation.
+     *
+     * @param config - Content configuration with optional interpolation. If className is omitted, searches in global content.
+     * @returns Observable that emits the content string and updates on language change
+     *
+     * @example Simple global content:
+     * ```typescript
+     * // Searches in global content (no className needed)
+     * okButton$ = this.content.fromContent({
+     *   key: 'ok',
+     *   fallback: 'OK'
+     * });
+     * ```
+     *
+     * @example Component-specific content:
+     * ```typescript
+     * title$ = this.content.fromContent({
+     *   className: 'HeaderComponent',
+     *   key: 'title',
+     *   fallback: 'Default Title'
+     * });
+     * ```
+     *
+     * @example Content with interpolation:
+     * ```typescript
+     * // Global content with interpolation
+     * confirmation$ = this.content.fromContent({
+     *   key: 'deleteConfirmation',
+     *   interpolation: { itemName: 'archivo' }
+     * });
+     *
+     * // Component content with interpolation
+     * greeting$ = this.content.fromContent({
+     *   className: 'WelcomeComponent',
+     *   key: 'greeting',
+     *   interpolation: { name: 'John', count: 5 }
+     * });
+     * ```
+     */
+    fromContent(config) {
+        return fromContent(this.langService, config);
+    }
+    /**
+     * Create a reactive content observable with interpolation support.
+     *
+     * @deprecated Use fromContent() with interpolation property instead.
+     * This method is kept for backward compatibility.
+     *
+     * @param config - Interpolated content configuration. If className is omitted, searches in global content.
+     * @returns Observable that emits the interpolated content string
+     *
+     * @example Migration:
+     * ```typescript
+     * // OLD (deprecated):
+     * greeting$ = this.content.fromContentWithInterpolation({
+     *   className: 'WelcomeComponent',
+     *   key: 'greeting',
+     *   interpolation: { name: 'John', count: 5 }
+     * });
+     *
+     * // NEW (recommended):
+     * greeting$ = this.content.fromContent({
+     *   className: 'WelcomeComponent',
+     *   key: 'greeting',
+     *   interpolation: { name: 'John', count: 5 }
+     * });
+     * ```
+     */
+    fromContentWithInterpolation(config) {
+        // Delegate to the unified fromContent method
+        return this.fromContent(config);
+    }
+    /**
+     * Create multiple reactive content observables at once.
+     * Useful when a component needs several content strings.
+     *
+     * @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
+     * content$ = this.content.fromMultipleContent('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>
+     * ```
+     */
+    fromMultipleContent(className, keys) {
+        return fromMultipleContent(this.langService, className, keys);
+    }
+    getText(classNameOrKey, keyOrFallback, fallback) {
+        // Handle overloaded signatures
+        if (keyOrFallback === undefined ||
+            (typeof keyOrFallback === 'string' && fallback === undefined)) {
+            // Single parameter or two parameters (key, fallback) - treat as global content
+            return this.langService.getText('_global', classNameOrKey, keyOrFallback);
+        }
+        else {
+            // Three parameters (className, key, fallback) - treat as component content
+            return this.langService.getText(classNameOrKey, keyOrFallback, fallback);
+        }
+    }
+    /**
+     * Get a single global content string synchronously.
+     * This is a convenience method that's equivalent to getText(key, fallback).
+     *
+     * @param key - The text key
+     * @param fallback - Optional fallback text if key is not found
+     * @returns The text string or fallback
+     *
+     * @example
+     * ```typescript
+     * const okText = this.content.getGlobalText('ok');
+     * const cancelText = this.content.getGlobalText('cancel', 'Cancel');
+     * ```
+     */
+    getGlobalText(key, fallback) {
+        return this.langService.getText('_global', key, fallback);
+    }
+    /**
+     * 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
+     *
+     * @example
+     * ```typescript
+     * if (this.content.hasContent('MyComponent', 'optionalText')) {
+     *   // Show optional content
+     * }
+     * ```
+     */
+    hasContent(className, key) {
+        return this.langService.hasContent(className, key);
+    }
+    /**
+     * Helper function to interpolate values into a content string.
+     * Useful for processing content strings manually.
+     *
+     * @param content - The content string with placeholders
+     * @param values - Object with values to interpolate
+     * @returns The interpolated string
+     *
+     * @example
+     * ```typescript
+     * const result = this.content.interpolate("Hello {name}!", { name: "World" });
+     * // Returns: "Hello World!"
+     * ```
+     */
+    interpolate(content, values) {
+        return interpolateContent(content, values);
+    }
+    /**
+     * Create a content helper bound to a specific component class.
+     * This provides a scoped API for components that need multiple content strings.
+     *
+     * @param className - The component class name
+     * @returns Content helper with methods scoped to the class
+     *
+     * @example
+     * ```typescript
+     * export class MyComponent {
+     *   private contentHelper = this.content.createHelper('MyComponent');
+     *
+     *   ngOnInit() {
+     *     this.title$ = this.contentHelper.get('title');
+     *     this.allContent$ = this.contentHelper.getMultiple(['title', 'description']);
+     *   }
+     *
+     *   constructor(private content: ContentService) {}
+     * }
+     * ```
+     */
+    createHelper(className) {
+        return createContentHelper(this.langService, className);
+    }
+    /**
+     * Create a scoped content service for a specific component class.
+     * This provides an even more convenient API for components with many content needs.
+     *
+     * @param className - The component class name
+     * @returns Scoped content service
+     *
+     * @example
+     * ```typescript
+     * export class MyComponent {
+     *   private content = inject(ContentService).forComponent('MyComponent');
+     *
+     *   // Simple content
+     *   title$ = this.content.get('title');
+     *
+     *   // Content with interpolation
+     *   greeting$ = this.content.get('greeting', {
+     *     interpolation: { name: 'John' }
+     *   });
+     *
+     *   // Content with fallback
+     *   subtitle$ = this.content.get('subtitle', {
+     *     fallback: 'Default Subtitle'
+     *   });
+     *
+     *   // Multiple texts
+     *   allTexts$ = this.content.getMultiple(['title', 'subtitle', 'description']);
+     *
+     *   constructor() {}
+     * }
+     * ```
+     */
+    forComponent(className) {
+        return {
+            /**
+             * Get a single content string reactively for this component.
+             * Supports optional interpolation.
+             */
+            get: (key, options) => {
+                return this.fromContent({
+                    className,
+                    key,
+                    fallback: options?.fallback,
+                    interpolation: options?.interpolation,
+                });
+            },
+            /**
+             * Get content with interpolation for this component.
+             * @deprecated Use get() with interpolation option instead.
+             */
+            getWithInterpolation: (key, interpolation, fallback) => {
+                return this.fromContent({
+                    className,
+                    key,
+                    interpolation,
+                    fallback,
+                });
+            },
+            /**
+             * Get multiple content strings for this component.
+             */
+            getMultiple: (keys) => {
+                return this.fromMultipleContent(className, keys);
+            },
+            /**
+             * Get a single content string synchronously for this component.
+             */
+            getText: (key, fallback) => {
+                return this.getText(className, key, fallback);
+            },
+            /**
+             * Check if a content key exists for this component.
+             */
+            hasContent: (key) => {
+                return this.hasContent(className, key);
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ContentService, deps: [{ token: i1.LangService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ContentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ContentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.LangService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content.service.js","sourceRoot":"","sources":["../../../../../projects/valtech-components/src/lib/services/content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport {\n  ContentConfig,\n  InterpolatedContentConfig,\n  createContentHelper,\n  fromContent,\n  fromMultipleContent,\n  interpolateContent,\n} from '../shared/utils/content';\nimport { LangService } from './lang-provider/lang-provider.service';\nimport { LangOption } from './lang-provider/types';\n\n/**\n * ContentService - High-level reactive content management service.\n *\n * This service provides a clean, convenient API for reactive content management\n * without requiring direct interaction with LangService. It acts as a facade\n * that simplifies the most common content operations.\n *\n * @example Basic usage:\n * ```typescript\n * @Component({})\n * export class MyComponent {\n *   content = inject(ContentService);\n *\n *   title$ = this.content.fromContent({\n *     className: 'MyComponent',\n *     key: 'title'\n *   });\n *\n *   constructor() {}\n * }\n * ```\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ContentService {\n  constructor(private langService: LangService) {}\n\n  /**\n   * Get current language as an observable stream.\n   * Emits whenever the language changes.\n   */\n  get currentLang$(): Observable<LangOption> {\n    return this.langService.currentLang$;\n  }\n\n  /**\n   * Get current language synchronously.\n   */\n  get currentLang(): LangOption {\n    return this.langService.currentLang;\n  }\n\n  /**\n   * Set the current language.\n   * This will trigger updates in all reactive content.\n   *\n   * @param lang - The language to set\n   */\n  setLang(lang: LangOption): void {\n    this.langService.setLang(lang);\n  }\n\n  /**\n   * Create a reactive content observable from a content key.\n   * This is the primary method for reactive content with unified support\n   * for both simple content and content with interpolation.\n   *\n   * @param config - Content configuration with optional interpolation. If className is omitted, searches in global content.\n   * @returns Observable that emits the content string and updates on language change\n   *\n   * @example Simple global content:\n   * ```typescript\n   * // Searches in global content (no className needed)\n   * okButton$ = this.content.fromContent({\n   *   key: 'ok',\n   *   fallback: 'OK'\n   * });\n   * ```\n   *\n   * @example Component-specific content:\n   * ```typescript\n   * title$ = this.content.fromContent({\n   *   className: 'HeaderComponent',\n   *   key: 'title',\n   *   fallback: 'Default Title'\n   * });\n   * ```\n   *\n   * @example Content with interpolation:\n   * ```typescript\n   * // Global content with interpolation\n   * confirmation$ = this.content.fromContent({\n   *   key: 'deleteConfirmation',\n   *   interpolation: { itemName: 'archivo' }\n   * });\n   *\n   * // Component content with interpolation\n   * greeting$ = this.content.fromContent({\n   *   className: 'WelcomeComponent',\n   *   key: 'greeting',\n   *   interpolation: { name: 'John', count: 5 }\n   * });\n   * ```\n   */\n  fromContent(config: ContentConfig): Observable<string> {\n    return fromContent(this.langService, config);\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 config - Interpolated content configuration. If className is omitted, searches in global content.\n   * @returns Observable that emits the interpolated content string\n   *\n   * @example Migration:\n   * ```typescript\n   * // OLD (deprecated):\n   * greeting$ = this.content.fromContentWithInterpolation({\n   *   className: 'WelcomeComponent',\n   *   key: 'greeting',\n   *   interpolation: { name: 'John', count: 5 }\n   * });\n   *\n   * // NEW (recommended):\n   * greeting$ = this.content.fromContent({\n   *   className: 'WelcomeComponent',\n   *   key: 'greeting',\n   *   interpolation: { name: 'John', count: 5 }\n   * });\n   * ```\n   */\n  fromContentWithInterpolation(\n    config: InterpolatedContentConfig | Omit<InterpolatedContentConfig, 'className'>\n  ): Observable<string> {\n    // Delegate to the unified fromContent method\n    return this.fromContent(config as ContentConfig);\n  }\n\n  /**\n   * Create multiple reactive content observables at once.\n   * Useful when a component needs several content strings.\n   *\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   * content$ = this.content.fromMultipleContent('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   */\n  fromMultipleContent(className: string, keys: string[]): Observable<Record<string, string>> {\n    return fromMultipleContent(this.langService, className, keys);\n  }\n\n  /**\n   * Get a single content string synchronously for the current language.\n   *\n   * @param className - The component class name. If omitted, searches in global content.\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   * @example Component-specific:\n   * ```typescript\n   * const title = this.content.getText('MyComponent', 'title');\n   * ```\n   *\n   * @example Global content:\n   * ```typescript\n   * const okText = this.content.getText('ok'); // First parameter is the key\n   * // or more explicitly:\n   * const okText = this.content.getGlobalText('ok');\n   * ```\n   */\n  getText(className: string, key?: string, fallback?: string): string;\n  getText(key: string, fallback?: string): string;\n  getText(classNameOrKey: string, keyOrFallback?: string, fallback?: string): string {\n    // Handle overloaded signatures\n    if (\n      keyOrFallback === undefined ||\n      (typeof keyOrFallback === 'string' && fallback === undefined)\n    ) {\n      // Single parameter or two parameters (key, fallback) - treat as global content\n      return this.langService.getText('_global', classNameOrKey, keyOrFallback);\n    } else {\n      // Three parameters (className, key, fallback) - treat as component content\n      return this.langService.getText(classNameOrKey, keyOrFallback, fallback);\n    }\n  }\n\n  /**\n   * Get a single global content string synchronously.\n   * This is a convenience method that's equivalent to getText(key, fallback).\n   *\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   * @example\n   * ```typescript\n   * const okText = this.content.getGlobalText('ok');\n   * const cancelText = this.content.getGlobalText('cancel', 'Cancel');\n   * ```\n   */\n  getGlobalText(key: string, fallback?: string): string {\n    return this.langService.getText('_global', key, fallback);\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   * @example\n   * ```typescript\n   * if (this.content.hasContent('MyComponent', 'optionalText')) {\n   *   // Show optional content\n   * }\n   * ```\n   */\n  hasContent(className: string, key: string): boolean {\n    return this.langService.hasContent(className, key);\n  }\n\n  /**\n   * Helper function to interpolate values into a content string.\n   * Useful for processing content strings manually.\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 = this.content.interpolate(\"Hello {name}!\", { name: \"World\" });\n   * // Returns: \"Hello World!\"\n   * ```\n   */\n  interpolate(content: string, values?: Record<string, string | number>): string {\n    return interpolateContent(content, values);\n  }\n\n  /**\n   * Create a content helper bound to a specific component class.\n   * This provides a scoped API for components that need multiple content strings.\n   *\n   * @param className - The component class name\n   * @returns Content helper with methods scoped to the class\n   *\n   * @example\n   * ```typescript\n   * export class MyComponent {\n   *   private contentHelper = this.content.createHelper('MyComponent');\n   *\n   *   ngOnInit() {\n   *     this.title$ = this.contentHelper.get('title');\n   *     this.allContent$ = this.contentHelper.getMultiple(['title', 'description']);\n   *   }\n   *\n   *   constructor(private content: ContentService) {}\n   * }\n   * ```\n   */\n  createHelper(className: string) {\n    return createContentHelper(this.langService, className);\n  }\n\n  /**\n   * Create a scoped content service for a specific component class.\n   * This provides an even more convenient API for components with many content needs.\n   *\n   * @param className - The component class name\n   * @returns Scoped content service\n   *\n   * @example\n   * ```typescript\n   * export class MyComponent {\n   *   private content = inject(ContentService).forComponent('MyComponent');\n   *\n   *   // Simple content\n   *   title$ = this.content.get('title');\n   *\n   *   // Content with interpolation\n   *   greeting$ = this.content.get('greeting', {\n   *     interpolation: { name: 'John' }\n   *   });\n   *\n   *   // Content with fallback\n   *   subtitle$ = this.content.get('subtitle', {\n   *     fallback: 'Default Subtitle'\n   *   });\n   *\n   *   // Multiple texts\n   *   allTexts$ = this.content.getMultiple(['title', 'subtitle', 'description']);\n   *\n   *   constructor() {}\n   * }\n   * ```\n   */\n  forComponent(className: string) {\n    return {\n      /**\n       * Get a single content string reactively for this component.\n       * Supports optional interpolation.\n       */\n      get: (\n        key: string,\n        options?: { fallback?: string; interpolation?: Record<string, string | number> }\n      ): Observable<string> => {\n        return this.fromContent({\n          className,\n          key,\n          fallback: options?.fallback,\n          interpolation: options?.interpolation,\n        });\n      },\n\n      /**\n       * Get content with interpolation for this component.\n       * @deprecated Use get() with interpolation option instead.\n       */\n      getWithInterpolation: (\n        key: string,\n        interpolation: Record<string, string | number>,\n        fallback?: string\n      ): Observable<string> => {\n        return this.fromContent({\n          className,\n          key,\n          interpolation,\n          fallback,\n        });\n      },\n\n      /**\n       * Get multiple content strings for this component.\n       */\n      getMultiple: (keys: string[]): Observable<Record<string, string>> => {\n        return this.fromMultipleContent(className, keys);\n      },\n\n      /**\n       * Get a single content string synchronously for this component.\n       */\n      getText: (key: string, fallback?: string): string => {\n        return this.getText(className, key, fallback);\n      },\n\n      /**\n       * Check if a content key exists for this component.\n       */\n      hasContent: (key: string): boolean => {\n        return this.hasContent(className, key);\n      },\n    };\n  }\n}\n"]}

package/esm2022/lib/services/icons.service.mjs

@@ -5,7 +5,7 @@
  */
 import { Injectable } from '@angular/core';
 import { addIcons } from 'ionicons';
-import { addCircleOutline, addOutline, alertCircleOutline, alertOutline, arrowBackOutline, arrowDownOutline, arrowForwardOutline, businessOutline, calendarOutline, chatbubblesOutline, checkmarkCircleOutline, checkmarkOutline, chevronDownOutline, chevronForwardOutline, clipboardOutline, closeOutline, copyOutline, createOutline, documentTextOutline, ellipsisHorizontalOutline, eyeOffOutline, eyeOutline, filterOutline, heart, heartOutline, homeOutline, informationCircleOutline, locationOutline, lockClosedOutline, logoFacebook, logoInstagram, logoLinkedin, logoTiktok, logoTwitter, logoYoutube, notificationsOutline, openOutline, playOutline, refreshOutline, scanOutline, shareOutline, trashOutline, } from 'ionicons/icons';
+import { addCircleOutline, addOutline, alertCircleOutline, alertOutline, arrowBackOutline, arrowDownOutline, arrowForwardOutline, businessOutline, calendarOutline, chatbubblesOutline, checkmarkCircleOutline, checkmarkOutline, chevronDownOutline, chevronForwardOutline, clipboardOutline, closeOutline, copyOutline, createOutline, documentTextOutline, ellipsisHorizontalOutline, eyeOffOutline, eyeOutline, filterOutline, heart, heartOutline, homeOutline, informationCircleOutline, locationOutline, lockClosedOutline, logoFacebook, logoInstagram, logoLinkedin, logoNpm, logoTiktok, logoTwitter, logoYoutube, notificationsOutline, openOutline, playOutline, refreshOutline, scanOutline, shareOutline, trashOutline, } from 'ionicons/icons';
 import * as i0 from "@angular/core";
 export class IconService {
     /**
@@ -55,6 +55,7 @@ export class IconService {
             documentTextOutline,
             lockClosedOutline,
             informationCircleOutline,
+            logoNpm,
         });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IconService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -66,4 +67,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,8 +1,143 @@
+import GlobalContentExample from '../../components/_examples/global-content-example-content';
+import ReactiveContentExample from '../../components/_examples/reactive-content-example-content';
 import LangSettings from './components/lang-settings';
 import ThemeSettings from './components/theme-settings';
+import { TextContent } from './types';
+/**
+ * Global content that can be used across all components.
+ * These are common texts like buttons, actions, states, etc.
+ */
+const globalContentData = {
+    // Common buttons
+    ok: {
+        es: 'Aceptar',
+        en: 'OK',
+    },
+    cancel: {
+        es: 'Cancelar',
+        en: 'Cancel',
+    },
+    save: {
+        es: 'Guardar',
+        en: 'Save',
+    },
+    delete: {
+        es: 'Eliminar',
+        en: 'Delete',
+    },
+    edit: {
+        es: 'Editar',
+        en: 'Edit',
+    },
+    close: {
+        es: 'Cerrar',
+        en: 'Close',
+    },
+    back: {
+        es: 'Volver',
+        en: 'Back',
+    },
+    next: {
+        es: 'Siguiente',
+        en: 'Next',
+    },
+    previous: {
+        es: 'Anterior',
+        en: 'Previous',
+    },
+    finish: {
+        es: 'Finalizar',
+        en: 'Finish',
+    },
+    continue: {
+        es: 'Continuar',
+        en: 'Continue',
+    },
+    // Common actions
+    add: {
+        es: 'Agregar',
+        en: 'Add',
+    },
+    remove: {
+        es: 'Quitar',
+        en: 'Remove',
+    },
+    search: {
+        es: 'Buscar',
+        en: 'Search',
+    },
+    filter: {
+        es: 'Filtrar',
+        en: 'Filter',
+    },
+    sort: {
+        es: 'Ordenar',
+        en: 'Sort',
+    },
+    refresh: {
+        es: 'Actualizar',
+        en: 'Refresh',
+    },
+    // Common states and messages
+    loading: {
+        es: 'Cargando...',
+        en: 'Loading...',
+    },
+    noData: {
+        es: 'No hay datos disponibles',
+        en: 'No data available',
+    },
+    error: {
+        es: 'Error',
+        en: 'Error',
+    },
+    success: {
+        es: 'Éxito',
+        en: 'Success',
+    },
+    warning: {
+        es: 'Advertencia',
+        en: 'Warning',
+    },
+    info: {
+        es: 'Información',
+        en: 'Information',
+    },
+    // Common confirmations
+    areYouSure: {
+        es: '¿Estás seguro?',
+        en: 'Are you sure?',
+    },
+    deleteConfirmation: {
+        es: '¿Estás seguro de que deseas eliminar {itemName}?',
+        en: 'Are you sure you want to delete {itemName}?',
+    },
+    unsavedChanges: {
+        es: 'Tienes cambios sin guardar. ¿Deseas continuar?',
+        en: 'You have unsaved changes. Do you want to continue?',
+    },
+    // Common form labels
+    required: {
+        es: 'Requerido',
+        en: 'Required',
+    },
+    optional: {
+        es: 'Opcional',
+        en: 'Optional',
+    },
+    // Common placeholders
+    searchPlaceholder: {
+        es: 'Buscar...',
+        en: 'Search...',
+    },
+};
+const GlobalContent = new TextContent(globalContentData);
 const content = {
+    _global: GlobalContent,
     LangSettings,
     ThemeSettings,
+    ReactiveContentExample,
+    GlobalContentExample,
 };
 export default content;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRlY2gtY29tcG9uZW50cy9zcmMvbGliL3NlcnZpY2VzL2xhbmctcHJvdmlkZXIvY29udGVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLFlBQVksTUFBTSw0QkFBNEIsQ0FBQztBQUN0RCxPQUFPLGFBQWEsTUFBTSw2QkFBNkIsQ0FBQztBQU94RCxNQUFNLE9BQU8sR0FBYTtJQUN4QixZQUFZO0lBQ1osYUFBYTtDQUNkLENBQUM7QUFFRixlQUFlLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBMYW5nU2V0dGluZ3MgZnJvbSAnLi9jb21wb25lbnRzL2xhbmctc2V0dGluZ3MnO1xuaW1wb3J0IFRoZW1lU2V0dGluZ3MgZnJvbSAnLi9jb21wb25lbnRzL3RoZW1lLXNldHRpbmdzJztcbmltcG9ydCB7IFRleHRDb250ZW50IH0gZnJvbSAnLi90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvdmlkZXIge1xuICBbeDogc3RyaW5nXTogVGV4dENvbnRlbnQ7XG59XG5cbmNvbnN0IGNvbnRlbnQ6IFByb3ZpZGVyID0ge1xuICBMYW5nU2V0dGluZ3MsXG4gIFRoZW1lU2V0dGluZ3MsXG59O1xuXG5leHBvcnQgZGVmYXVsdCBjb250ZW50O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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