valtech-components 2.0.729 → 2.0.730

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

@@ -1,45 +1,79 @@
 import { HttpClient } from '@angular/common/http';
-import { Injectable, inject } from '@angular/core';
-import { catchError, map, of, shareReplay, switchMap, throwError } from 'rxjs';
+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 Markdown legal documents from `/assets/legal/{locale}/{slug}.md` and parses them
- * into ArticleMetadata ready for `<val-article>`. Caches parsed results by `locale:slug`
- * so multiple views consuming the same doc share one HTTP request.
+ * 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 base = options.basePath ?? this.DEFAULT_BASE;
-        const fallback = options.fallbackLocale === undefined ? 'es' : options.fallbackLocale;
-        const key = `${base}|${locale}|${slug}`;
+        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.fetchAndParse(`${base}/${locale}/${slug}.md`);
+        const primary = this.loadOne(slug, locale, options.basePath);
         const stream = fallback && fallback !== locale
-            ? primary.pipe(catchError(() => this.fetchAndParse(`${base}/${fallback}/${slug}.md`)))
+            ? 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;
     }
-    /** Returns the raw Markdown string without parsing. Useful for debugging. */
+    /** Raw Markdown — only available in runtime mode (HTTP). */
     raw(slug, options = {}) {
         const locale = (options.locale ?? 'es').toLowerCase();
-        const base = options.basePath ?? this.DEFAULT_BASE;
+        const base = options.basePath ?? this.config.basePath ?? this.DEFAULT_BASE;
         return this.http.get(`${base}/${locale}/${slug}.md`, { responseType: 'text' });
     }
