valtech-components 2.0.795 → 2.0.796

package/lib/services/i18n/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Idiomas soportados por el sistema i18n
+ */
+export type I18nLang = 'es' | 'en' | 'pt' | 'fr' | 'de';
+/**
+ * Contenido de traducciones para un namespace
+ *
+ * @example
+ * const loginContent: LanguagesContent = {
+ *   es: { title: 'Iniciar sesión', submit: 'Entrar' },
+ *   en: { title: 'Sign in', submit: 'Sign in' }
+ * };
+ */
+export type LanguagesContent = {
+    [lang in I18nLang]?: Record<string, string>;
+};
+/**
+ * Almacén de contenido por namespace
+ *
+ * @example
+ * {
+ *   '_global': { es: {...}, en: {...} },
+ *   'Login': { es: {...}, en: {...} },
+ *   'Profile': { es: {...}, en: {...} }
+ * }
+ */
+export type ContentStore = Record<string, LanguagesContent>;
+/**
+ * Configuración para provideValtechI18n()
+ */
+export interface I18nConfig {
+    /**
+     * Idioma por defecto si no hay preferencia guardada
+     * @default 'es'
+     */
+    defaultLanguage?: I18nLang;
+    /**
+     * Lista de idiomas habilitados en la app
+     * @default ['es', 'en']
+     */
+    supportedLanguages?: I18nLang[];
+    /**
+     * Detectar idioma del navegador al iniciar
+     * @default true
+     */
+    detectBrowserLanguage?: boolean;
+    /**
+     * Contenido inicial de traducciones por namespace.
+     * Si includeDefaultContent es true, este contenido se mergea
+     * con VALTECH_DEFAULT_CONTENT (las keys del usuario ganan).
+     */
+    content?: ContentStore;
+    /**
+     * Si es true, incluye traducciones por defecto de valtech-components.
+     * Las traducciones del usuario sobrescriben las por defecto.
+     *
+     * @default true
+     *
+     * @example Usar defaults (comportamiento por defecto)
+     * ```typescript
+     * provideValtechI18n() // Funciona sin configuración
+     * ```
+     *
+     * @example Sobrescribir keys específicas
+     * ```typescript
+     * provideValtechI18n({
+     *   content: {
+     *     _global: {
+     *       es: { success: '¡Lo hicimos!' },
+     *       en: { success: 'We did it!' },
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example Desactivar defaults completamente
+     * ```typescript
+     * provideValtechI18n({
+     *   includeDefaultContent: false,
+     *   content: MY_CUSTOM_CONTENT,
+     * })
+     * ```
+     */
+    includeDefaultContent?: boolean;
+}
+/**
+ * Valores por defecto de configuración
+ */
+export declare const DEFAULT_I18N_CONFIG: Required<I18nConfig>;
+/**
+ * Clave para persistir idioma en localStorage
+ */
+export declare const LANG_STORAGE_KEY = "app_lang";

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

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class IconService {
+    /**
+     * Registers a set of Ionicons icons for use throughout the app.
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconService>;
+}

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

@@ -0,0 +1,76 @@
+import { CropData, ImageCompressOptions, ImageValidateOptions, ImageValidationResult, ProcessedImage } from './types';
+import * as i0 from "@angular/core";
+/**
+ * ImageService
+ *
+ * Service for image processing including compression, thumbnails, cropping and validation.
+ * Uses HTML Canvas for all operations - no external dependencies.
+ *
+ * @example
+ * ```typescript
+ * const imageService = inject(ImageService);
+ *
+ * // Compress an image
+ * const compressed = await imageService.compress(file, { maxWidth: 800, quality: 0.8 });
+ *
+ * // Generate thumbnail
+ * const thumb = await imageService.thumbnail(file, 150);
+ *
+ * // Validate before processing
+ * const validation = imageService.validate(file, { maxSize: 5 * 1024 * 1024 });
+ * if (!validation.valid) {
+ *   console.error(validation.message);
+ * }
+ * ```
+ */
+export declare class ImageService {
+    /**
+     * Compress an image maintaining aspect ratio
+     * @param file - File or Blob to compress
+     * @param options - Compression options
+     * @returns Promise with processed image data
+     */
+    compress(file: File | Blob, options?: ImageCompressOptions): Promise<ProcessedImage>;
+    /**
+     * Generate a square thumbnail from an image
+     * @param file - File or Blob to process
+     * @param size - Thumbnail size in pixels (default: 150)
+     * @returns Promise with processed thumbnail
+     */
+    thumbnail(file: File | Blob, size?: number): Promise<ProcessedImage>;
+    /**
+     * Crop an image with specific coordinates
+     * @param file - File or Blob to crop
+     * @param cropData - Crop coordinates and dimensions
+     * @param options - Optional compression options for output
+     * @returns Promise with cropped image
+     */
+    crop(file: File | Blob, cropData: CropData, options?: ImageCompressOptions): Promise<ProcessedImage>;
+    /**
+     * Validate an image file before processing
+     * @param file - File to validate
+     * @param options - Validation options
+     * @returns Validation result with error details if invalid
+     */
+    validate(file: File, options?: ImageValidateOptions): ImageValidationResult;
+    /**
+     * Validate image dimensions (async - requires loading image)
+     * @param file - File to validate
+     * @param options - Validation options with minWidth/minHeight
+     * @returns Promise with validation result
+     */
+    validateDimensions(file: File, options: Pick<ImageValidateOptions, 'minWidth' | 'minHeight'>): Promise<ImageValidationResult>;
+    /**
+     * Convert a Blob/File to a data URL
+     */
+    toDataUrl(file: File | Blob): Promise<string>;
+    /**
+     * Convert a data URL to a Blob
+     */
+    dataUrlToBlob(dataUrl: string): Blob;
+    private loadImage;
+    private calculateDimensions;
+    private canvasToBlob;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageService>;
+}

package/lib/services/image/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Options for image compression
+ */
+export interface ImageCompressOptions {
+    /** Maximum width in pixels (default: 800) */
+    maxWidth?: number;
+    /** Maximum height in pixels (default: 800) */
+    maxHeight?: number;
+    /** Quality 0-1 (default: 0.8) */
+    quality?: number;
+    /** Output MIME type (default: 'image/jpeg') */
+    mimeType?: 'image/jpeg' | 'image/png' | 'image/webp';
+}
+/**
+ * Options for image validation
+ */
+export interface ImageValidateOptions {
+    /** Maximum file size in bytes (default: 10MB) */
+    maxSize?: number;
+    /** Allowed MIME types (default: ['image/jpeg', 'image/png', 'image/webp', 'image/gif']) */
+    allowedTypes?: string[];
+    /** Minimum width in pixels */
+    minWidth?: number;
+    /** Minimum height in pixels */
+    minHeight?: number;
+}
+/**
+ * Result of image validation
+ */
+export interface ImageValidationResult {
+    valid: boolean;
+    error?: 'invalidType' | 'fileTooLarge' | 'imageTooSmall';
+    message?: string;
+}
+/**
+ * Processed image result
+ */
+export interface ProcessedImage {
+    /** Processed image as Blob */
+    blob: Blob;
+    /** Data URL for preview */
+    dataUrl: string;
+    /** Final width in pixels */
+    width: number;
+    /** Final height in pixels */
+    height: number;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Crop data for manual cropping
+ */
+export interface CropData {
+    /** X position of crop area */
+    x: number;
+    /** Y position of crop area */
+    y: number;
+    /** Width of crop area */
+    width: number;
+    /** Height of crop area */
+    height: number;
+}
+/**
+ * Default values for image processing
+ */
+export declare const IMAGE_DEFAULTS: {
+    maxWidth: number;
+    maxHeight: number;
+    quality: number;
+    mimeType: "image/jpeg";
+    maxSize: number;
+    allowedTypes: string[];
+    thumbnailSize: number;
+};

package/lib/services/in-app-browser.service.d.ts

@@ -0,0 +1,16 @@
+import { OpenOptions } from '@capacitor/browser';
+import * as i0 from "@angular/core";
+export declare class InAppBrowserService {
+    /**
+     * Default options for the in-app browser.
+     */
+    options: OpenOptions;
+    constructor();
+    /**
+     * Opens a URL using Capacitor's InAppBrowser with the configured options.
+     * @param url The URL to open
+     */
+    openWithInAppBrowser(url: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InAppBrowserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InAppBrowserService>;
+}

package/lib/services/legal-link/legal-link.service.d.ts

@@ -0,0 +1,73 @@
+import { InjectionToken, Provider } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Config for cross-app legal/site link resolution.
+ *
+ * Used by satellite apps (showcase, sigify, admin-portal, …) to point their legal
+ * and site links (terms, privacy, about, contact, …) to the main marketing site,
+ * which owns the canonical legal content. The main site itself does NOT call
+ * `provideValtechLegal` — its links stay relative.
+ */
+export interface ValtechLegalConfig {
+    /**
+     * Absolute base URL of the main site (no trailing slash).
+     * @example 'https://myvaltech.com'
+     */
+    baseUrl?: string;
+    /** Open resolved external links in a new tab. Defaults to `true` when `baseUrl` is set. */
+    openInNewTab?: boolean;
+}
+export declare const VALTECH_LEGAL_CONFIG: InjectionToken<ValtechLegalConfig>;
+/**
+ * Resolves legal/site paths against a configurable main-site base URL.
+ *
+ * - **Main site mode**: no `provideValtechLegal` called → `resolve('/legal/terms')` returns `/legal/terms` (relative).
+ * - **Satellite mode**: `provideValtechLegal({ baseUrl: 'https://myvaltech.com' })` → `resolve('/legal/terms')` returns `'https://myvaltech.com/legal/terms'` and `isExternal('/legal/terms')` returns `true`.
+ *
+ * Absolute URLs passed in are returned unchanged (no double-prefix).
+ */
+export declare class LegalLinkService {
+    private readonly config;
+    /** Effective base URL (null if running as main site). */
+    get baseUrl(): string | null;
+    /** Whether resolved external links should open in a new tab. */
+    get openInNewTab(): boolean;
+    /**
+     * Returns the URL to use for a given internal path. Absolute URLs pass through.
+     *
+     * When `locale` is provided AND the resolved URL would be cross-origin, appends
+     * `?lang={locale}` so the main site can render the legal doc in the user's
+     * active language (instead of its default). Locale is omitted for same-origin
+     * resolves since the main site reads locale from its own `LocaleService`.
+     *
+     * @example
+     * resolve('/legal/terms')
+     *   // main site:  '/legal/terms'
+     *   // satellite:  'https://myvaltech.com/legal/terms'
+     *
+     * resolve('/legal/terms', { locale: 'pt' })
+     *   // main site:  '/legal/terms'  (locale stays implicit)
+     *   // satellite:  'https://myvaltech.com/legal/terms?lang=pt'
+     *
+     * resolve('https://x.com/y') // unchanged
+     */
+    resolve(path: string, options?: {
+        locale?: string;
+    }): string;
+    /** `true` if the path would be resolved to a cross-origin URL. */
+    isExternal(path: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LegalLinkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LegalLinkService>;
+}
+/**
+ * Wires `LegalLinkService` for satellite apps. Omit in the main site (the one
+ * that hosts the canonical /legal/* routes) so links stay relative.
+ *
+ * @example
+ * // main.ts of showcase / sigify / etc.
+ * provideValtechLegal({
+ *   baseUrl: 'https://myvaltech.com',
+ *   openInNewTab: true,
+ * }),
+ */
+export declare function provideValtechLegal(config: ValtechLegalConfig): Provider;

package/lib/services/link-processor.service.d.ts

@@ -0,0 +1,104 @@
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export interface LinkProcessorConfig {
+    /** Whether to open external links in new tab (default: true) */
+    openExternalInNewTab?: boolean;
+    /** Whether to open internal links in new tab (default: false) */
+    openInternalInNewTab?: boolean;
+    /** Custom CSS classes for links */
+    linkClass?: string;
+    /** Custom CSS classes for external links */
+    externalLinkClass?: string;
+    /** Custom CSS classes for internal links */
+    internalLinkClass?: string;
+    /** Whether to process Markdown-style links [text](url) (default: true) */
+    processMarkdownLinks?: boolean;
+}
+/**
+ * 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 declare class LinkProcessorService {
+    private sanitizer;
+    private readonly urlRegex;
+    private readonly internalRouteRegex;
+    private readonly markdownLinkRegex;
+    constructor(sanitizer: DomSanitizer);
+    /**
+     * 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.
+     */
+    private cleanUrlPunctuation;
+    /**
+     * 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: string, config?: LinkProcessorConfig): SafeHtml | string;
+    /**
+     * 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: string): boolean;
+    /**
+     * 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: string): Array<{
+        url: string;
+        type: 'external' | 'internal';
+        text: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkProcessorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LinkProcessorService>;
+}

package/lib/services/local-storage.service.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility service for interacting with browser localStorage in a type-safe way.
+ * Provides static methods for setting, getting, removing, and clearing items.
+ */
+export declare 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<T>(reference: string, value: T): void;
+    /**
+     * Retrieves a value from localStorage by key.
+     * @param reference The key to retrieve
+     * @returns The parsed value
+     */
+    static get<T>(reference: string): T;
+    /**
+     * Removes an item from localStorage by key.
+     * @param reference The key to remove
+     */
+    static remove(reference: string): void;
+    /**
+     * Clears all items from localStorage.
+     */
+    static clear(): void;
+}

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

@@ -0,0 +1,52 @@
+import * as i0 from "@angular/core";
+/**
+ * Tipos de idioma soportados
+ */
+export type SupportedLang = 'es' | 'en';
+/**
+ * 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 declare class LocaleService {
+    /**
+     * Idioma actual de la aplicación.
+     * Se lee una vez al iniciar desde localStorage.
+     */
+    readonly lang: SupportedLang;
+    constructor();
+    /**
+     * 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: SupportedLang): void;
+    /**
+     * Obtiene el idioma almacenado en localStorage.
+     * Si no existe o no es válido, retorna el idioma por defecto.
+     */
+    private getStoredLang;
+    /**
+     * Verifica si el idioma actual es español
+     */
+    get isSpanish(): boolean;
+    /**
+     * Verifica si el idioma actual es inglés
+     */
+    get isEnglish(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleService>;
+}

package/lib/services/markdown-article/legal-content.service.d.ts

@@ -0,0 +1,73 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ArticleMetadata } from '../../components/organisms/article/types';
+import * as i0 from "@angular/core";
+export type LegalSlug = 'terms' | 'privacy' | 'cookies' | 'data-usage' | 'legal-notice' | string;
+/**
+ * Factory that returns a Record<slug, ArticleMetadata> for a given locale.
+ * Use a dynamic `import()` so each locale module is code-split by the bundler.
+ */
+export type LegalContentFactory = () => Promise<Record<string, ArticleMetadata>>;
+export interface LegalContentConfig {
+    /** Pre-generated content factories keyed by locale (e.g. `{ es: () => import('./generated/legal-content.es') ... }`). */
+    factories?: Record<string, LegalContentFactory>;
+    /** Override default `/assets/legal` base path used when no factory matches. */
+    basePath?: string;
+    /** Fallback locale (default `es`). Set null to disable. */
+    fallbackLocale?: string | null;
+}
+export declare const LEGAL_CONTENT_CONFIG: InjectionToken<LegalContentConfig>;
+export interface LegalLoadOptions {
+    /** Two-letter locale code (es, en, pt). */
+    locale?: string;
+    /** Override base path for runtime mode (default `/assets/legal`). */
+    basePath?: string;
+    /** Fallback locale tried when the requested one is missing. Set null to disable. */
+    fallbackLocale?: string | null;
+}
+/**
+ * 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 declare class LegalContentService {
+    private readonly http;
+    private readonly parser;
+    private readonly config;
+    private readonly DEFAULT_BASE;
+    private readonly cache;
+    private readonly factoryCache;
+    load(slug: LegalSlug, options?: LegalLoadOptions): Observable<ArticleMetadata>;
+    /** Raw Markdown — only available in runtime mode (HTTP). */
+    raw(slug: LegalSlug, options?: LegalLoadOptions): Observable<string>;
+    /** Clears in-memory caches. Call on runtime locale change. */
+    invalidate(): void;
+    private loadOne;
+    private runFactory;
+    private fetchAndParse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LegalContentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LegalContentService>;
+}
+/**
+ * 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 declare function provideLegalContent(config: LegalContentConfig): Provider;

package/lib/services/markdown-article/markdown-article-parser.d.ts

@@ -0,0 +1,38 @@
+import { ArticleMetadata } from '../../components/organisms/article/types';
+export type CalloutType = 'NOTE' | 'TIP' | 'INFO' | 'WARNING' | 'CAUTION' | 'IMPORTANT';
+/**
+ * Localized label per callout kind. Used as the prefix shown inside the
+ * resulting note element (e.g. `> [!NOTE] …` → `<val-notes-box prefix="Nota">`).
+ *
+ * Defaults to Spanish for back-compat. Pass a different map per locale when
+ * parsing translated documents so the prefix matches the body language.
+ */
+export type CalloutLabels = Record<CalloutType, string>;
+/** Built-in label sets for the three platform locales. */
+export declare const CALLOUT_LABELS: Record<'es' | 'en' | 'pt', CalloutLabels>;
+/** Optional configuration for the parser. */
+export interface ParseMarkdownArticleOptions extends Partial<ArticleMetadata> {
+    /**
+     * Locale used to pick built-in callout labels. Convenience shortcut so
+     * callers don't have to spread `CALLOUT_LABELS.en` themselves. Ignored
+     * when `calloutLabels` is provided explicitly.
+     */
+    locale?: 'es' | 'en' | 'pt';
+    /** Override every callout label individually. Takes precedence over `locale`. */
+    calloutLabels?: CalloutLabels;
+}
+/**
+ * Pure Markdown → ArticleMetadata parser. No Angular deps — usable from Node scripts
+ * (build-time generation) and from the Angular `MarkdownArticleParserService` wrapper.
+ *
+ * Supported syntax:
+ * - Headings (#, ##, ### …) → title / subtitle
+ * - Paragraphs → paragraph (with `processLinks` + `allowPartialBold`)
+ * - Lists (-, *, 1.) → unordered / ordered list (- [ ] / - [x] for checklist)
+ * - Blockquotes (>) → quote, with GitHub callouts `> [!NOTE|TIP|INFO|WARNING|CAUTION|IMPORTANT]` mapped to notes
+ * - Code fences (```lang) → code
+ * - Box-drawing ASCII art (┌┐└┘│─) auto-wrapped as code
+ * - Tables → flattened into paragraphs with bold keys
+ * - Horizontal rules (---, ***, ___) → separator
+ */
+export declare function parseMarkdownArticle(markdown: string, options?: ParseMarkdownArticleOptions): ArticleMetadata;

package/lib/services/markdown-article/markdown-article-parser.service.d.ts

@@ -0,0 +1,12 @@
+import { ArticleMetadata } from '../../components/organisms/article/types';
+import * as i0 from "@angular/core";
+/**
+ * Angular service wrapper for the pure {@link parseMarkdownArticle} function.
+ * Provided in root so it can be injected anywhere. The actual parsing logic lives in
+ * `markdown-article-parser.ts` and is also usable from Node scripts (build-time generation).
+ */
+export declare class MarkdownArticleParserService {
+    parse(markdown: string, config?: Partial<ArticleMetadata>): ArticleMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownArticleParserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MarkdownArticleParserService>;
+}

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

@@ -0,0 +1,23 @@
+import { PageMetadata, MetaConfig } from './types';
+import * as i0 from "@angular/core";
+export declare class MetaService {
+    private meta;
+    private titleService;
+    private baseUrl;
+    private defaultImage;
+    private siteName;
+    /**
+     * Configurar el servicio con valores de la app
+     */
+    configure(config: MetaConfig): void;
+    /**
+     * Actualizar meta tags de la página
+     */
+    updatePageMeta(metadata: PageMetadata, path?: string): void;
+    /**
+     * Resetear a valores por defecto
+     */
+    resetToDefault(metadata: PageMetadata): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetaService>;
+}