valtech-components 2.0.821 → 2.0.823

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

@@ -0,0 +1,51 @@
+/**
+ * Content Types Module
+ *
+ * Provides a flexible content abstraction layer that transforms
+ * structured content documents into ArticleMetadata for rendering
+ * with the val-article component.
+ *
+ * @example
+ * ```typescript
+ * // Using BlogPostBuilder
+ * import { blogPost } from 'valtech-components';
+ *
+ * const post = blogPost()
+ *   .title('My First Post')
+ *   .author('John Doe')
+ *   .heading('Introduction')
+ *   .paragraph('Welcome to my blog...')
+ *   .toArticle();
+ *
+ * // Using DocsBuilder
+ * import { docs } from 'valtech-components';
+ *
+ * const page = docs()
+ *   .title('Installation')
+ *   .section('Getting Started')
+ *   .code('npm install valtech-components', 'bash')
+ *   .toArticle();
+ *
+ * // Using NewsBuilder
+ * import { news } from 'valtech-components';
+ *
+ * const article = news()
+ *   .headline('Breaking News')
+ *   .summary('Important announcement...')
+ *   .breaking()
+ *   .toArticle();
+ *
+ * // From JSON/API response
+ * import { ContentTransformer, BlogPost } from 'valtech-components';
+ *
+ * const json: BlogPost = await fetch('/api/posts/1').then(r => r.json());
+ * const article = ContentTransformer.toArticle(json);
+ * ```
+ */
+// Transformer
+export { ContentTransformer, toArticle } from './transformer';
+// Content types
+export { BlogPostBuilder, blogPost } from './content-types/blog';
+export { DocsBuilder, docs } from './content-types/documentation';
+export { NewsBuilder, news } from './content-types/news';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/content/transformer.mjs