-    /** Clears the in-memory cache. Call when the user changes locale at runtime. */
+    /** 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
@@ -53,4 +87,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAY,MAAM,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAc,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAEjG,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;;AAmBjF,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,cAAc,CAAqB,sBAAsB,CAAC,CAAC;AAWnG;;;;;;;;;;;;GAYG;AAEH,MAAM,OAAO,mBAAmB;IADhC;QAEmB,SAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1B,WAAM,GAAG,MAAM,CAAC,4BAA4B,CAAC,CAAC;QAC9C,WAAM,GAAG,MAAM,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;QAEhE,iBAAY,GAAG,eAAe,CAAC;QAC/B,UAAK,GAAG,IAAI,GAAG,EAAuC,CAAC;QACvD,iBAAY,GAAG,IAAI,GAAG,EAAoD,CAAC;KA8E7F;IA5EC,IAAI,CAAC,IAAe,EAAE,UAA4B,EAAE;QAClD,MAAM,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;QACtD,MAAM,QAAQ,GACZ,OAAO,CAAC,cAAc,KAAK,SAAS;YAClC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC;YACtC,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;QAE7B,MAAM,GAAG,GAAG,GAAG,MAAM,IAAI,IAAI,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;QAE1B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC7D,MAAM,MAAM,GACV,QAAQ,IAAI,QAAQ,KAAK,MAAM;YAC7B,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YAChF,CAAC,CAAC,OAAO,CAAC;QAEd,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAC5E,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC5B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,4DAA4D;IAC5D,GAAG,CAAC,IAAe,EAAE,UAA4B,EAAE;QACjD,MAAM,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;QACtD,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC;QAC3E,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,MAAM,IAAI,IAAI,KAAK,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC;IACjF,CAAC;IAED,8DAA8D;IAC9D,UAAU;QACR,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAEO,OAAO,CACb,IAAY,EACZ,MAAc,EACd,gBAAyB;QAEzB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAChD,SAAS,CAAC,OAAO,CAAC,EAAE;gBAClB,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC9B,OAAO,OAAO;oBACZ,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC;oBACb,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,wBAAwB,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;YAC5E,CAAC,CAAC,CACH,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,gBAAgB,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC;QAC3E,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,IAAI,IAAI,MAAM,IAAI,IAAI,KAAK,CAAC,CAAC;IAC5D,CAAC;IAEO,UAAU,CAChB,MAAc,EACd,OAA4B;QAE5B,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;QAC1B,MAAM,OAAO,GAAG,OAAO,EAAE,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACvC,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,aAAa,CAAC,GAAW;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI,CACtD,SAAS,CAAC,EAAE,CAAC,EAAE,CACb,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;YACxB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC3B,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC,CAAC,CAC3D,EACD,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CACtB,CAAC;IACJ,CAAC;+GApFU,mBAAmB;mHAAnB,mBAAmB,cADN,MAAM;;4FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;AAwFlC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAA0B;IAC5D,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;AAC7D,CAAC","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"]}

package/esm2022/lib/services/markdown-article/markdown-article-parser.mjs

@@ -0,0 +1,266 @@
+const BOX_DRAWING = /[┌┐└┘├┤┬┴┼─│╔╗╚╝═║]/;
+const CALLOUT_RE = /^>\s*\[!(NOTE|TIP|INFO|WARNING|CAUTION|IMPORTANT)\]\s*(.*)$/i;
+const FENCE_RE = /^```([\w-]*)\s*$/;
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+const SEPARATOR_RE = /^\s*(?:-{3,}|\*{3,}|_{3,})\s*$/;
+const UNORDERED_RE = /^\s*[-*+]\s+(.+)$/;
+const CHECKLIST_RE = /^\s*[-*+]\s+\[([ xX])\]\s+(.+)$/;
+const ORDERED_RE = /^\s*\d+\.\s+(.+)$/;
+const TABLE_DIVIDER_RE = /^\s*\|?[\s:|-]+\|?\s*$/;
+const TABLE_ROW_RE = /^\s*\|(.+)\|\s*$/;
+/**
+ * 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 function parseMarkdownArticle(markdown, config) {
+    const lines = normalize(markdown).split('\n');
+    const elements = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            i++;
+            continue;
+        }
+        const fence = line.match(FENCE_RE);
+        if (fence) {
+            const lang = fence[1] || undefined;
+            const body = [];
+            i++;
+            while (i < lines.length && !FENCE_RE.test(lines[i])) {
+                body.push(lines[i]);
+                i++;
+            }
+            i++;
+            elements.push({
+                type: 'code',
+                props: { code: body.join('\n'), language: lang, theme: 'dark' },
+            });
+            continue;
+        }
+        if (BOX_DRAWING.test(line)) {
+            const body = [];
+            while (i < lines.length && (lines[i].trim() === '' || BOX_DRAWING.test(lines[i]))) {
+                body.push(lines[i]);
+                i++;
+            }
+            while (body.length && body[body.length - 1].trim() === '')
+                body.pop();
+            elements.push({
+                type: 'code',
+                props: { code: body.join('\n'), language: 'text', theme: 'dark' },
+            });
+            continue;
+        }
+        if (SEPARATOR_RE.test(line)) {
+            elements.push({ type: 'separator', props: { style: 'line' } });
+            i++;
+            continue;
+        }
+        const heading = line.match(HEADING_RE);
+        if (heading) {
+            elements.push(makeHeading(heading[1].length, heading[2].trim()));
+            i++;
+            continue;
+        }
+        if (line.startsWith('>')) {
+            const block = [];
+            while (i < lines.length && lines[i].startsWith('>')) {
+                block.push(lines[i]);
+                i++;
+            }
+            elements.push(makeQuoteOrCallout(block));
+            continue;
+        }
+        if (TABLE_ROW_RE.test(line)) {
+            const rows = [];
+            while (i < lines.length && TABLE_ROW_RE.test(lines[i])) {
+                rows.push(lines[i]);
+                i++;
+            }
+            elements.push(...makeTable(rows));
+            continue;
+        }
+        if (CHECKLIST_RE.test(line) || UNORDERED_RE.test(line) || ORDERED_RE.test(line)) {
+            const listType = CHECKLIST_RE.test(line)
+                ? 'checklist'
+                : ORDERED_RE.test(line)
+                    ? 'ordered'
+                    : 'unordered';
+            const items = [];
+            while (i < lines.length && lines[i].trim() !== '') {
+                const cur = lines[i];
+                const check = cur.match(CHECKLIST_RE);
+                const unord = cur.match(UNORDERED_RE);
+                const ord = cur.match(ORDERED_RE);
+                if (check)
+                    items.push({ text: check[2].trim() });
+                else if (ord && listType === 'ordered')
+                    items.push({ text: ord[1].trim() });
+                else if (unord && listType !== 'ordered')
+                    items.push({ text: unord[1].trim() });
+                else
+                    break;
+                i++;
+            }
+            elements.push({ type: 'list', props: { items, listType } });
+            continue;
+        }
+        const paragraph = [];
+        while (i < lines.length && lines[i].trim() !== '' && !startsNewBlock(lines[i])) {
+            paragraph.push(lines[i]);
+            i++;
+        }
+        const text = paragraph.join(' ').trim();
+        if (text) {
+            elements.push({
+                type: 'paragraph',
+                props: {
+                    content: text,
+                    size: 'medium',
+                    color: 'dark',
+                    bold: false,
+                    processLinks: true,
+                    allowPartialBold: true,
+                },
+            });
+        }
+    }
+    return {
+        elements,
+        maxWidth: '900px',
+        centered: true,
+        theme: 'auto',
+        ...config,
+    };
+}
+function normalize(md) {
+    return md.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+function startsNewBlock(line) {
+    return (HEADING_RE.test(line) ||
+        FENCE_RE.test(line) ||
+        SEPARATOR_RE.test(line) ||
+        TABLE_ROW_RE.test(line) ||
+        UNORDERED_RE.test(line) ||
+        ORDERED_RE.test(line) ||
+        CHECKLIST_RE.test(line) ||
+        line.startsWith('>') ||
+        BOX_DRAWING.test(line));
+}
+function makeHeading(level, content) {
+    if (level === 1) {
+        return {
+            type: 'title',
+            props: { content, size: 'xlarge', color: 'dark', bold: true },
+        };
+    }
+    const size = level === 2 ? 'large' : level === 3 ? 'medium' : 'small';
+    return {
+        type: 'subtitle',
+        props: { content, size, color: 'dark', bold: true },
+    };
+}
+function makeQuoteOrCallout(block) {
+    const first = block[0];
+    const callout = first.match(CALLOUT_RE);
+    const lines = block.map(l => l.replace(/^>\s?/, ''));
+    if (callout) {
+        const type = callout[1].toUpperCase();
+        const firstLineRest = callout[2] || '';
+        const rest = lines.slice(1).join(' ').trim();
+        const text = [firstLineRest, rest].filter(Boolean).join(' ').trim();
+        return makeNote(type, text);
+    }
+    const text = lines.join(' ').trim();
+    return {
+        type: 'quote',
+        props: {
+            content: text,
+            size: 'medium',
+            color: 'medium',
+            bold: false,
+            showQuoteMark: true,
+            alignment: 'left',
+        },
+    };
+}
+function makeNote(kind, text) {
+    const map = {
+        NOTE: { color: 'primary', prefix: 'Nota' },
+        TIP: { color: 'success', prefix: 'Tip' },
+        INFO: { color: 'tertiary', prefix: 'Info' },
+        IMPORTANT: { color: 'warning', prefix: 'Importante' },
+        WARNING: { color: 'warning', prefix: 'Atención' },
+        CAUTION: { color: 'danger', prefix: 'Precaución' },
+    };
+    const cfg = map[kind];
+    return {
+        type: 'note',
+        props: {
+            text,
+            prefix: `${cfg.prefix}:`,
+            color: cfg.color,
+            textColor: 'dark',
+            size: 'medium',
+            rounded: true,
+        },
+    };
+}
+function makeTable(rows) {
+    const parsed = rows
+        .filter(r => !TABLE_DIVIDER_RE.test(r))
+        .map(r => r
+        .trim()
+        .replace(/^\|/, '')
+        .replace(/\|$/, '')
+        .split('|')
+        .map(c => c.trim()));
+    if (parsed.length === 0)
+        return [];
+    const header = parsed[0];
+    const dataRows = parsed.slice(1);
+    if (dataRows.length === 0) {
+        return [
+            {
+                type: 'paragraph',
+                props: {
+                    content: header.join(' · '),
+                    size: 'medium',
+                    color: 'dark',
+                    bold: false,
+                    processLinks: true,
+                    allowPartialBold: true,
+                },
+            },
+        ];
+    }
+    return dataRows.map(row => {
+        const pairs = row.map((cell, idx) => {
+            const key = header[idx] ?? '';
+            return key ? `**${key}:** ${cell}` : cell;
+        });
+        return {
+            type: 'paragraph',
+            props: {
+                content: pairs.join(' · '),
+                size: 'medium',
+                color: 'dark',
+                bold: false,
+                processLinks: true,
+                allowPartialBold: true,
+            },
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown-article-parser.js","sourceRoot":"","sources":["../../../../../../src/lib/services/markdown-article/markdown-article-parser.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ArticleElement,\n  ArticleListElement,\n  ArticleMetadata,\n  ArticleNoteElement,\n  ArticleSubtitleElement,\n  ArticleTitleElement,\n} from '../../components/organisms/article/types';\n\ntype CalloutType = 'NOTE' | 'TIP' | 'INFO' | 'WARNING' | 'CAUTION' | 'IMPORTANT';\n\nconst BOX_DRAWING = /[┌┐└┘├┤┬┴┼─│╔╗╚╝═║]/;\nconst CALLOUT_RE = /^>\\s*\\[!(NOTE|TIP|INFO|WARNING|CAUTION|IMPORTANT)\\]\\s*(.*)$/i;\nconst FENCE_RE = /^```([\\w-]*)\\s*$/;\nconst HEADING_RE = /^(#{1,6})\\s+(.+)$/;\nconst SEPARATOR_RE = /^\\s*(?:-{3,}|\\*{3,}|_{3,})\\s*$/;\nconst UNORDERED_RE = /^\\s*[-*+]\\s+(.+)$/;\nconst CHECKLIST_RE = /^\\s*[-*+]\\s+\\[([ xX])\\]\\s+(.+)$/;\nconst ORDERED_RE = /^\\s*\\d+\\.\\s+(.+)$/;\nconst TABLE_DIVIDER_RE = /^\\s*\\|?[\\s:|-]+\\|?\\s*$/;\nconst TABLE_ROW_RE = /^\\s*\\|(.+)\\|\\s*$/;\n\n/**\n * Pure Markdown → ArticleMetadata parser. No Angular deps — usable from Node scripts\n * (build-time generation) and from the Angular `MarkdownArticleParserService` wrapper.\n *\n * Supported syntax:\n * - Headings (#, ##, ### …) → title / subtitle\n * - Paragraphs → paragraph (with `processLinks` + `allowPartialBold`)\n * - Lists (-, *, 1.) → unordered / ordered list (- [ ] / - [x] for checklist)\n * - Blockquotes (>) → quote, with GitHub callouts `> [!NOTE|TIP|INFO|WARNING|CAUTION|IMPORTANT]` mapped to notes\n * - Code fences (```lang) → code\n * - Box-drawing ASCII art (┌┐└┘│─) auto-wrapped as code\n * - Tables → flattened into paragraphs with bold keys\n * - Horizontal rules (---, ***, ___) → separator\n */\nexport function parseMarkdownArticle(\n  markdown: string,\n  config?: Partial<ArticleMetadata>\n): ArticleMetadata {\n  const lines = normalize(markdown).split('\\n');\n  const elements: ArticleElement[] = [];\n\n  let i = 0;\n  while (i < lines.length) {\n    const line = lines[i];\n\n    if (line.trim() === '') {\n      i++;\n      continue;\n    }\n\n    const fence = line.match(FENCE_RE);\n    if (fence) {\n      const lang = fence[1] || undefined;\n      const body: string[] = [];\n      i++;\n      while (i < lines.length && !FENCE_RE.test(lines[i])) {\n        body.push(lines[i]);\n        i++;\n      }\n      i++;\n      elements.push({\n        type: 'code',\n        props: { code: body.join('\\n'), language: lang, theme: 'dark' },\n      });\n      continue;\n    }\n\n    if (BOX_DRAWING.test(line)) {\n      const body: string[] = [];\n      while (i < lines.length && (lines[i].trim() === '' || BOX_DRAWING.test(lines[i]))) {\n        body.push(lines[i]);\n        i++;\n      }\n      while (body.length && body[body.length - 1].trim() === '') body.pop();\n      elements.push({\n        type: 'code',\n        props: { code: body.join('\\n'), language: 'text', theme: 'dark' },\n      });\n      continue;\n    }\n\n    if (SEPARATOR_RE.test(line)) {\n      elements.push({ type: 'separator', props: { style: 'line' } });\n      i++;\n      continue;\n    }\n\n    const heading = line.match(HEADING_RE);\n    if (heading) {\n      elements.push(makeHeading(heading[1].length, heading[2].trim()));\n      i++;\n      continue;\n    }\n\n    if (line.startsWith('>')) {\n      const block: string[] = [];\n      while (i < lines.length && lines[i].startsWith('>')) {\n        block.push(lines[i]);\n        i++;\n      }\n      elements.push(makeQuoteOrCallout(block));\n      continue;\n    }\n\n    if (TABLE_ROW_RE.test(line)) {\n      const rows: string[] = [];\n      while (i < lines.length && TABLE_ROW_RE.test(lines[i])) {\n        rows.push(lines[i]);\n        i++;\n      }\n      elements.push(...makeTable(rows));\n      continue;\n    }\n\n    if (CHECKLIST_RE.test(line) || UNORDERED_RE.test(line) || ORDERED_RE.test(line)) {\n      const listType: 'checklist' | 'unordered' | 'ordered' = CHECKLIST_RE.test(line)\n        ? 'checklist'\n        : ORDERED_RE.test(line)\n          ? 'ordered'\n          : 'unordered';\n\n      const items: ArticleListElement['props']['items'] = [];\n      while (i < lines.length && lines[i].trim() !== '') {\n        const cur = lines[i];\n        const check = cur.match(CHECKLIST_RE);\n        const unord = cur.match(UNORDERED_RE);\n        const ord = cur.match(ORDERED_RE);\n        if (check) items.push({ text: check[2].trim() });\n        else if (ord && listType === 'ordered') items.push({ text: ord[1].trim() });\n        else if (unord && listType !== 'ordered') items.push({ text: unord[1].trim() });\n        else break;\n        i++;\n      }\n      elements.push({ type: 'list', props: { items, listType } });\n      continue;\n    }\n\n    const paragraph: string[] = [];\n    while (i < lines.length && lines[i].trim() !== '' && !startsNewBlock(lines[i])) {\n      paragraph.push(lines[i]);\n      i++;\n    }\n    const text = paragraph.join(' ').trim();\n    if (text) {\n      elements.push({\n        type: 'paragraph',\n        props: {\n          content: text,\n          size: 'medium',\n          color: 'dark',\n          bold: false,\n          processLinks: true,\n          allowPartialBold: true,\n        },\n      });\n    }\n  }\n\n  return {\n    elements,\n    maxWidth: '900px',\n    centered: true,\n    theme: 'auto',\n    ...config,\n  };\n}\n\nfunction normalize(md: string): string {\n  return md.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\n}\n\nfunction startsNewBlock(line: string): boolean {\n  return (\n    HEADING_RE.test(line) ||\n    FENCE_RE.test(line) ||\n    SEPARATOR_RE.test(line) ||\n    TABLE_ROW_RE.test(line) ||\n    UNORDERED_RE.test(line) ||\n    ORDERED_RE.test(line) ||\n    CHECKLIST_RE.test(line) ||\n    line.startsWith('>') ||\n    BOX_DRAWING.test(line)\n  );\n}\n\nfunction makeHeading(level: number, content: string): ArticleTitleElement | ArticleSubtitleElement {\n  if (level === 1) {\n    return {\n      type: 'title',\n      props: { content, size: 'xlarge', color: 'dark', bold: true },\n    };\n  }\n  const size: 'large' | 'medium' | 'small' =\n    level === 2 ? 'large' : level === 3 ? 'medium' : 'small';\n  return {\n    type: 'subtitle',\n    props: { content, size, color: 'dark', bold: true },\n  };\n}\n\nfunction makeQuoteOrCallout(block: string[]): ArticleElement {\n  const first = block[0];\n  const callout = first.match(CALLOUT_RE);\n  const lines = block.map(l => l.replace(/^>\\s?/, ''));\n\n  if (callout) {\n    const type = callout[1].toUpperCase() as CalloutType;\n    const firstLineRest = callout[2] || '';\n    const rest = lines.slice(1).join(' ').trim();\n    const text = [firstLineRest, rest].filter(Boolean).join(' ').trim();\n    return makeNote(type, text);\n  }\n\n  const text = lines.join(' ').trim();\n  return {\n    type: 'quote',\n    props: {\n      content: text,\n      size: 'medium',\n      color: 'medium',\n      bold: false,\n      showQuoteMark: true,\n      alignment: 'left',\n    },\n  };\n}\n\nfunction makeNote(kind: CalloutType, text: string): ArticleNoteElement {\n  const map: Record<CalloutType, { color: ArticleNoteElement['props']['color']; prefix: string }> =\n    {\n      NOTE: { color: 'primary', prefix: 'Nota' },\n      TIP: { color: 'success', prefix: 'Tip' },\n      INFO: { color: 'tertiary', prefix: 'Info' },\n      IMPORTANT: { color: 'warning', prefix: 'Importante' },\n      WARNING: { color: 'warning', prefix: 'Atención' },\n      CAUTION: { color: 'danger', prefix: 'Precaución' },\n    };\n  const cfg = map[kind];\n  return {\n    type: 'note',\n    props: {\n      text,\n      prefix: `${cfg.prefix}:`,\n      color: cfg.color,\n      textColor: 'dark',\n      size: 'medium',\n      rounded: true,\n    },\n  };\n}\n\nfunction makeTable(rows: string[]): ArticleElement[] {\n  const parsed = rows\n    .filter(r => !TABLE_DIVIDER_RE.test(r))\n    .map(r =>\n      r\n        .trim()\n        .replace(/^\\|/, '')\n        .replace(/\\|$/, '')\n        .split('|')\n        .map(c => c.trim())\n    );\n  if (parsed.length === 0) return [];\n\n  const header = parsed[0];\n  const dataRows = parsed.slice(1);\n  if (dataRows.length === 0) {\n    return [\n      {\n        type: 'paragraph',\n        props: {\n          content: header.join(' · '),\n          size: 'medium',\n          color: 'dark',\n          bold: false,\n          processLinks: true,\n          allowPartialBold: true,\n        },\n      },\n    ];\n  }\n\n  return dataRows.map(row => {\n    const pairs = row.map((cell, idx) => {\n      const key = header[idx] ?? '';\n      return key ? `**${key}:** ${cell}` : cell;\n    });\n    return {\n      type: 'paragraph',\n      props: {\n        content: pairs.join(' · '),\n        size: 'medium',\n        color: 'dark',\n        bold: false,\n        processLinks: true,\n        allowPartialBold: true,\n      },\n    } as ArticleElement;\n  });\n}\n"]}