valtech-components 2.0.821 → 2.0.824

package/esm2022/lib/services/link-processor.service.mjs

@@ -0,0 +1,259 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * LinkProcessorService - Service for processing text content to convert URLs and internal routes into clickable links.
+ *
+ * This service automatically detects external URLs (http/https), internal routes (starting with /),
+ * and Markdown-style links [text](url) and converts them into HTML anchor elements with appropriate attributes.
+ *
+ * @example Basic usage:
+ * ```typescript
+ * constructor(private linkProcessor: LinkProcessorService) {}
+ *
+ * processText() {
+ *   const text = 'Visit https://example.com, go to /profile, or [check docs](https://docs.example.com)';
+ *   const processed = this.linkProcessor.processLinks(text);
+ *   // Returns SafeHtml with clickable links
+ * }
+ * ```
+ */
+export class LinkProcessorService {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+        // Regex para detectar URLs completas (http/https) - captura toda la URL y luego limpiamos puntuación
+        this.urlRegex = /(https?:\/\/[^\s]+)/g;
+        // Regex para detectar rutas internas - captura toda la ruta y luego limpiamos puntuación
+        this.internalRouteRegex = /(\s|^)(\/[^\s]*)/g;
+        // Regex para detectar enlaces estilo Markdown [texto](url)
+        this.markdownLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    }
+    /**
+     * Limpia la puntuación del final de una URL.
+     * Mantiene caracteres válidos de URL pero remueve signos de puntuación comunes al final.
+     * Preserva parámetros de consulta, fragmentos y caracteres válidos en URLs.
+     */
+    cleanUrlPunctuation(url) {
+        // Caracteres que consideramos puntuación al final de oración, pero NO parte de URLs
+        // No incluimos & o = que son parte de query params, ni # que es parte de fragmentos
+        const trailingPunctuation = /[.,;!?)]+$/;
+        // Casos especiales: si la URL termina con paréntesis pero no tiene paréntesis de apertura
+        // probablemente el paréntesis no es parte de la URL
+        const hasOpeningParen = url.includes('(');
+        const endsWithClosingParen = url.endsWith(')');
+        if (endsWithClosingParen && !hasOpeningParen) {
+            // Remover el paréntesis de cierre si no hay uno de apertura
+            url = url.replace(/\)$/, '');
+        }
+        return url.replace(trailingPunctuation, '');
+    }
+    /**
+     * Procesa texto para convertir enlaces en elementos <a> clickeables.
+     * Detecta automáticamente URLs externas, rutas internas y enlaces estilo Markdown.
+     *
+     * @param text - Texto a procesar
+     * @param config - Configuración del procesamiento
+     * @returns SafeHtml con enlaces procesados o string original
+     *
+     * @example
+     * ```typescript
+     * const result = this.linkProcessor.processLinks(
+     *   'Visit https://example.com, go to /profile, or [check docs](https://docs.example.com)',
+     *   {
+     *     openExternalInNewTab: true,
+     *     openInternalInNewTab: false,
+     *     processMarkdownLinks: true,
+     *     linkClass: 'custom-link'
+     *   }
+     * );
+     * ```
+     */
+    processLinks(text, config = {}) {
+        if (!text)
+            return '';
+        const { openExternalInNewTab = true, openInternalInNewTab = false, linkClass = 'processed-link', externalLinkClass = 'external-link', internalLinkClass = 'internal-link', processMarkdownLinks = true, } = config;
+        let hasLinks = false;
+        let processedText = text;
+        // 1. Procesar enlaces estilo Markdown [texto](url) primero
+        if (processMarkdownLinks) {
+            // Usar exec en bucle (compatible con ES2018)
+            const markdownMatches = [];
+            this.markdownLinkRegex.lastIndex = 0;
+            let mdMatch;
+            while ((mdMatch = this.markdownLinkRegex.exec(processedText)) !== null) {
+                markdownMatches.push(mdMatch);
+            }
+            // Procesar de atrás hacia adelante para mantener las posiciones
+            for (let i = markdownMatches.length - 1; i >= 0; i--) {
+                const match = markdownMatches[i];
+                const [fullMatch, linkText, url] = match;
+                const startIndex = match.index;
+                const endIndex = startIndex + fullMatch.length;
+                hasLinks = true;
+                const isExternal = /^https?:\/\//.test(url);
+                const target = (isExternal ? openExternalInNewTab : openInternalInNewTab)
+                    ? isExternal
+                        ? ' target="_blank" rel="noopener noreferrer"'
+                        : ' target="_blank"'
+                    : '';
+                const typeClass = isExternal ? externalLinkClass : internalLinkClass;
+                const classes = `${linkClass} ${typeClass}`.trim();
+                const linkHtml = `<a href="${url}"${target} class="${classes}">${linkText}</a>`;
+                processedText =
+                    processedText.substring(0, startIndex) + linkHtml + processedText.substring(endIndex);
+            }
+        }
+        // 2. Procesar URLs externas directas
+        // Usar exec en bucle (compatible con ES2018)
+        const urlMatches = [];
+        this.urlRegex.lastIndex = 0;
+        let urlMatch;
+        while ((urlMatch = this.urlRegex.exec(processedText)) !== null) {
+            urlMatches.push(urlMatch);
+        }
+        // Procesar de atrás hacia adelante para mantener las posiciones
+        for (let i = urlMatches.length - 1; i >= 0; i--) {
+            const match = urlMatches[i];
+            const [fullMatch, url] = match;
+            const startIndex = match.index;
+            const endIndex = startIndex + fullMatch.length;
+            // Verificar que no esté ya dentro de un enlace HTML existente
+            const textBefore = processedText.substring(0, startIndex);
+            const lastOpenTag = textBefore.lastIndexOf('<a ');
+            const lastCloseTag = textBefore.lastIndexOf('</a>');
+            // Si hay un tag <a abierto sin cerrar, no procesamos
+            if (lastOpenTag > lastCloseTag) {
+                continue;
+            }
+            // Limpiar puntuación del final de la URL
+            const cleanUrl = this.cleanUrlPunctuation(url);
+            const punctuationRemoved = url !== cleanUrl;
+            const punctuation = punctuationRemoved ? url.substring(cleanUrl.length) : '';
+            hasLinks = true;
+            const target = openExternalInNewTab ? ' target="_blank" rel="noopener noreferrer"' : '';
+            const classes = `${linkClass} ${externalLinkClass}`.trim();
+            const linkHtml = `<a href="${cleanUrl}"${target} class="${classes}">${cleanUrl}</a>`;
+            // Reemplazar el URL original con el enlace + puntuación si existía
+            const replacement = punctuationRemoved ? linkHtml + punctuation : linkHtml;
+            processedText =
+                processedText.substring(0, startIndex) + replacement + processedText.substring(endIndex);
+        }
+        // 3. Procesar rutas internas
+        // Usar exec en bucle (compatible con ES2018)
+        const internalMatches = [];
+        this.internalRouteRegex.lastIndex = 0;
+        let internalMatch;
+        while ((internalMatch = this.internalRouteRegex.exec(processedText)) !== null) {
+            internalMatches.push(internalMatch);
+        }
+        // Procesar de atrás hacia adelante para mantener las posiciones
+        for (let i = internalMatches.length - 1; i >= 0; i--) {
+            const match = internalMatches[i];
+            const [fullMatch, prefix, route] = match;
+            const startIndex = match.index;
+            const endIndex = startIndex + fullMatch.length;
+            // Verificar que no esté ya dentro de un enlace HTML existente
+            const textBefore = processedText.substring(0, startIndex);
+            const lastOpenTag = textBefore.lastIndexOf('<a ');
+            const lastCloseTag = textBefore.lastIndexOf('</a>');
+            // Si hay un tag <a abierto sin cerrar, no procesamos
+            if (lastOpenTag > lastCloseTag) {
+                continue;
+            }
+            hasLinks = true;
+            const target = openInternalInNewTab ? ' target="_blank"' : '';
+            const classes = `${linkClass} ${internalLinkClass}`.trim();
+            const linkHtml = `<a href="${route}"${target} class="${classes}">${route}</a>`;
+            const replacement = `${prefix}${linkHtml}`;
+            processedText =
+                processedText.substring(0, startIndex) + replacement + processedText.substring(endIndex);
+        }
+        // Si hay enlaces, sanitizar el HTML
+        if (hasLinks) {
+            return this.sanitizer.bypassSecurityTrustHtml(processedText);
+        }
+        return text;
+    }
+    /**
+     * Detecta si un texto contiene enlaces (URLs, rutas internas o enlaces Markdown).
+     *
+     * @param text - Texto a analizar
+     * @returns true si contiene enlaces
+     *
+     * @example
+     * ```typescript
+     * const hasLinks = this.linkProcessor.hasLinks('Visit https://example.com or [docs](https://docs.com)');
+     * // Returns: true
+     * ```
+     */
+    hasLinks(text) {
+        if (!text)
+            return false;
+        // Reset regex indices
+        this.urlRegex.lastIndex = 0;
+        this.internalRouteRegex.lastIndex = 0;
+        this.markdownLinkRegex.lastIndex = 0;
+        return (this.urlRegex.test(text) ||
+            this.internalRouteRegex.test(text) ||
+            this.markdownLinkRegex.test(text));
+    }
+    /**
+     * Extrae todos los enlaces de un texto.
+     *
+     * @param text - Texto a analizar
+     * @returns Array de enlaces encontrados con su tipo y texto (si es Markdown)
+     *
+     * @example
+     * ```typescript
+     * const links = this.linkProcessor.extractLinks('Visit https://example.com, /profile, or [docs](https://docs.com)');
+     * // Returns: [
+     * //   { url: 'https://example.com', type: 'external', text: 'https://example.com' },
+     * //   { url: '/profile', type: 'internal', text: '/profile' },
+     * //   { url: 'https://docs.com', type: 'external', text: 'docs' }
+     * // ]
+     * ```
+     */
+    extractLinks(text) {
+        if (!text)
+            return [];
+        const links = [];
+        // Reset regex indices
+        this.urlRegex.lastIndex = 0;
+        this.internalRouteRegex.lastIndex = 0;
+        this.markdownLinkRegex.lastIndex = 0;
+        // Extraer enlaces Markdown primero
+        let match;
+        while ((match = this.markdownLinkRegex.exec(text)) !== null) {
+            const url = match[2];
+            const linkText = match[1];
+            const type = /^https?:\/\//.test(url) ? 'external' : 'internal';
+            links.push({ url, type, text: linkText });
+        }
+        // Extraer URLs externas directas
+        while ((match = this.urlRegex.exec(text)) !== null) {
+            const url = match[1];
+            // Verificar que no esté ya capturado como Markdown link
+            if (!links.some(link => link.url === url)) {
+                links.push({ url, type: 'external', text: url });
+            }
+        }
+        // Extraer rutas internas directas
+        while ((match = this.internalRouteRegex.exec(text)) !== null) {
+            const url = match[2];
+            // Verificar que no esté ya capturado como Markdown link
+            if (!links.some(link => link.url === url)) {
+                links.push({ url, type: 'internal', text: url });
+            }
+        }
+        return links;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LinkProcessorService, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LinkProcessorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LinkProcessorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link-processor.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/link-processor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\n\nexport interface LinkProcessorConfig {\n  /** Whether to open external links in new tab (default: true) */\n  openExternalInNewTab?: boolean;\n  /** Whether to open internal links in new tab (default: false) */\n  openInternalInNewTab?: boolean;\n  /** Custom CSS classes for links */\n  linkClass?: string;\n  /** Custom CSS classes for external links */\n  externalLinkClass?: string;\n  /** Custom CSS classes for internal links */\n  internalLinkClass?: string;\n  /** Whether to process Markdown-style links [text](url) (default: true) */\n  processMarkdownLinks?: boolean;\n}\n\n/**\n * LinkProcessorService - Service for processing text content to convert URLs and internal routes into clickable links.\n *\n * This service automatically detects external URLs (http/https), internal routes (starting with /),\n * and Markdown-style links [text](url) and converts them into HTML anchor elements with appropriate attributes.\n *\n * @example Basic usage:\n * ```typescript\n * constructor(private linkProcessor: LinkProcessorService) {}\n *\n * processText() {\n *   const text = 'Visit https://example.com, go to /profile, or [check docs](https://docs.example.com)';\n *   const processed = this.linkProcessor.processLinks(text);\n *   // Returns SafeHtml with clickable links\n * }\n * ```\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class LinkProcessorService {\n  // Regex para detectar URLs completas (http/https) - captura toda la URL y luego limpiamos puntuación\n  private readonly urlRegex = /(https?:\\/\\/[^\\s]+)/g;\n\n  // Regex para detectar rutas internas - captura toda la ruta y luego limpiamos puntuación\n  private readonly internalRouteRegex = /(\\s|^)(\\/[^\\s]*)/g;\n\n  // Regex para detectar enlaces estilo Markdown [texto](url)\n  private readonly markdownLinkRegex = /\\[([^\\]]+)\\]\\(([^)]+)\\)/g;\n\n  constructor(private sanitizer: DomSanitizer) {}\n\n  /**\n   * Limpia la puntuación del final de una URL.\n   * Mantiene caracteres válidos de URL pero remueve signos de puntuación comunes al final.\n   * Preserva parámetros de consulta, fragmentos y caracteres válidos en URLs.\n   */\n  private cleanUrlPunctuation(url: string): string {\n    // Caracteres que consideramos puntuación al final de oración, pero NO parte de URLs\n    // No incluimos & o = que son parte de query params, ni # que es parte de fragmentos\n    const trailingPunctuation = /[.,;!?)]+$/;\n\n    // Casos especiales: si la URL termina con paréntesis pero no tiene paréntesis de apertura\n    // probablemente el paréntesis no es parte de la URL\n    const hasOpeningParen = url.includes('(');\n    const endsWithClosingParen = url.endsWith(')');\n\n    if (endsWithClosingParen && !hasOpeningParen) {\n      // Remover el paréntesis de cierre si no hay uno de apertura\n      url = url.replace(/\\)$/, '');\n    }\n\n    return url.replace(trailingPunctuation, '');\n  }\n\n  /**\n   * Procesa texto para convertir enlaces en elementos <a> clickeables.\n   * Detecta automáticamente URLs externas, rutas internas y enlaces estilo Markdown.\n   *\n   * @param text - Texto a procesar\n   * @param config - Configuración del procesamiento\n   * @returns SafeHtml con enlaces procesados o string original\n   *\n   * @example\n   * ```typescript\n   * const result = this.linkProcessor.processLinks(\n   *   'Visit https://example.com, go to /profile, or [check docs](https://docs.example.com)',\n   *   {\n   *     openExternalInNewTab: true,\n   *     openInternalInNewTab: false,\n   *     processMarkdownLinks: true,\n   *     linkClass: 'custom-link'\n   *   }\n   * );\n   * ```\n   */\n  processLinks(text: string, config: LinkProcessorConfig = {}): SafeHtml | string {\n    if (!text) return '';\n\n    const {\n      openExternalInNewTab = true,\n      openInternalInNewTab = false,\n      linkClass = 'processed-link',\n      externalLinkClass = 'external-link',\n      internalLinkClass = 'internal-link',\n      processMarkdownLinks = true,\n    } = config;\n\n    let hasLinks = false;\n    let processedText = text;\n\n    // 1. Procesar enlaces estilo Markdown [texto](url) primero\n    if (processMarkdownLinks) {\n      // Usar exec en bucle (compatible con ES2018)\n      const markdownMatches: RegExpExecArray[] = [];\n      this.markdownLinkRegex.lastIndex = 0;\n      let mdMatch: RegExpExecArray | null;\n      while ((mdMatch = this.markdownLinkRegex.exec(processedText)) !== null) {\n        markdownMatches.push(mdMatch);\n      }\n\n      // Procesar de atrás hacia adelante para mantener las posiciones\n      for (let i = markdownMatches.length - 1; i >= 0; i--) {\n        const match = markdownMatches[i];\n        const [fullMatch, linkText, url] = match;\n        const startIndex = match.index!;\n        const endIndex = startIndex + fullMatch.length;\n\n        hasLinks = true;\n        const isExternal = /^https?:\\/\\//.test(url);\n        const target = (isExternal ? openExternalInNewTab : openInternalInNewTab)\n          ? isExternal\n            ? ' target=\"_blank\" rel=\"noopener noreferrer\"'\n            : ' target=\"_blank\"'\n          : '';\n        const typeClass = isExternal ? externalLinkClass : internalLinkClass;\n        const classes = `${linkClass} ${typeClass}`.trim();\n        const linkHtml = `<a href=\"${url}\"${target} class=\"${classes}\">${linkText}</a>`;\n\n        processedText =\n          processedText.substring(0, startIndex) + linkHtml + processedText.substring(endIndex);\n      }\n    }\n\n    // 2. Procesar URLs externas directas\n    // Usar exec en bucle (compatible con ES2018)\n    const urlMatches: RegExpExecArray[] = [];\n    this.urlRegex.lastIndex = 0;\n    let urlMatch: RegExpExecArray | null;\n    while ((urlMatch = this.urlRegex.exec(processedText)) !== null) {\n      urlMatches.push(urlMatch);\n    }\n\n    // Procesar de atrás hacia adelante para mantener las posiciones\n    for (let i = urlMatches.length - 1; i >= 0; i--) {\n      const match = urlMatches[i];\n      const [fullMatch, url] = match;\n      const startIndex = match.index!;\n      const endIndex = startIndex + fullMatch.length;\n\n      // Verificar que no esté ya dentro de un enlace HTML existente\n      const textBefore = processedText.substring(0, startIndex);\n      const lastOpenTag = textBefore.lastIndexOf('<a ');\n      const lastCloseTag = textBefore.lastIndexOf('</a>');\n\n      // Si hay un tag <a abierto sin cerrar, no procesamos\n      if (lastOpenTag > lastCloseTag) {\n        continue;\n      }\n\n      // Limpiar puntuación del final de la URL\n      const cleanUrl = this.cleanUrlPunctuation(url);\n      const punctuationRemoved = url !== cleanUrl;\n      const punctuation = punctuationRemoved ? url.substring(cleanUrl.length) : '';\n\n      hasLinks = true;\n      const target = openExternalInNewTab ? ' target=\"_blank\" rel=\"noopener noreferrer\"' : '';\n      const classes = `${linkClass} ${externalLinkClass}`.trim();\n      const linkHtml = `<a href=\"${cleanUrl}\"${target} class=\"${classes}\">${cleanUrl}</a>`;\n\n      // Reemplazar el URL original con el enlace + puntuación si existía\n      const replacement = punctuationRemoved ? linkHtml + punctuation : linkHtml;\n      processedText =\n        processedText.substring(0, startIndex) + replacement + processedText.substring(endIndex);\n    }\n\n    // 3. Procesar rutas internas\n    // Usar exec en bucle (compatible con ES2018)\n    const internalMatches: RegExpExecArray[] = [];\n    this.internalRouteRegex.lastIndex = 0;\n    let internalMatch: RegExpExecArray | null;\n    while ((internalMatch = this.internalRouteRegex.exec(processedText)) !== null) {\n      internalMatches.push(internalMatch);\n    }\n\n    // Procesar de atrás hacia adelante para mantener las posiciones\n    for (let i = internalMatches.length - 1; i >= 0; i--) {\n      const match = internalMatches[i];\n      const [fullMatch, prefix, route] = match;\n      const startIndex = match.index!;\n      const endIndex = startIndex + fullMatch.length;\n\n      // Verificar que no esté ya dentro de un enlace HTML existente\n      const textBefore = processedText.substring(0, startIndex);\n      const lastOpenTag = textBefore.lastIndexOf('<a ');\n      const lastCloseTag = textBefore.lastIndexOf('</a>');\n\n      // Si hay un tag <a abierto sin cerrar, no procesamos\n      if (lastOpenTag > lastCloseTag) {\n        continue;\n      }\n\n      hasLinks = true;\n      const target = openInternalInNewTab ? ' target=\"_blank\"' : '';\n      const classes = `${linkClass} ${internalLinkClass}`.trim();\n      const linkHtml = `<a href=\"${route}\"${target} class=\"${classes}\">${route}</a>`;\n\n      const replacement = `${prefix}${linkHtml}`;\n      processedText =\n        processedText.substring(0, startIndex) + replacement + processedText.substring(endIndex);\n    }\n\n    // Si hay enlaces, sanitizar el HTML\n    if (hasLinks) {\n      return this.sanitizer.bypassSecurityTrustHtml(processedText);\n    }\n\n    return text;\n  }\n\n  /**\n   * Detecta si un texto contiene enlaces (URLs, rutas internas o enlaces Markdown).\n   *\n   * @param text - Texto a analizar\n   * @returns true si contiene enlaces\n   *\n   * @example\n   * ```typescript\n   * const hasLinks = this.linkProcessor.hasLinks('Visit https://example.com or [docs](https://docs.com)');\n   * // Returns: true\n   * ```\n   */\n  hasLinks(text: string): boolean {\n    if (!text) return false;\n\n    // Reset regex indices\n    this.urlRegex.lastIndex = 0;\n    this.internalRouteRegex.lastIndex = 0;\n    this.markdownLinkRegex.lastIndex = 0;\n\n    return (\n      this.urlRegex.test(text) ||\n      this.internalRouteRegex.test(text) ||\n      this.markdownLinkRegex.test(text)\n    );\n  }\n\n  /**\n   * Extrae todos los enlaces de un texto.\n   *\n   * @param text - Texto a analizar\n   * @returns Array de enlaces encontrados con su tipo y texto (si es Markdown)\n   *\n   * @example\n   * ```typescript\n   * const links = this.linkProcessor.extractLinks('Visit https://example.com, /profile, or [docs](https://docs.com)');\n   * // Returns: [\n   * //   { url: 'https://example.com', type: 'external', text: 'https://example.com' },\n   * //   { url: '/profile', type: 'internal', text: '/profile' },\n   * //   { url: 'https://docs.com', type: 'external', text: 'docs' }\n   * // ]\n   * ```\n   */\n  extractLinks(text: string): Array<{ url: string; type: 'external' | 'internal'; text: string }> {\n    if (!text) return [];\n\n    const links: Array<{ url: string; type: 'external' | 'internal'; text: string }> = [];\n\n    // Reset regex indices\n    this.urlRegex.lastIndex = 0;\n    this.internalRouteRegex.lastIndex = 0;\n    this.markdownLinkRegex.lastIndex = 0;\n\n    // Extraer enlaces Markdown primero\n    let match;\n    while ((match = this.markdownLinkRegex.exec(text)) !== null) {\n      const url = match[2];\n      const linkText = match[1];\n      const type = /^https?:\\/\\//.test(url) ? 'external' : 'internal';\n      links.push({ url, type, text: linkText });\n    }\n\n    // Extraer URLs externas directas\n    while ((match = this.urlRegex.exec(text)) !== null) {\n      const url = match[1];\n      // Verificar que no esté ya capturado como Markdown link\n      if (!links.some(link => link.url === url)) {\n        links.push({ url, type: 'external', text: url });\n      }\n    }\n\n    // Extraer rutas internas directas\n    while ((match = this.internalRouteRegex.exec(text)) !== null) {\n      const url = match[2];\n      // Verificar que no esté ya capturado como Markdown link\n      if (!links.some(link => link.url === url)) {\n        links.push({ url, type: 'internal', text: url });\n      }\n    }\n\n    return links;\n  }\n}\n"]}

package/esm2022/lib/services/local-storage.service.mjs

@@ -0,0 +1,37 @@
+/**
+ * Utility service for interacting with browser localStorage in a type-safe way.
+ * Provides static methods for setting, getting, removing, and clearing items.
+ */
+export class LocalStorageService {
+    /**
+     * Stores a value in localStorage under the given reference key.
+     * @param reference The key to store the value under
+     * @param value The value to store
+     */
+    static set(reference, value) {
+        localStorage.setItem(reference, JSON.stringify(value));
+    }
+    /**
+     * Retrieves a value from localStorage by key.
+     * @param reference The key to retrieve
+     * @returns The parsed value
+     */
+    static get(reference) {
+        const value = localStorage.getItem(reference);
+        return JSON.parse(value);
+    }
+    /**
+     * Removes an item from localStorage by key.
+     * @param reference The key to remove
+     */
+    static remove(reference) {
+        localStorage.removeItem(reference);
+    }
+    /**
+     * Clears all items from localStorage.
+     */
+    static clear() {
+        localStorage.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Clave para persistir el idioma en localStorage
+ */
+const LANG_STORAGE_KEY = 'app_lang';
+/**
+ * Idioma por defecto
+ */
+const DEFAULT_LANG = 'es';
+/**
+ * Servicio mínimo de localización.
+ *
+ * - Lee el idioma desde localStorage al iniciar
+ * - Proporciona método para cambiar idioma (recarga la página)
+ * - Sin observables ni subscripciones
+ *
+ * @example
+ * // En un componente
+ * locale = inject(LocaleService);
+ *
+ * // Obtener idioma actual
+ * console.log(this.locale.lang); // 'es' o 'en'
+ *
+ * // Cambiar idioma (recarga la página)
+ * this.locale.setLang('en');
+ */
+export class LocaleService {
+    constructor() {
+        this.lang = this.getStoredLang();
+    }
+    /**
+     * Cambia el idioma de la aplicación.
+     * Guarda en localStorage y recarga la página para aplicar el cambio.
+     *
+     * @param lang Nuevo idioma ('es' o 'en')
+     */
+    setLang(lang) {
+        if (lang === this.lang) {
+            return;
+        }
+        localStorage.setItem(LANG_STORAGE_KEY, lang);
+        window.location.reload();
+    }
+    /**
+     * Obtiene el idioma almacenado en localStorage.
+     * Si no existe o no es válido, retorna el idioma por defecto.
+     */
+    getStoredLang() {
+        const stored = localStorage.getItem(LANG_STORAGE_KEY);
+        if (stored === 'es' || stored === 'en') {
+            return stored;
+        }
+        return DEFAULT_LANG;
+    }
+    /**
+     * Verifica si el idioma actual es español
+     */
+    get isSpanish() {
+        return this.lang === 'es';
+    }
+    /**
+     * Verifica si el idioma actual es inglés
+     */
+    get isEnglish() {
+        return this.lang === 'en';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocaleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocaleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocaleService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2xvY2FsZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzNDOztHQUVHO0FBQ0gsTUFBTSxnQkFBZ0IsR0FBRyxVQUFVLENBQUM7QUFFcEM7O0dBRUc7QUFDSCxNQUFNLFlBQVksR0FBa0IsSUFBSSxDQUFDO0FBRXpDOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBRUgsTUFBTSxPQUFPLGFBQWE7SUFPeEI7UUFDRSxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztJQUNuQyxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxPQUFPLENBQUMsSUFBbUI7UUFDekIsSUFBSSxJQUFJLEtBQUssSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3ZCLE9BQU87UUFDVCxDQUFDO1FBQ0QsWUFBWSxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUM3QyxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7O09BR0c7SUFDSyxhQUFhO1FBQ25CLE1BQU0sTUFBTSxHQUFHLFlBQVksQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUN0RCxJQUFJLE1BQU0sS0FBSyxJQUFJLElBQUksTUFBTSxLQUFLLElBQUksRUFBRSxDQUFDO1lBQ3ZDLE9BQU8sTUFBTSxDQUFDO1FBQ2hCLENBQUM7UUFDRCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLFNBQVM7UUFDWCxPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDO0lBQzVCLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUksU0FBUztRQUNYLE9BQU8sSUFBSSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUM7SUFDNUIsQ0FBQzsrR0FqRFUsYUFBYTttSEFBYixhQUFhLGNBREEsTUFBTTs7NEZBQ25CLGFBQWE7a0JBRHpCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFRpcG9zIGRlIGlkaW9tYSBzb3BvcnRhZG9zXG4gKi9cbmV4cG9ydCB0eXBlIFN1cHBvcnRlZExhbmcgPSAnZXMnIHwgJ2VuJztcblxuLyoqXG4gKiBDbGF2ZSBwYXJhIHBlcnNpc3RpciBlbCBpZGlvbWEgZW4gbG9jYWxTdG9yYWdlXG4gKi9cbmNvbnN0IExBTkdfU1RPUkFHRV9LRVkgPSAnYXBwX2xhbmcnO1xuXG4vKipcbiAqIElkaW9tYSBwb3IgZGVmZWN0b1xuICovXG5jb25zdCBERUZBVUxUX0xBTkc6IFN1cHBvcnRlZExhbmcgPSAnZXMnO1xuXG4vKipcbiAqIFNlcnZpY2lvIG3DrW5pbW8gZGUgbG9jYWxpemFjacOzbi5cbiAqXG4gKiAtIExlZSBlbCBpZGlvbWEgZGVzZGUgbG9jYWxTdG9yYWdlIGFsIGluaWNpYXJcbiAqIC0gUHJvcG9yY2lvbmEgbcOpdG9kbyBwYXJhIGNhbWJpYXIgaWRpb21hIChyZWNhcmdhIGxhIHDDoWdpbmEpXG4gKiAtIFNpbiBvYnNlcnZhYmxlcyBuaSBzdWJzY3JpcGNpb25lc1xuICpcbiAqIEBleGFtcGxlXG4gKiAvLyBFbiB1biBjb21wb25lbnRlXG4gKiBsb2NhbGUgPSBpbmplY3QoTG9jYWxlU2VydmljZSk7XG4gKlxuICogLy8gT2J0ZW5lciBpZGlvbWEgYWN0dWFsXG4gKiBjb25zb2xlLmxvZyh0aGlzLmxvY2FsZS5sYW5nKTsgLy8gJ2VzJyBvICdlbidcbiAqXG4gKiAvLyBDYW1iaWFyIGlkaW9tYSAocmVjYXJnYSBsYSBww6FnaW5hKVxuICogdGhpcy5sb2NhbGUuc2V0TGFuZygnZW4nKTtcbiAqL1xuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBMb2NhbGVTZXJ2aWNlIHtcbiAgLyoqXG4gICAqIElkaW9tYSBhY3R1YWwgZGUgbGEgYXBsaWNhY2nDs24uXG4gICAqIFNlIGxlZSB1bmEgdmV6IGFsIGluaWNpYXIgZGVzZGUgbG9jYWxTdG9yYWdlLlxuICAgKi9cbiAgcmVhZG9ubHkgbGFuZzogU3VwcG9ydGVkTGFuZztcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICB0aGlzLmxhbmcgPSB0aGlzLmdldFN0b3JlZExhbmcoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDYW1iaWEgZWwgaWRpb21hIGRlIGxhIGFwbGljYWNpw7NuLlxuICAgKiBHdWFyZGEgZW4gbG9jYWxTdG9yYWdlIHkgcmVjYXJnYSBsYSBww6FnaW5hIHBhcmEgYXBsaWNhciBlbCBjYW1iaW8uXG4gICAqXG4gICAqIEBwYXJhbSBsYW5nIE51ZXZvIGlkaW9tYSAoJ2VzJyBvICdlbicpXG4gICAqL1xuICBzZXRMYW5nKGxhbmc6IFN1cHBvcnRlZExhbmcpOiB2b2lkIHtcbiAgICBpZiAobGFuZyA9PT0gdGhpcy5sYW5nKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIGxvY2FsU3RvcmFnZS5zZXRJdGVtKExBTkdfU1RPUkFHRV9LRVksIGxhbmcpO1xuICAgIHdpbmRvdy5sb2NhdGlvbi5yZWxvYWQoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBPYnRpZW5lIGVsIGlkaW9tYSBhbG1hY2VuYWRvIGVuIGxvY2FsU3RvcmFnZS5cbiAgICogU2kgbm8gZXhpc3RlIG8gbm8gZXMgdsOhbGlkbywgcmV0b3JuYSBlbCBpZGlvbWEgcG9yIGRlZmVjdG8uXG4gICAqL1xuICBwcml2YXRlIGdldFN0b3JlZExhbmcoKTogU3VwcG9ydGVkTGFuZyB7XG4gICAgY29uc3Qgc3RvcmVkID0gbG9jYWxTdG9yYWdlLmdldEl0ZW0oTEFOR19TVE9SQUdFX0tFWSk7XG4gICAgaWYgKHN0b3JlZCA9PT0gJ2VzJyB8fCBzdG9yZWQgPT09ICdlbicpIHtcbiAgICAgIHJldHVybiBzdG9yZWQ7XG4gICAgfVxuICAgIHJldHVybiBERUZBVUxUX0xBTkc7XG4gIH1cblxuICAvKipcbiAgICogVmVyaWZpY2Egc2kgZWwgaWRpb21hIGFjdHVhbCBlcyBlc3Bhw7FvbFxuICAgKi9cbiAgZ2V0IGlzU3BhbmlzaCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5sYW5nID09PSAnZXMnO1xuICB9XG5cbiAgLyoqXG4gICAqIFZlcmlmaWNhIHNpIGVsIGlkaW9tYSBhY3R1YWwgZXMgaW5nbMOpc1xuICAgKi9cbiAgZ2V0IGlzRW5nbGlzaCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5sYW5nID09PSAnZW4nO1xuICB9XG59XG4iXX0=

package/esm2022/lib/services/markdown-article/legal-content.service.mjs

@@ -0,0 +1,107 @@
+import { HttpClient } from '@angular/common/http';
+import { InjectionToken, Injectable, inject } from '@angular/core';
+import { catchError, from, map, of, shareReplay, switchMap, throwError } from 'rxjs';
+import { MarkdownArticleParserService } from './markdown-article-parser.service';
+import * as i0 from "@angular/core";
+export const LEGAL_CONTENT_CONFIG = new InjectionToken('LEGAL_CONTENT_CONFIG');
+/**
+ * Loads legal articles via one of two modes:
+ *
+ * 1. **Build-time** (preferred): when the app provides `LEGAL_CONTENT_CONFIG.factories`
+ *    via `provideLegalContent()`, the service dynamically imports the matching
+ *    locale module and returns the pre-parsed `ArticleMetadata` synchronously
+ *    (wrapped in an Observable). Each locale is code-split.
+ *
+ * 2. **Runtime**: when no factory matches, falls back to fetching
+ *    `/assets/legal/{locale}/{slug}.md` and parsing on the fly.
+ *
+ * Both modes cache by `locale:slug` so concurrent loads share one promise/HTTP request.
+ */
+export class LegalContentService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.parser = inject(MarkdownArticleParserService);
+        this.config = inject(LEGAL_CONTENT_CONFIG, { optional: true }) ?? {};
+        this.DEFAULT_BASE = '/assets/legal';
+        this.cache = new Map();
+        this.factoryCache = new Map();
+    }
+    load(slug, options = {}) {
+        const locale = (options.locale ?? 'es').toLowerCase();
+        const fallback = options.fallbackLocale === undefined
+            ? (this.config.fallbackLocale ?? 'es')
+            : options.fallbackLocale;
+        const key = `${locale}|${slug}`;
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const primary = this.loadOne(slug, locale, options.basePath);
+        const stream = fallback && fallback !== locale
+            ? primary.pipe(catchError(() => this.loadOne(slug, fallback, options.basePath)))
+            : primary;
+        const shared = stream.pipe(shareReplay({ bufferSize: 1, refCount: false }));
+        this.cache.set(key, shared);
+        return shared;
+    }
+    /** Raw Markdown — only available in runtime mode (HTTP). */
+    raw(slug, options = {}) {
+        const locale = (options.locale ?? 'es').toLowerCase();
+        const base = options.basePath ?? this.config.basePath ?? this.DEFAULT_BASE;
+        return this.http.get(`${base}/${locale}/${slug}.md`, { responseType: 'text' });
+    }
+    /** Clears in-memory caches. Call on runtime locale change. */
+    invalidate() {
+        this.cache.clear();
+        this.factoryCache.clear();
+    }
+    loadOne(slug, locale, basePathOverride) {
+        const factory = this.config.factories?.[locale];
+        if (factory) {
+            return from(this.runFactory(locale, factory)).pipe(switchMap(content => {
+                const article = content[slug];
+                return article
+                    ? of(article)
+                    : throwError(() => new Error(`Legal doc not found: ${locale}/${slug}`));
+            }));
+        }
+        const base = basePathOverride ?? this.config.basePath ?? this.DEFAULT_BASE;
+        return this.fetchAndParse(`${base}/${locale}/${slug}.md`);
+    }
+    runFactory(locale, factory) {
+        const cached = this.factoryCache.get(locale);
+        if (cached)
+            return cached;
+        const promise = factory();
+        this.factoryCache.set(locale, promise);
+        return promise;
+    }
+    fetchAndParse(url) {
+        return this.http.get(url, { responseType: 'text' }).pipe(switchMap(md => md && md.trim().length > 0
+            ? of(this.parser.parse(md))
+            : throwError(() => new Error(`Empty legal doc: ${url}`))), map(parsed => parsed));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LegalContentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LegalContentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LegalContentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * Wires pre-generated legal content into `LegalContentService`. Call from `main.ts`
+ * (or any `providers: []` array). The factories use dynamic `import()` so each
+ * locale is code-split — only the active locale's bundle is loaded.
+ *
+ * @example
+ * provideLegalContent({
+ *   factories: {
+ *     es: () => import('./app/generated/legal-content.es').then((m) => m.LEGAL_CONTENT_ES),
+ *     en: () => import('./app/generated/legal-content.en').then((m) => m.LEGAL_CONTENT_EN),
+ *     pt: () => import('./app/generated/legal-content.pt').then((m) => m.LEGAL_CONTENT_PT),
+ *   },
+ * })
+ */
+export function provideLegalContent(config) {
+    return { provide: LEGAL_CONTENT_CONFIG, useValue: config };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"legal-content.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/markdown-article/legal-content.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { InjectionToken, Injectable, Provider, inject } from '@angular/core';\nimport { Observable, catchError, from, map, of, shareReplay, switchMap, throwError } from 'rxjs';\nimport { ArticleMetadata } from '../../components/organisms/article/types';\nimport { MarkdownArticleParserService } from './markdown-article-parser.service';\n\nexport type LegalSlug = 'terms' | 'privacy' | 'cookies' | 'data-usage' | 'legal-notice' | string;\n\n/**\n * Factory that returns a Record<slug, ArticleMetadata> for a given locale.\n * Use a dynamic `import()` so each locale module is code-split by the bundler.\n */\nexport type LegalContentFactory = () => Promise<Record<string, ArticleMetadata>>;\n\nexport interface LegalContentConfig {\n  /** Pre-generated content factories keyed by locale (e.g. `{ es: () => import('./generated/legal-content.es') ... }`). */\n  factories?: Record<string, LegalContentFactory>;\n  /** Override default `/assets/legal` base path used when no factory matches. */\n  basePath?: string;\n  /** Fallback locale (default `es`). Set null to disable. */\n  fallbackLocale?: string | null;\n}\n\nexport const LEGAL_CONTENT_CONFIG = new InjectionToken<LegalContentConfig>('LEGAL_CONTENT_CONFIG');\n\nexport interface LegalLoadOptions {\n  /** Two-letter locale code (es, en, pt). */\n  locale?: string;\n  /** Override base path for runtime mode (default `/assets/legal`). */\n  basePath?: string;\n  /** Fallback locale tried when the requested one is missing. Set null to disable. */\n  fallbackLocale?: string | null;\n}\n\n/**\n * Loads legal articles via one of two modes:\n *\n * 1. **Build-time** (preferred): when the app provides `LEGAL_CONTENT_CONFIG.factories`\n *    via `provideLegalContent()`, the service dynamically imports the matching\n *    locale module and returns the pre-parsed `ArticleMetadata` synchronously\n *    (wrapped in an Observable). Each locale is code-split.\n *\n * 2. **Runtime**: when no factory matches, falls back to fetching\n *    `/assets/legal/{locale}/{slug}.md` and parsing on the fly.\n *\n * Both modes cache by `locale:slug` so concurrent loads share one promise/HTTP request.\n */\n@Injectable({ providedIn: 'root' })\nexport class LegalContentService {\n  private readonly http = inject(HttpClient);\n  private readonly parser = inject(MarkdownArticleParserService);\n  private readonly config = inject(LEGAL_CONTENT_CONFIG, { optional: true }) ?? {};\n\n  private readonly DEFAULT_BASE = '/assets/legal';\n  private readonly cache = new Map<string, Observable<ArticleMetadata>>();\n  private readonly factoryCache = new Map<string, Promise<Record<string, ArticleMetadata>>>();\n\n  load(slug: LegalSlug, options: LegalLoadOptions = {}): Observable<ArticleMetadata> {\n    const locale = (options.locale ?? 'es').toLowerCase();\n    const fallback =\n      options.fallbackLocale === undefined\n        ? (this.config.fallbackLocale ?? 'es')\n        : options.fallbackLocale;\n\n    const key = `${locale}|${slug}`;\n    const cached = this.cache.get(key);\n    if (cached) return cached;\n\n    const primary = this.loadOne(slug, locale, options.basePath);\n    const stream =\n      fallback && fallback !== locale\n        ? primary.pipe(catchError(() => this.loadOne(slug, fallback, options.basePath)))\n        : primary;\n\n    const shared = stream.pipe(shareReplay({ bufferSize: 1, refCount: false }));\n    this.cache.set(key, shared);\n    return shared;\n  }\n\n  /** Raw Markdown — only available in runtime mode (HTTP). */\n  raw(slug: LegalSlug, options: LegalLoadOptions = {}): Observable<string> {\n    const locale = (options.locale ?? 'es').toLowerCase();\n    const base = options.basePath ?? this.config.basePath ?? this.DEFAULT_BASE;\n    return this.http.get(`${base}/${locale}/${slug}.md`, { responseType: 'text' });\n  }\n\n  /** Clears in-memory caches. Call on runtime locale change. */\n  invalidate(): void {\n    this.cache.clear();\n    this.factoryCache.clear();\n  }\n\n  private loadOne(\n    slug: string,\n    locale: string,\n    basePathOverride?: string\n  ): Observable<ArticleMetadata> {\n    const factory = this.config.factories?.[locale];\n    if (factory) {\n      return from(this.runFactory(locale, factory)).pipe(\n        switchMap(content => {\n          const article = content[slug];\n          return article\n            ? of(article)\n            : throwError(() => new Error(`Legal doc not found: ${locale}/${slug}`));\n        })\n      );\n    }\n    const base = basePathOverride ?? this.config.basePath ?? this.DEFAULT_BASE;\n    return this.fetchAndParse(`${base}/${locale}/${slug}.md`);\n  }\n\n  private runFactory(\n    locale: string,\n    factory: LegalContentFactory\n  ): Promise<Record<string, ArticleMetadata>> {\n    const cached = this.factoryCache.get(locale);\n    if (cached) return cached;\n    const promise = factory();\n    this.factoryCache.set(locale, promise);\n    return promise;\n  }\n\n  private fetchAndParse(url: string): Observable<ArticleMetadata> {\n    return this.http.get(url, { responseType: 'text' }).pipe(\n      switchMap(md =>\n        md && md.trim().length > 0\n          ? of(this.parser.parse(md))\n          : throwError(() => new Error(`Empty legal doc: ${url}`))\n      ),\n      map(parsed => parsed)\n    );\n  }\n}\n\n/**\n * Wires pre-generated legal content into `LegalContentService`. Call from `main.ts`\n * (or any `providers: []` array). The factories use dynamic `import()` so each\n * locale is code-split — only the active locale's bundle is loaded.\n *\n * @example\n * provideLegalContent({\n *   factories: {\n *     es: () => import('./app/generated/legal-content.es').then((m) => m.LEGAL_CONTENT_ES),\n *     en: () => import('./app/generated/legal-content.en').then((m) => m.LEGAL_CONTENT_EN),\n *     pt: () => import('./app/generated/legal-content.pt').then((m) => m.LEGAL_CONTENT_PT),\n *   },\n * })\n */\nexport function provideLegalContent(config: LegalContentConfig): Provider {\n  return { provide: LEGAL_CONTENT_CONFIG, useValue: config };\n}\n"]}