@@ -0,0 +1,265 @@
+/**
+ * Content Transformer
+ *
+ * Transforms ContentDocument instances into ArticleMetadata
+ * for rendering with the val-article component.
+ */
+import { ArticleBuilder } from '../../components/organisms/article/types';
+import { ComponentStates } from '../../components/types';
+/**
+ * Maps callout variants to Ionic colors
+ */
+const CALLOUT_COLOR_MAP = {
+    info: 'primary',
+    warning: 'warning',
+    success: 'success',
+    error: 'danger',
+};
+/**
+ * Maps callout variants to prefix text
+ */
+const CALLOUT_PREFIX_MAP = {
+    info: 'Info:',
+    warning: 'Aviso:',
+    success: 'Listo:',
+    error: 'Error:',
+};
+/**
+ * ContentTransformer converts ContentDocument objects into ArticleMetadata
+ * that can be rendered by the val-article component.
+ *
+ * @example
+ * ```typescript
+ * const doc: BlogPost = { ... };
+ * const article = ContentTransformer.toArticle(doc);
+ * // Use article with <val-article [props]="article">
+ * ```
+ */
+export class ContentTransformer {
+    /**
+     * Transforms a ContentDocument into ArticleMetadata
+     *
+     * @param doc - The content document to transform
+     * @returns ArticleMetadata ready for val-article component
+     */
+    static toArticle(doc) {
+        const builder = new ArticleBuilder();
+        // Add header based on document type and meta
+        this.addHeader(builder, doc);
+        // Transform each content block
+        for (const block of doc.content) {
+            this.addBlock(builder, block);
+        }
+        // Add footer based on document type
+        this.addFooter(builder, doc);
+        return builder.build({
+            theme: doc.config?.theme ?? 'auto',
+            maxWidth: doc.config?.maxWidth ?? '800px',
+            centered: doc.config?.centered ?? true,
+        });
+    }
+    /**
+     * Adds header elements based on document type and metadata
+     */
+    static addHeader(builder, doc) {
+        // Add author/date info if showMeta is enabled
+        if (doc.config?.showMeta && doc.meta.author) {
+            this.addAuthorBlock(builder, doc.meta.author, doc.meta.publishedAt);
+            builder.separator('space', { spacing: { top: 'small', bottom: 'medium' } });
+        }
+    }
+    /**
+     * Adds footer elements based on document type
+     */
+    static addFooter(builder, doc) {
+        // Add tags if present
+        if (doc.meta.tags && doc.meta.tags.length > 0) {
+            builder.separator('line', { spacing: { top: 'large', bottom: 'medium' } });
+            builder.paragraph({
+                content: `Tags: ${doc.meta.tags.join(', ')}`,
+                size: 'small',
+                color: 'medium',
+                bold: false,
+            });
+        }
+    }
+    /**
+     * Adds author information block
+     */
+    static addAuthorBlock(builder, author, publishedAt) {
+        let authorText = author.name;
+        if (author.role) {
+            authorText += ` - ${author.role}`;
+        }
+        if (publishedAt) {
+            const date = typeof publishedAt === 'string' ? new Date(publishedAt) : publishedAt;
+            authorText += ` | ${date.toLocaleDateString()}`;
+        }
+        builder.paragraph({
+            content: authorText,
+            size: 'small',
+            color: 'medium',
+            bold: false,
+        });
+    }
+    /**
+     * Transforms a single content block and adds it to the builder
+     */
+    static addBlock(builder, block) {
+        switch (block.type) {
+            case 'heading':
+                this.addHeading(builder, block);
+                break;
+            case 'paragraph':
+                this.addParagraph(builder, block);
+                break;
+            case 'quote':
+                this.addQuote(builder, block);
+                break;
+            case 'code':
+                this.addCode(builder, block);
+                break;
+            case 'list':
+                this.addList(builder, block);
+                break;
+            case 'image':
+                this.addImage(builder, block);
+                break;
+            case 'callout':
+                this.addCallout(builder, block);
+                break;
+            case 'divider':
+                this.addDivider(builder, block);
+                break;
+            case 'button':
+                this.addButton(builder, block);
+                break;
+            case 'command':
+                this.addCommand(builder, block);
+                break;
+        }
+    }
+    /**
+     * Adds a heading block
+     */
+    static addHeading(builder, block) {
+        if (block.level === 1) {
+            builder.title({
+                content: block.text,
+                size: 'large',
+                color: 'dark',
+                bold: true,
+            });
+        }
+        else {
+            builder.subtitle({
+                content: block.text,
+                size: block.level === 2 ? 'medium' : 'small',
+                color: 'dark',
+                bold: true,
+            });
+        }
+    }
+    /**
+     * Adds a paragraph block
+     */
+    static addParagraph(builder, block) {
+        builder.paragraph({
+            content: block.text,
+            size: 'medium',
+            color: 'dark',
+            bold: block.emphasis ?? false,
+        });
+    }
+    /**
+     * Adds a quote block
+     */
+    static addQuote(builder, block) {
+        builder.quote({
+            content: block.text,
+            size: 'medium',
+            color: 'dark',
+            bold: false,
+            author: block.author,
+            source: block.source,
+        });
+    }
+    /**
+     * Adds a code block
+     */
+    static addCode(builder, block) {
+        builder.code(block.code, block.language);
+    }
+    /**
+     * Adds a list block
+     */
+    static addList(builder, block) {
+        const items = block.items.map((text) => ({ text }));
+        const listType = block.checklist ? 'checklist' : block.ordered ? 'ordered' : 'unordered';
+        builder.list(items, listType);
+    }
+    /**
+     * Adds an image block
+     */
+    static addImage(builder, block) {
+        builder.image(block.src, block.alt, block.caption, {
+        // Note: alignment is handled differently in ArticleBuilder
+        });
+    }
+    /**
+     * Adds a callout/note block
+     */
+    static addCallout(builder, block) {
+        const color = CALLOUT_COLOR_MAP[block.variant] ?? 'primary';
+        const prefix = block.title ?? CALLOUT_PREFIX_MAP[block.variant] ?? 'Nota:';
+        builder.note(block.text, prefix, color);
+    }
+    /**
+     * Adds a divider/separator block
+     */
+    static addDivider(builder, block) {
+        builder.separator(block.style ?? 'line');
+    }
+    /**
+     * Adds a button block
+     */
+    static addButton(builder, block) {
+        const colorMap = {
+            primary: 'primary',
+            secondary: 'secondary',
+            success: 'success',
+            warning: 'warning',
+            danger: 'danger',
+        };
+        builder.button({
+            text: block.text,
+            color: colorMap[block.color ?? 'primary'] ?? 'primary',
+            fill: 'solid',
+            type: 'button',
+            state: ComponentStates.ENABLED,
+            href: block.href,
+            token: block.action,
+        }, block.alignment ?? 'center');
+    }
+    /**
+     * Adds a command/terminal block
+     */
+    static addCommand(builder, block) {
+        builder.command(block.command);
+    }
+}
+/**
+ * Convenience function to transform a ContentDocument to ArticleMetadata
+ *
+ * @param doc - The content document to transform
+ * @returns ArticleMetadata ready for val-article component
+ *
+ * @example
+ * ```typescript
+ * const article = toArticle(myBlogPost);
+ * ```
+ */
+export function toArticle(doc) {
+    return ContentTransformer.toArticle(doc);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transformer.js","sourceRoot":"","sources":["../../../../../../src/lib/services/content/transformer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Content Transformer\n *\n * Transforms ContentDocument instances into ArticleMetadata\n * for rendering with the val-article component.\n */\n\nimport { Color } from '@ionic/core';\nimport { ArticleBuilder, ArticleMetadata } from '../../components/organisms/article/types';\nimport { ComponentStates } from '../../components/types';\nimport {\n  ContentDocument,\n  ContentBlock,\n  ContentMeta,\n  ContentAuthor,\n  HeadingBlock,\n  ParagraphBlock,\n  QuoteBlock,\n  CodeBlock,\n  ListBlock,\n  ImageBlock,\n  CalloutBlock,\n  DividerBlock,\n  ButtonBlock,\n  CommandBlock,\n} from './types';\n\n/**\n * Maps callout variants to Ionic colors\n */\nconst CALLOUT_COLOR_MAP: Record<string, Color> = {\n  info: 'primary',\n  warning: 'warning',\n  success: 'success',\n  error: 'danger',\n};\n\n/**\n * Maps callout variants to prefix text\n */\nconst CALLOUT_PREFIX_MAP: Record<string, string> = {\n  info: 'Info:',\n  warning: 'Aviso:',\n  success: 'Listo:',\n  error: 'Error:',\n};\n\n/**\n * ContentTransformer converts ContentDocument objects into ArticleMetadata\n * that can be rendered by the val-article component.\n *\n * @example\n * ```typescript\n * const doc: BlogPost = { ... };\n * const article = ContentTransformer.toArticle(doc);\n * // Use article with <val-article [props]=\"article\">\n * ```\n */\nexport class ContentTransformer {\n  /**\n   * Transforms a ContentDocument into ArticleMetadata\n   *\n   * @param doc - The content document to transform\n   * @returns ArticleMetadata ready for val-article component\n   */\n  static toArticle(doc: ContentDocument): ArticleMetadata {\n    const builder = new ArticleBuilder();\n\n    // Add header based on document type and meta\n    this.addHeader(builder, doc);\n\n    // Transform each content block\n    for (const block of doc.content) {\n      this.addBlock(builder, block);\n    }\n\n    // Add footer based on document type\n    this.addFooter(builder, doc);\n\n    return builder.build({\n      theme: doc.config?.theme ?? 'auto',\n      maxWidth: doc.config?.maxWidth ?? '800px',\n      centered: doc.config?.centered ?? true,\n    });\n  }\n\n  /**\n   * Adds header elements based on document type and metadata\n   */\n  private static addHeader(builder: ArticleBuilder, doc: ContentDocument): void {\n    // Add author/date info if showMeta is enabled\n    if (doc.config?.showMeta && doc.meta.author) {\n      this.addAuthorBlock(builder, doc.meta.author, doc.meta.publishedAt);\n      builder.separator('space', { spacing: { top: 'small', bottom: 'medium' } });\n    }\n  }\n\n  /**\n   * Adds footer elements based on document type\n   */\n  private static addFooter(builder: ArticleBuilder, doc: ContentDocument): void {\n    // Add tags if present\n    if (doc.meta.tags && doc.meta.tags.length > 0) {\n      builder.separator('line', { spacing: { top: 'large', bottom: 'medium' } });\n      builder.paragraph({\n        content: `Tags: ${doc.meta.tags.join(', ')}`,\n        size: 'small',\n        color: 'medium',\n        bold: false,\n      });\n    }\n  }\n\n  /**\n   * Adds author information block\n   */\n  private static addAuthorBlock(\n    builder: ArticleBuilder,\n    author: ContentAuthor,\n    publishedAt?: Date | string\n  ): void {\n    let authorText = author.name;\n    if (author.role) {\n      authorText += ` - ${author.role}`;\n    }\n    if (publishedAt) {\n      const date = typeof publishedAt === 'string' ? new Date(publishedAt) : publishedAt;\n      authorText += ` | ${date.toLocaleDateString()}`;\n    }\n\n    builder.paragraph({\n      content: authorText,\n      size: 'small',\n      color: 'medium',\n      bold: false,\n    });\n  }\n\n  /**\n   * Transforms a single content block and adds it to the builder\n   */\n  private static addBlock(builder: ArticleBuilder, block: ContentBlock): void {\n    switch (block.type) {\n      case 'heading':\n        this.addHeading(builder, block);\n        break;\n      case 'paragraph':\n        this.addParagraph(builder, block);\n        break;\n      case 'quote':\n        this.addQuote(builder, block);\n        break;\n      case 'code':\n        this.addCode(builder, block);\n        break;\n      case 'list':\n        this.addList(builder, block);\n        break;\n      case 'image':\n        this.addImage(builder, block);\n        break;\n      case 'callout':\n        this.addCallout(builder, block);\n        break;\n      case 'divider':\n        this.addDivider(builder, block);\n        break;\n      case 'button':\n        this.addButton(builder, block);\n        break;\n      case 'command':\n        this.addCommand(builder, block);\n        break;\n    }\n  }\n\n  /**\n   * Adds a heading block\n   */\n  private static addHeading(builder: ArticleBuilder, block: HeadingBlock): void {\n    if (block.level === 1) {\n      builder.title({\n        content: block.text,\n        size: 'large',\n        color: 'dark',\n        bold: true,\n      });\n    } else {\n      builder.subtitle({\n        content: block.text,\n        size: block.level === 2 ? 'medium' : 'small',\n        color: 'dark',\n        bold: true,\n      });\n    }\n  }\n\n  /**\n   * Adds a paragraph block\n   */\n  private static addParagraph(builder: ArticleBuilder, block: ParagraphBlock): void {\n    builder.paragraph({\n      content: block.text,\n      size: 'medium',\n      color: 'dark',\n      bold: block.emphasis ?? false,\n    });\n  }\n\n  /**\n   * Adds a quote block\n   */\n  private static addQuote(builder: ArticleBuilder, block: QuoteBlock): void {\n    builder.quote({\n      content: block.text,\n      size: 'medium',\n      color: 'dark',\n      bold: false,\n      author: block.author,\n      source: block.source,\n    });\n  }\n\n  /**\n   * Adds a code block\n   */\n  private static addCode(builder: ArticleBuilder, block: CodeBlock): void {\n    builder.code(block.code, block.language);\n  }\n\n  /**\n   * Adds a list block\n   */\n  private static addList(builder: ArticleBuilder, block: ListBlock): void {\n    const items = block.items.map((text) => ({ text }));\n    const listType = block.checklist ? 'checklist' : block.ordered ? 'ordered' : 'unordered';\n    builder.list(items, listType);\n  }\n\n  /**\n   * Adds an image block\n   */\n  private static addImage(builder: ArticleBuilder, block: ImageBlock): void {\n    builder.image(block.src, block.alt, block.caption, {\n      // Note: alignment is handled differently in ArticleBuilder\n    });\n  }\n\n  /**\n   * Adds a callout/note block\n   */\n  private static addCallout(builder: ArticleBuilder, block: CalloutBlock): void {\n    const color = CALLOUT_COLOR_MAP[block.variant] ?? 'primary';\n    const prefix = block.title ?? CALLOUT_PREFIX_MAP[block.variant] ?? 'Nota:';\n    builder.note(block.text, prefix, color);\n  }\n\n  /**\n   * Adds a divider/separator block\n   */\n  private static addDivider(builder: ArticleBuilder, block: DividerBlock): void {\n    builder.separator(block.style ?? 'line');\n  }\n\n  /**\n   * Adds a button block\n   */\n  private static addButton(builder: ArticleBuilder, block: ButtonBlock): void {\n    const colorMap: Record<string, Color> = {\n      primary: 'primary',\n      secondary: 'secondary',\n      success: 'success',\n      warning: 'warning',\n      danger: 'danger',\n    };\n\n    builder.button(\n      {\n        text: block.text,\n        color: colorMap[block.color ?? 'primary'] ?? 'primary',\n        fill: 'solid',\n        type: 'button',\n        state: ComponentStates.ENABLED,\n        href: block.href,\n        token: block.action,\n      },\n      block.alignment ?? 'center'\n    );\n  }\n\n  /**\n   * Adds a command/terminal block\n   */\n  private static addCommand(builder: ArticleBuilder, block: CommandBlock): void {\n    builder.command(block.command);\n  }\n}\n\n/**\n * Convenience function to transform a ContentDocument to ArticleMetadata\n *\n * @param doc - The content document to transform\n * @returns ArticleMetadata ready for val-article component\n *\n * @example\n * ```typescript\n * const article = toArticle(myBlogPost);\n * ```\n */\nexport function toArticle(doc: ContentDocument): ArticleMetadata {\n  return ContentTransformer.toArticle(doc);\n}\n"]}

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

@@ -0,0 +1,41 @@
+/**
+ * Content Types System
+ *
+ * This module provides a content abstraction layer that transforms
+ * structured content documents (blog posts, documentation, news articles)
+ * into ArticleMetadata for rendering with val-article component.
+ */
+// =============================================================================
+// TYPE GUARDS
+// =============================================================================
+/**
+ * Type guard to check if a block is a heading
+ */
+export function isHeadingBlock(block) {
+    return block.type === 'heading';
+}
+/**
+ * Type guard to check if a block is a paragraph
+ */
+export function isParagraphBlock(block) {
+    return block.type === 'paragraph';
+}
+/**
+ * Type guard to check if a block is a code block
+ */
+export function isCodeBlock(block) {
+    return block.type === 'code';
+}
+/**
+ * Type guard to check if a block is a list
+ */
+export function isListBlock(block) {
+    return block.type === 'list';
+}
+/**
+ * Type guard to check if a block is a callout
+ */
+export function isCalloutBlock(block) {
+    return block.type === 'callout';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/lib/services/content/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAwOH,gFAAgF;AAChF,cAAc;AACd,gFAAgF;AAEhF;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,KAAmB;IAChD,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAClC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAmB;IAClD,OAAO,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,KAAmB;IAC7C,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,KAAmB;IAC7C,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,KAAmB;IAChD,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAClC,CAAC","sourcesContent":["/**\n * Content Types System\n *\n * This module provides a content abstraction layer that transforms\n * structured content documents (blog posts, documentation, news articles)\n * into ArticleMetadata for rendering with val-article component.\n */\n\n// =============================================================================\n// AUTHOR & META\n// =============================================================================\n\n/**\n * Author information for content documents\n */\nexport interface ContentAuthor {\n  /** Author's display name */\n  name: string;\n  /** URL to author's avatar image */\n  avatar?: string;\n  /** Author's role or title */\n  role?: string;\n  /** Link to author's profile */\n  profileUrl?: string;\n}\n\n/**\n * Common metadata for all content documents\n */\nexport interface ContentMeta {\n  /** Unique identifier */\n  id?: string;\n  /** URL-friendly slug */\n  slug?: string;\n  /** Creation date */\n  createdAt?: Date | string;\n  /** Last update date */\n  updatedAt?: Date | string;\n  /** Publication date */\n  publishedAt?: Date | string;\n  /** Content author */\n  author?: ContentAuthor;\n  /** Tags for categorization */\n  tags?: string[];\n  /** Primary category */\n  category?: string;\n  /** Content locale (e.g., 'es', 'en') */\n  locale?: string;\n}\n\n// =============================================================================\n// CONTENT BLOCKS\n// =============================================================================\n\n/**\n * Heading block - renders as title or subtitle\n */\nexport interface HeadingBlock {\n  type: 'heading';\n  /** Heading level: 1 = title, 2-3 = subtitle */\n  level: 1 | 2 | 3;\n  /** Heading text */\n  text: string;\n}\n\n/**\n * Paragraph block - renders as text\n */\nexport interface ParagraphBlock {\n  type: 'paragraph';\n  /** Paragraph text content */\n  text: string;\n  /** Apply emphasis styling */\n  emphasis?: boolean;\n}\n\n/**\n * Quote block - renders as blockquote\n */\nexport interface QuoteBlock {\n  type: 'quote';\n  /** Quote text */\n  text: string;\n  /** Quote author name */\n  author?: string;\n  /** Quote source */\n  source?: string;\n}\n\n/**\n * Code block - renders as syntax-highlighted code\n */\nexport interface CodeBlock {\n  type: 'code';\n  /** Code content */\n  code: string;\n  /** Programming language for syntax highlighting */\n  language?: string;\n  /** Code block title/filename */\n  title?: string;\n}\n\n/**\n * List block - renders as ordered, unordered, or checklist\n */\nexport interface ListBlock {\n  type: 'list';\n  /** List items (simple strings) */\n  items: string[];\n  /** Render as numbered list */\n  ordered?: boolean;\n  /** Render as checklist with checkmarks */\n  checklist?: boolean;\n}\n\n/**\n * Image block - renders as image with optional caption\n */\nexport interface ImageBlock {\n  type: 'image';\n  /** Image source URL */\n  src: string;\n  /** Alt text for accessibility */\n  alt: string;\n  /** Image caption */\n  caption?: string;\n  /** Image alignment */\n  alignment?: 'left' | 'center' | 'right';\n}\n\n/**\n * Callout block - renders as highlighted note/warning\n */\nexport interface CalloutBlock {\n  type: 'callout';\n  /** Callout text content */\n  text: string;\n  /** Callout variant determines styling */\n  variant: 'info' | 'warning' | 'success' | 'error';\n  /** Optional title/prefix */\n  title?: string;\n}\n\n/**\n * Divider block - renders as separator line\n */\nexport interface DividerBlock {\n  type: 'divider';\n  /** Divider style */\n  style?: 'line' | 'dots' | 'space';\n}\n\n/**\n * Button block - renders as call-to-action button\n */\nexport interface ButtonBlock {\n  type: 'button';\n  /** Button text */\n  text: string;\n  /** Link URL (for navigation) */\n  href?: string;\n  /** Action identifier (for event handling) */\n  action?: string;\n  /** Button color */\n  color?: 'primary' | 'secondary' | 'success' | 'warning' | 'danger';\n  /** Button alignment */\n  alignment?: 'left' | 'center' | 'right';\n}\n\n/**\n * Command block - renders as terminal/CLI command\n */\nexport interface CommandBlock {\n  type: 'command';\n  /** Command to display */\n  command: string;\n  /** Show copy button */\n  copyable?: boolean;\n}\n\n/**\n * Union type of all content blocks\n */\nexport type ContentBlock =\n  | HeadingBlock\n  | ParagraphBlock\n  | QuoteBlock\n  | CodeBlock\n  | ListBlock\n  | ImageBlock\n  | CalloutBlock\n  | DividerBlock\n  | ButtonBlock\n  | CommandBlock;\n\n// =============================================================================\n// CONTENT DOCUMENT\n// =============================================================================\n\n/**\n * Configuration options for content rendering\n */\nexport interface ContentConfig {\n  /** Article theme */\n  theme?: 'light' | 'dark' | 'auto';\n  /** Maximum width of the content container */\n  maxWidth?: string;\n  /** Show metadata (author, date, etc.) */\n  showMeta?: boolean;\n  /** Show table of contents */\n  showTableOfContents?: boolean;\n  /** Center the content container */\n  centered?: boolean;\n}\n\n/**\n * Base interface for all content documents.\n * Generic type T represents the document type discriminator.\n *\n * @example\n * ```typescript\n * interface BlogPost extends ContentDocument<'blog'> {\n *   title: string;\n *   excerpt: string;\n * }\n * ```\n */\nexport interface ContentDocument<T extends string = string> {\n  /** Document type discriminator */\n  type: T;\n  /** Document metadata */\n  meta: ContentMeta;\n  /** Array of content blocks */\n  content: ContentBlock[];\n  /** Rendering configuration */\n  config?: ContentConfig;\n}\n\n// =============================================================================\n// TYPE GUARDS\n// =============================================================================\n\n/**\n * Type guard to check if a block is a heading\n */\nexport function isHeadingBlock(block: ContentBlock): block is HeadingBlock {\n  return block.type === 'heading';\n}\n\n/**\n * Type guard to check if a block is a paragraph\n */\nexport function isParagraphBlock(block: ContentBlock): block is ParagraphBlock {\n  return block.type === 'paragraph';\n}\n\n/**\n * Type guard to check if a block is a code block\n */\nexport function isCodeBlock(block: ContentBlock): block is CodeBlock {\n  return block.type === 'code';\n}\n\n/**\n * Type guard to check if a block is a list\n */\nexport function isListBlock(block: ContentBlock): block is ListBlock {\n  return block.type === 'list';\n}\n\n/**\n * Type guard to check if a block is a callout\n */\nexport function isCalloutBlock(block: ContentBlock): block is CalloutBlock {\n  return block.type === 'callout';\n}\n"]}

package/esm2022/lib/services/docs/docs-navigation.service.mjs

@@ -0,0 +1,91 @@
+import { Injectable, inject } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+/**
+ * Service for handling documentation navigation with scroll management.
+ *
+ * @example
+ * ```typescript
+ * import { DocsNavigationService } from 'valtech-components';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   private docsNav = inject(DocsNavigationService);
+ *
+ *   onLinkClick(route: string[]) {
+ *     this.docsNav.navigateAndScroll(route);
+ *   }
+ * }
+ * ```
+ */
+export class DocsNavigationService {
+    constructor() {
+        this.router = inject(Router);
+        /**
+         * Default scroll container selector.
+         * Can be overridden per-call or globally.
+         */
+        this.defaultScrollSelector = '.docs-main-scroll';
+    }
+    /**
+     * Navigate to a route and scroll to top.
+     * @param route - Route segments to navigate to
+     * @param scrollSelector - Optional custom scroll container selector
+     */
+    async navigateAndScroll(route, scrollSelector) {
+        const result = await this.router.navigate(route);
+        if (result) {
+            this.scrollToTop(scrollSelector);
+        }
+        return result;
+    }
+    /**
+     * Scroll to top of the documentation content.
+     * Tries multiple scroll containers for compatibility.
+     * @param scrollSelector - Optional custom scroll container selector
+     */
+    scrollToTop(scrollSelector) {
+        const selector = scrollSelector || this.defaultScrollSelector;
+        // 1. Try ion-content first (Ionic)
+        const ionContent = document.querySelector('ion-content');
+        if (ionContent && typeof ionContent.scrollToTop === 'function') {
+            ionContent.scrollToTop(0);
+        }
+        // 2. Try the main scrollable element
+        const mainScroll = document.querySelector(selector);
+        if (mainScroll) {
+            mainScroll.scrollTop = 0;
+        }
+        // 3. Fallback to window/document scroll
+        window.scrollTo({ top: 0, behavior: 'instant' });
+        document.documentElement.scrollTop = 0;
+        document.body.scrollTop = 0;
+    }
+    /**
+     * Scroll to a specific element by ID.
+     * @param elementId - The ID of the element to scroll to
+     * @param scrollSelector - Optional custom scroll container selector
+     */
+    scrollToElement(elementId, scrollSelector) {
+        const element = document.getElementById(elementId);
+        if (element) {
+            element.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        }
+    }
+    /**
+     * Set the default scroll container selector.
+     * @param selector - CSS selector for the scroll container
+     */
+    setDefaultScrollSelector(selector) {
+        this.defaultScrollSelector = selector;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DocsNavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DocsNavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DocsNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/donation/config.mjs

@@ -0,0 +1,41 @@
+import { InjectionToken, makeEnvironmentProviders } from '@angular/core';
+/**
+ * Token de inyección para la configuración de Donation/Support.
+ */
+export const VALTECH_DONATION_CONFIG = new InjectionToken('ValtechDonationConfig');
+/** Configuración por defecto — sin métodos habilitados. */
+export const DEFAULT_DONATION_CONFIG = {
+    methods: [],
+};
+/**
+ * Provee el feature de aportes (Support) a la aplicación Angular.
+ *
+ * Cada app del factory declara qué métodos habilita. La vista de Support
+ * (heredada o local) renderiza solo los métodos configurados.
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * provideValtechDonations({
+ *   appId: 'showcase',
+ *   methods: ['coffee', 'bank', 'ads'],
+ *   coffee: { provider: 'buymeacoffee', url: 'https://buymeacoffee.com/valtech' },
+ *   bank: {
+ *     accounts: [{
+ *       country: 'CL', bank: 'Banco X', accountType: 'Cuenta Corriente',
+ *       number: '000000000', taxId: '11.111.111-1', holder: 'Valtech SpA',
+ *       email: 'aportes@valtech.com', currency: 'CLP',
+ *     }],
+ *   },
+ *   ads: { provider: 'admob', rewardedUnitId: 'ca-app-pub-xxx' },
+ * }),
+ * ```
+ */
+export function provideValtechDonations(config) {
+    const merged = {
+        ...DEFAULT_DONATION_CONFIG,
+        ...config,
+    };
+    return makeEnvironmentProviders([{ provide: VALTECH_DONATION_CONFIG, useValue: merged }]);
+}
+//# sourceMappingURL=data:application/json;base64,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