valtech-components 2.0.689 → 2.0.690

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,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

package/esm2022/lib/services/meta/index.mjs

@@ -0,0 +1,3 @@
+export * from './meta.service';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL21ldGEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWV0YS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19

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

@@ -0,0 +1,63 @@
+import { Injectable, inject } from '@angular/core';
+import { Meta, Title } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export class MetaService {
+    constructor() {
+        this.meta = inject(Meta);
+        this.titleService = inject(Title);
+        this.baseUrl = '';
+        this.defaultImage = '/assets/images/main-icon.png';
+        this.siteName = '';
+    }
+    /**
+     * Configurar el servicio con valores de la app
+     */
+    configure(config) {
+        this.baseUrl = config.baseUrl;
+        this.siteName = config.siteName;
+        if (config.defaultImage) {
+            this.defaultImage = config.defaultImage;
+        }
+    }
+    /**
+     * Actualizar meta tags de la página
+     */
+    updatePageMeta(metadata, path) {
+        const fullTitle = `${metadata.title} | ${this.siteName}`;
+        const url = path ? `${this.baseUrl}${path}` : this.baseUrl;
+        const ogImage = metadata.ogImage || this.defaultImage;
+        const fullImageUrl = ogImage.startsWith('http') ? ogImage : `${this.baseUrl}${ogImage}`;
+        // Title
+        this.titleService.setTitle(fullTitle);
+        // Basic meta tags
+        this.meta.updateTag({ name: 'description', content: metadata.description });
+        if (metadata.keywords) {
+            this.meta.updateTag({ name: 'keywords', content: metadata.keywords });
+        }
+        // Open Graph
+        this.meta.updateTag({ property: 'og:title', content: fullTitle });
+        this.meta.updateTag({ property: 'og:description', content: metadata.description });
+        this.meta.updateTag({ property: 'og:url', content: url });
+        this.meta.updateTag({ property: 'og:image', content: fullImageUrl });
+        this.meta.updateTag({ property: 'og:type', content: metadata.type || 'website' });
+        // Twitter Card
+        this.meta.updateTag({ name: 'twitter:title', content: fullTitle });
+        this.meta.updateTag({ name: 'twitter:description', content: metadata.description });
+        this.meta.updateTag({ name: 'twitter:image', content: fullImageUrl });
+    }
+    /**
+     * Resetear a valores por defecto
+     */
+    resetToDefault(metadata) {
+        this.updatePageMeta(metadata);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MetaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MetaService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MetaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/meta/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL21ldGEvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUGFnZU1ldGFkYXRhIHtcbiAgdGl0bGU6IHN0cmluZztcbiAgZGVzY3JpcHRpb246IHN0cmluZztcbiAga2V5d29yZHM/OiBzdHJpbmc7XG4gIG9nSW1hZ2U/OiBzdHJpbmc7XG4gIHR5cGU/OiAnd2Vic2l0ZScgfCAnYXJ0aWNsZSc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWV0YUNvbmZpZyB7XG4gIGJhc2VVcmw6IHN0cmluZztcbiAgc2l0ZU5hbWU6IHN0cmluZztcbiAgZGVmYXVsdEltYWdlPzogc3RyaW5nO1xufVxuIl19