valtech-components 2.0.325 → 2.0.328

package/lib/services/content.service.d.ts

@@ -1,296 +0,0 @@
-import { Observable } from 'rxjs';
-import { ContentConfig, InterpolatedContentConfig } from '../shared/utils/content';
-import { LangService } from './lang-provider/lang-provider.service';
-import { LangOption } from './lang-provider/types';
-import * as i0 from "@angular/core";
-/**
- * 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 declare class ContentService {
-    private langService;
-    constructor(langService: LangService);
-    /**
-     * Get current language as an observable stream.
-     * Emits whenever the language changes.
-     */
-    get currentLang$(): Observable<LangOption>;
-    /**
-     * Get current language synchronously.
-     */
-    get currentLang(): LangOption;
-    /**
-     * Set the current language.
-     * This will trigger updates in all reactive content.
-     *
-     * @param lang - The language to set
-     */
-    setLang(lang: LangOption): void;
-    /**
-     * 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: ContentConfig): Observable<string>;
-    /**
-     * 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: InterpolatedContentConfig | Omit<InterpolatedContentConfig, 'className'>): Observable<string>;
-    /**
-     * 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: string, keys: string[]): Observable<Record<string, string>>;
-    /**
-     * Get a single content string synchronously for the current language.
-     *
-     * @param className - The component class name. If omitted, searches in global content.
-     * @param key - The text key
-     * @param fallback - Optional fallback text if key is not found
-     * @returns The text string or fallback
-     *
-     * @example Component-specific:
-     * ```typescript
-     * const title = this.content.getText('MyComponent', 'title');
-     * ```
-     *
-     * @example Global content:
-     * ```typescript
-     * const okText = this.content.getText('ok'); // First parameter is the key
-     * // or more explicitly:
-     * const okText = this.content.getGlobalText('ok');
-     * ```
-     */
-    getText(className: string, key?: string, fallback?: string): string;
-    getText(key: string, fallback?: string): string;
-    /**
-     * 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: string, fallback?: string): string;
-    /**
-     * 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: string, key: string): boolean;
-    /**
-     * 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: string, values?: Record<string, string | number>): string;
-    /**
-     * 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: string): {
-        get(key: string, fallback?: string): Observable<string>;
-        getMultiple(keys: string[]): Observable<Record<string, string>>;
-        getWithInterpolation(key: string, interpolation: Record<string, string | number>, fallback?: string): Observable<string>;
-        getText(key: string, fallback?: string): string;
-        hasContent(key: string): boolean;
-    };
-    /**
-     * 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: string): {
-        /**
-         * Get a single content string reactively for this component.
-         * Supports optional interpolation.
-         */
-        get: (key: string, options?: {
-            fallback?: string;
-            interpolation?: Record<string, string | number>;
-        }) => Observable<string>;
-        /**
-         * Get content with interpolation for this component.
-         * @deprecated Use get() with interpolation option instead.
-         */
-        getWithInterpolation: (key: string, interpolation: Record<string, string | number>, fallback?: string) => Observable<string>;
-        /**
-         * Get multiple content strings for this component.
-         */
-        getMultiple: (keys: string[]) => Observable<Record<string, string>>;
-        /**
-         * Get a single content string synchronously for this component.
-         */
-        getText: (key: string, fallback?: string) => string;
-        /**
-         * Check if a content key exists for this component.
-         */
-        hasContent: (key: string) => boolean;
-    };
-    static ɵfac: i0.ɵɵFactoryDeclaration<ContentService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ContentService>;
-}

package/lib/shared/utils/reactive-content.d.ts

@@ -1,109 +0,0 @@
-/**
- * Enhanced content utilities for multi-language component support.
- * Extends the base content utilities to provide specialized helpers for different component patterns.
- */
-import { Observable } from 'rxjs';
-import { ContentService } from '../../services/content.service';
-/**
- * Base configuration for reactive content.
- */
-export interface ReactiveContentConfig {
-    /** Content class name - defaults to '_global' if not provided */
-    className?: string;
-    /** Content key */
-    key: string;
-    /** Fallback text if content is not found */
-    fallback?: string;
-    /** Interpolation data for parameterized content */
-    interpolation?: Record<string, any>;
-}
-/**
- * Configuration for components that support both static and reactive content.
- */
-export interface HybridContentConfig {
-    /** Static content - takes precedence over reactive content */
-    content?: string;
-    /** Reactive content configuration */
-    contentConfig?: ReactiveContentConfig;
-}
-/**
- * Configuration for components with multiple text properties.
- */
-export interface MultiTextConfig {
-    /** Map of property names to their content configurations */
-    textConfigs: Record<string, ReactiveContentConfig>;
-}
-/**
- * Enhanced metadata for components that support reactive content.
- */
-export interface ReactiveTextMetadata extends HybridContentConfig {
-    size?: 'small' | 'medium' | 'large' | 'xlarge';
-    color?: string;
-    bold?: boolean;
-    processLinks?: boolean;
-    linkConfig?: any;
-}
-/**
- * Helper class for managing reactive content in components.
- */
-export declare class ComponentContentHelper {
-    private contentService;
-    private defaultClassName?;
-    constructor(contentService: ContentService, defaultClassName?: string);
-    /**
-     * Resolves content based on hybrid configuration (static vs reactive).
-     */
-    resolveContent(config: HybridContentConfig): Observable<string> | string;
-    /**
-     * Resolves multiple text properties for components with multiple text fields.
-     */
-    resolveMultipleTexts(config: MultiTextConfig): Record<string, Observable<string>>;
-    /**
-     * Creates a reactive content configuration for array items.
-     * Useful for list components where items might have translatable text.
-     */
-    createArrayItemConfig(baseKey: string, index: number, fallback?: string): ReactiveContentConfig;
-    /**
-     * Helper for button/action text that commonly needs translation.
-     */
-    createActionConfig(actionKey: 'ok' | 'cancel' | 'save' | 'delete' | 'edit' | 'close' | 'back' | 'next' | 'previous' | 'finish' | 'continue' | 'add' | 'remove' | 'search' | 'filter' | 'sort' | 'refresh', fallback?: string): ReactiveContentConfig;
-}
-/**
- * Factory function to create content helpers for components.
- */
-export declare function createComponentContentHelper(contentService: ContentService, componentClassName?: string): ComponentContentHelper;
-/**
- * Utility function to determine if content should be reactive.
- */
-export declare function shouldUseReactiveContent(config: HybridContentConfig): boolean;
-/**
- * Enhanced props factory for components that support reactive content.
- */
-export declare function createReactiveProps<T extends Record<string, any>>(contentHelper: ComponentContentHelper, staticProps: Omit<T, keyof HybridContentConfig>, contentConfig: HybridContentConfig): T;
-/**
- * Configuration for list components that mix static and dynamic content.
- */
-export interface ListComponentConfig<T> {
-    /** Static items that don't need translation */
-    staticItems?: T[];
-    /** Reactive items configuration */
-    reactiveItems?: {
-        /** Base key for the items (e.g., 'navigationLinks') */
-        baseKey: string;
-        /** Number of items expected */
-        count: number;
-        /** Template for creating individual items */
-        itemTemplate: (contentHelper: ComponentContentHelper, index: number) => T;
-    };
-}
-/**
- * Helper for list components that need to mix static and reactive content.
- */
-export declare class ListContentHelper<T> {
-    private contentHelper;
-    constructor(contentHelper: ComponentContentHelper);
-    /**
-     * Resolves a list configuration into final items.
-     */
-    resolveListItems(config: ListComponentConfig<T>): T[];
-}