valtech-components 2.0.821 → 2.0.823

package/esm2022/lib/components/organisms/article/types.mjs

@@ -0,0 +1,183 @@
+/**
+ * Configuración de espaciado predefinida
+ */
+export const ARTICLE_SPACING = {
+    NONE: { top: 'none', bottom: 'none' },
+    SMALL: { top: 'small', bottom: 'small' },
+    MEDIUM: { top: 'medium', bottom: 'medium' },
+    LARGE: { top: 'large', bottom: 'large' },
+    XLARGE: { top: 'xlarge', bottom: 'xlarge' },
+    // Espaciados específicos para elementos
+    TITLE: { top: 'large', bottom: 'medium' },
+    SUBTITLE: { top: 'medium', bottom: 'small' },
+    PARAGRAPH: { top: 'small', bottom: 'medium' },
+    QUOTE: { top: 'medium', bottom: 'medium' },
+    CODE: { top: 'medium', bottom: 'medium' },
+    NOTE: { top: 'medium', bottom: 'medium' },
+    COMMAND: { top: 'medium', bottom: 'medium' },
+    LIST: { top: 'small', bottom: 'medium' },
+    BUTTON: { top: 'medium', bottom: 'medium' },
+    IMAGE: { top: 'large', bottom: 'large' },
+    SEPARATOR: { top: 'large', bottom: 'large' },
+};
+/**
+ * Función helper para crear elementos de artículo de forma fácil
+ */
+export class ArticleBuilder {
+    constructor() {
+        this.elements = [];
+    }
+    /**
+     * Añade un título al artículo
+     */
+    title(props, options) {
+        this.elements.push({
+            type: 'title',
+            props,
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade un subtítulo al artículo
+     */
+    subtitle(props, options) {
+        this.elements.push({
+            type: 'subtitle',
+            props,
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade un párrafo al artículo
+     */
+    paragraph(props, options) {
+        this.elements.push({
+            type: 'paragraph',
+            props,
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade una cita al artículo
+     */
+    quote(props, options) {
+        this.elements.push({
+            type: 'quote',
+            props,
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade código al artículo
+     */
+    code(code, language, options) {
+        this.elements.push({
+            type: 'code',
+            props: { code, language },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade una lista al artículo
+     */
+    list(items, listType, options) {
+        this.elements.push({
+            type: 'list',
+            props: { items, listType },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade un botón al artículo
+     */
+    button(props, alignment, options) {
+        this.elements.push({
+            type: 'button',
+            props: { ...props, alignment },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade un separador al artículo
+     */
+    separator(style, options) {
+        this.elements.push({
+            type: 'separator',
+            props: { style },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade una imagen al artículo
+     */
+    image(src, alt, caption, options) {
+        this.elements.push({
+            type: 'image',
+            props: { src, alt, caption },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade una nota destacada al artículo
+     */
+    note(text, prefix, color, options) {
+        this.elements.push({
+            type: 'note',
+            props: {
+                text,
+                prefix: prefix || 'Nota:',
+                color: color || 'warning',
+                textColor: 'dark',
+                size: 'medium',
+                rounded: true,
+            },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Añade un comando de terminal al artículo
+     * Acepta un string simple o un array de comandos
+     */
+    command(command, options) {
+        const commands = Array.isArray(command) ? command : [command];
+        this.elements.push({
+            type: 'command',
+            props: {
+                lines: commands.map(cmd => ({ text: cmd, type: 'command' })),
+                showCopyButton: true,
+            },
+            ...options,
+        });
+        return this;
+    }
+    /**
+     * Construye el artículo final
+     */
+    build(config) {
+        return {
+            elements: this.elements,
+            maxWidth: 'auto',
+            centered: true,
+            theme: 'auto',
+            ...config,
+        };
+    }
+    /**
+     * Resetea el builder para crear un nuevo artículo
+     */
+    clear() {
+        this.elements = [];
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/article/types.ts"],"names":[],"mappings":"AAgVA;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAoB;IACvD,KAAK,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAoB;IAC1D,MAAM,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC7D,KAAK,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAoB;IAC1D,MAAM,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAE7D,wCAAwC;IACxC,KAAK,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC3D,QAAQ,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAoB;IAC9D,SAAS,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC/D,KAAK,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC5D,IAAI,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC3D,IAAI,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC3D,OAAO,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC9D,IAAI,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC1D,MAAM,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAoB;IAC7D,KAAK,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAoB;IAC1D,SAAS,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAoB;CACtD,CAAC;AAEX;;GAEG;AACH,MAAM,OAAO,cAAc;IAA3B;QACU,aAAQ,GAAqB,EAAE,CAAC;IA8L1C,CAAC;IA5LC;;OAEG;IACH,KAAK,CAAC,KAAoB,EAAE,OAAqC;QAC/D,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,OAAO;YACb,KAAK;YACL,GAAG,OAAO;SACY,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,KAAoB,EAAE,OAAqC;QAClE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,UAAU;YAChB,KAAK;YACL,GAAG,OAAO;SACe,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAmB,EAAE,OAAqC;QAClE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,WAAW;YACjB,KAAK;YACL,GAAG,OAAO;SACW,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK,CACH,KAAmC,EACnC,OAAqC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,OAAO;YACb,KAAK;YACL,GAAG,OAAO;SACY,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,IAAY,EAAE,QAAiB,EAAE,OAAqC;QACzE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACzB,GAAG,OAAO;SACW,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,IAAI,CACF,KAA2C,EAC3C,QAAkD,EAClD,OAAqC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;YAC1B,GAAG,OAAO;SACW,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM,CACJ,KAAqB,EACrB,SAAuC,EACvC,OAAqC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE;YAC9B,GAAG,OAAO;SACa,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,SAAS,CACP,KAAiC,EACjC,OAAqC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE,EAAE,KAAK,EAAE;YAChB,GAAG,OAAO;SACgB,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK,CACH,GAAW,EACX,GAAW,EACX,OAAgB,EAChB,OAAqC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE;YAC5B,GAAG,OAAO;SACY,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,IAAI,CACF,IAAY,EACZ,MAAe,EACf,KAAa,EACb,OAAqC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE;gBACL,IAAI;gBACJ,MAAM,EAAE,MAAM,IAAI,OAAO;gBACzB,KAAK,EAAE,KAAK,IAAI,SAAS;gBACzB,SAAS,EAAE,MAAM;gBACjB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,IAAI;aACd;YACD,GAAG,OAAO;SACW,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,OAA0B,EAAE,OAAqC;QACvE,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC9D,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,SAAS;YACf,KAAK,EAAE;gBACL,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,SAAkB,EAAE,CAAC,CAAC;gBACrE,cAAc,EAAE,IAAI;aACrB;YACD,GAAG,OAAO;SACc,CAAC,CAAC;QAC5B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAiC;QACrC,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,MAAM;YAChB,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE,MAAM;YACb,GAAG,MAAM;SACV,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import { Color } from '@ionic/core';\nimport { TextMetadata } from '../../atoms/text/types';\nimport { TitleMetadata } from '../../atoms/title/types';\nimport { ButtonMetadata } from '../../types';\n\n/**\n * Tipos de contenido soportados en el componente val-article\n */\nexport type ArticleContentType =\n  | 'title'\n  | 'subtitle'\n  | 'text'\n  | 'paragraph'\n  | 'quote'\n  | 'highlight'\n  | 'code'\n  | 'note'\n  | 'command'\n  | 'list'\n  | 'button'\n  | 'separator'\n  | 'image'\n  | 'video'\n  | 'custom';\n\n/**\n * Configuración de espaciado entre elementos\n */\nexport interface ArticleSpacing {\n  /** Espaciado superior */\n  top?: 'none' | 'small' | 'medium' | 'large' | 'xlarge';\n  /** Espaciado inferior */\n  bottom?: 'none' | 'small' | 'medium' | 'large' | 'xlarge';\n  /** Espaciado lateral */\n  horizontal?: 'none' | 'small' | 'medium' | 'large' | 'xlarge';\n}\n\n/**\n * Configuración base para cualquier elemento del artículo\n */\nexport interface BaseArticleElement {\n  /** Tipo de elemento */\n  type: ArticleContentType;\n  /** ID único del elemento (opcional) */\n  id?: string;\n  /** Clases CSS adicionales */\n  cssClass?: string;\n  /** Configuración de espaciado */\n  spacing?: ArticleSpacing;\n  /** Elemento visible condicionalmente */\n  visible?: boolean;\n}\n\n/**\n * Elemento de título\n */\nexport interface ArticleTitleElement extends BaseArticleElement {\n  type: 'title';\n  props: TitleMetadata;\n}\n\n/**\n * Elemento de subtítulo\n */\nexport interface ArticleSubtitleElement extends BaseArticleElement {\n  type: 'subtitle';\n  props: TitleMetadata;\n}\n\n/**\n * Elemento de texto/párrafo\n */\nexport interface ArticleTextElement extends BaseArticleElement {\n  type: 'text' | 'paragraph';\n  props: TextMetadata;\n}\n\n/**\n * Elemento de cita\n */\nexport interface ArticleQuoteElement extends BaseArticleElement {\n  type: 'quote';\n  props: TextMetadata & {\n    /** Autor de la cita */\n    author?: string;\n    /** Fuente de la cita */\n    source?: string;\n    /** Color del nombre del autor */\n    authorColor?: Color;\n    /** Alineación del texto */\n    alignment?: 'left' | 'center' | 'right';\n    /** Mostrar comillas decorativas */\n    showQuoteMark?: boolean;\n  };\n}\n\n/**\n * Elemento de texto destacado\n */\nexport interface ArticleHighlightElement extends BaseArticleElement {\n  type: 'highlight';\n  props: TextMetadata & {\n    /** Color de fondo del highlight */\n    backgroundColor?: Color;\n    /** Esquinas redondeadas */\n    rounded?: boolean;\n  };\n}\n\n/**\n * Elemento de código\n */\nexport interface ArticleCodeElement extends BaseArticleElement {\n  type: 'code';\n  props: {\n    /** Código a mostrar */\n    code: string;\n    /** Lenguaje de programación */\n    language?: string;\n    /** Mostrar números de línea */\n    showLineNumbers?: boolean;\n    /** Tema del código */\n    theme?: 'light' | 'dark';\n  };\n}\n\n/**\n * Elemento de nota destacada\n */\nexport interface ArticleNoteElement extends BaseArticleElement {\n  type: 'note';\n  props: {\n    /** Texto principal de la nota. Puede contener `<strong>`/`<b>` si `allowPartialBold` está activo. */\n    text: string;\n    /** Prefijo en negrita (ej: \"Nota:\"). Pasa `''` (string vacío) para suprimir el prefijo. */\n    prefix?: string;\n    /** Color de fondo */\n    color?: Color;\n    /** Color del texto */\n    textColor?: Color;\n    /** Tamaño del texto */\n    size?: 'small' | 'medium' | 'large' | 'xlarge';\n    /** Esquinas redondeadas */\n    rounded?: boolean;\n    /** Padding personalizado */\n    padding?: string;\n    /** Renderiza `<strong>`/`<b>` inline en `text` via innerHTML. Default `false`. */\n    allowPartialBold?: boolean;\n    /** Procesa URLs y `[text](url)` en `text`. Default `false`. */\n    processLinks?: boolean;\n    /** Compact mode — inline-block fit-content, padding reducido, sin left-border. */\n    compact?: boolean;\n    /** Alineación del texto. Default `'left'`. */\n    align?: 'left' | 'center' | 'right';\n  };\n}\n\n/**\n * Elemento de comando de terminal\n */\nexport interface ArticleCommandElement extends BaseArticleElement {\n  type: 'command';\n  props: {\n    /** Líneas de comando */\n    lines: Array<{\n      /** Texto del comando */\n      text: string;\n      /** Tipo de línea */\n      type?: 'normal' | 'command' | 'success' | 'error';\n    }>;\n    /** Mostrar botón de copiar */\n    showCopyButton?: boolean;\n    /** Lenguaje (opcional) */\n    language?: string;\n  };\n}\n\n/**\n * Elemento de lista\n */\nexport interface ArticleListElement extends BaseArticleElement {\n  type: 'list';\n  props: {\n    /** Elementos de la lista */\n    items: Array<{\n      /** Texto del elemento */\n      text: string;\n      /** Configuración de contenido reactivo */\n      contentKey?: string;\n      contentClass?: string;\n      contentFallback?: string;\n      contentInterpolation?: Record<string, string | number>;\n    }>;\n    /** Tipo de lista */\n    listType?: 'unordered' | 'ordered' | 'checklist';\n    /** Color de los elementos */\n    color?: Color;\n  };\n}\n\n/**\n * Elemento de botón\n */\nexport interface ArticleButtonElement extends BaseArticleElement {\n  type: 'button';\n  props: ButtonMetadata & {\n    /** Alineación del botón */\n    alignment?: 'left' | 'center' | 'right';\n  };\n}\n\n/**\n * Elemento separador\n */\nexport interface ArticleSeparatorElement extends BaseArticleElement {\n  type: 'separator';\n  props: {\n    /** Tipo de separador */\n    style?: 'line' | 'dots' | 'space';\n    /** Color del separador */\n    color?: Color;\n    /** Grosor del separador */\n    thickness?: 'thin' | 'medium' | 'thick';\n  };\n}\n\n/**\n * Elemento de imagen\n */\nexport interface ArticleImageElement extends BaseArticleElement {\n  type: 'image';\n  props: {\n    /** URL de la imagen */\n    src: string;\n    /** Texto alternativo */\n    alt: string;\n    /** Título de la imagen */\n    title?: string;\n    /** Leyenda de la imagen */\n    caption?: string;\n    /** Configuración de contenido reactivo para caption */\n    captionContentKey?: string;\n    captionContentClass?: string;\n    captionContentFallback?: string;\n    /** Alineación de la imagen */\n    alignment?: 'left' | 'center' | 'right';\n    /** Ancho máximo */\n    maxWidth?: string;\n    /** Imagen con bordes redondeados */\n    rounded?: boolean;\n    /** Tamaño de la imagen */\n    size?: 'small' | 'medium' | 'large' | 'xlarge';\n    /** Modo preview (click para ampliar) */\n    preview?: boolean;\n  };\n}\n\n/**\n * Elemento de video\n */\nexport interface ArticleVideoElement extends BaseArticleElement {\n  type: 'video';\n  props: {\n    /** URL del video */\n    src: string;\n    /** Imagen de poster */\n    poster?: string;\n    /** Título del video */\n    title?: string;\n    /** Controles visibles */\n    controls?: boolean;\n    /** Reproducción automática */\n    autoplay?: boolean;\n    /** Silenciado por defecto */\n    muted?: boolean;\n    /** Ancho máximo */\n    maxWidth?: string;\n  };\n}\n\n/**\n * Elemento personalizado\n */\nexport interface ArticleCustomElement extends BaseArticleElement {\n  type: 'custom';\n  props: {\n    /** Contenido HTML personalizado */\n    htmlContent?: string;\n    /** Clase de componente personalizado */\n    componentClass?: any;\n    /** Props para el componente personalizado */\n    componentProps?: any;\n  };\n}\n\n/**\n * Unión de todos los tipos de elementos posibles\n */\nexport type ArticleElement =\n  | ArticleTitleElement\n  | ArticleSubtitleElement\n  | ArticleTextElement\n  | ArticleQuoteElement\n  | ArticleHighlightElement\n  | ArticleCodeElement\n  | ArticleNoteElement\n  | ArticleCommandElement\n  | ArticleListElement\n  | ArticleButtonElement\n  | ArticleSeparatorElement\n  | ArticleImageElement\n  | ArticleVideoElement\n  | ArticleCustomElement;\n\n/**\n * Configuración del artículo completo\n */\nexport interface ArticleMetadata {\n  /** Elementos del artículo */\n  elements: ArticleElement[];\n  /** Padding interno del contenedor article */\n  containerSpacing?: ArticleSpacing;\n  /** Override global de spacing para elementos (prioridad sobre spacing por tipo) */\n  elementSpacing?: ArticleSpacing;\n  /** @deprecated Usar elementSpacing en su lugar */\n  defaultSpacing?: ArticleSpacing;\n  /** Ancho máximo del artículo */\n  maxWidth?: string;\n  /** Centrar el artículo */\n  centered?: boolean;\n  /** Tema del artículo */\n  theme?: 'light' | 'dark' | 'auto';\n  /** Clases CSS adicionales */\n  cssClass?: string;\n}\n\n/**\n * Configuración de espaciado predefinida\n */\nexport const ARTICLE_SPACING = {\n  NONE: { top: 'none', bottom: 'none' } as ArticleSpacing,\n  SMALL: { top: 'small', bottom: 'small' } as ArticleSpacing,\n  MEDIUM: { top: 'medium', bottom: 'medium' } as ArticleSpacing,\n  LARGE: { top: 'large', bottom: 'large' } as ArticleSpacing,\n  XLARGE: { top: 'xlarge', bottom: 'xlarge' } as ArticleSpacing,\n\n  // Espaciados específicos para elementos\n  TITLE: { top: 'large', bottom: 'medium' } as ArticleSpacing,\n  SUBTITLE: { top: 'medium', bottom: 'small' } as ArticleSpacing,\n  PARAGRAPH: { top: 'small', bottom: 'medium' } as ArticleSpacing,\n  QUOTE: { top: 'medium', bottom: 'medium' } as ArticleSpacing,\n  CODE: { top: 'medium', bottom: 'medium' } as ArticleSpacing,\n  NOTE: { top: 'medium', bottom: 'medium' } as ArticleSpacing,\n  COMMAND: { top: 'medium', bottom: 'medium' } as ArticleSpacing,\n  LIST: { top: 'small', bottom: 'medium' } as ArticleSpacing,\n  BUTTON: { top: 'medium', bottom: 'medium' } as ArticleSpacing,\n  IMAGE: { top: 'large', bottom: 'large' } as ArticleSpacing,\n  SEPARATOR: { top: 'large', bottom: 'large' } as ArticleSpacing,\n} as const;\n\n/**\n * Función helper para crear elementos de artículo de forma fácil\n */\nexport class ArticleBuilder {\n  private elements: ArticleElement[] = [];\n\n  /**\n   * Añade un título al artículo\n   */\n  title(props: TitleMetadata, options?: Partial<BaseArticleElement>): ArticleBuilder {\n    this.elements.push({\n      type: 'title',\n      props,\n      ...options,\n    } as ArticleTitleElement);\n    return this;\n  }\n\n  /**\n   * Añade un subtítulo al artículo\n   */\n  subtitle(props: TitleMetadata, options?: Partial<BaseArticleElement>): ArticleBuilder {\n    this.elements.push({\n      type: 'subtitle',\n      props,\n      ...options,\n    } as ArticleSubtitleElement);\n    return this;\n  }\n\n  /**\n   * Añade un párrafo al artículo\n   */\n  paragraph(props: TextMetadata, options?: Partial<BaseArticleElement>): ArticleBuilder {\n    this.elements.push({\n      type: 'paragraph',\n      props,\n      ...options,\n    } as ArticleTextElement);\n    return this;\n  }\n\n  /**\n   * Añade una cita al artículo\n   */\n  quote(\n    props: ArticleQuoteElement['props'],\n    options?: Partial<BaseArticleElement>\n  ): ArticleBuilder {\n    this.elements.push({\n      type: 'quote',\n      props,\n      ...options,\n    } as ArticleQuoteElement);\n    return this;\n  }\n\n  /**\n   * Añade código al artículo\n   */\n  code(code: string, language?: string, options?: Partial<BaseArticleElement>): ArticleBuilder {\n    this.elements.push({\n      type: 'code',\n      props: { code, language },\n      ...options,\n    } as ArticleCodeElement);\n    return this;\n  }\n\n  /**\n   * Añade una lista al artículo\n   */\n  list(\n    items: ArticleListElement['props']['items'],\n    listType?: ArticleListElement['props']['listType'],\n    options?: Partial<BaseArticleElement>\n  ): ArticleBuilder {\n    this.elements.push({\n      type: 'list',\n      props: { items, listType },\n      ...options,\n    } as ArticleListElement);\n    return this;\n  }\n\n  /**\n   * Añade un botón al artículo\n   */\n  button(\n    props: ButtonMetadata,\n    alignment?: 'left' | 'center' | 'right',\n    options?: Partial<BaseArticleElement>\n  ): ArticleBuilder {\n    this.elements.push({\n      type: 'button',\n      props: { ...props, alignment },\n      ...options,\n    } as ArticleButtonElement);\n    return this;\n  }\n\n  /**\n   * Añade un separador al artículo\n   */\n  separator(\n    style?: 'line' | 'dots' | 'space',\n    options?: Partial<BaseArticleElement>\n  ): ArticleBuilder {\n    this.elements.push({\n      type: 'separator',\n      props: { style },\n      ...options,\n    } as ArticleSeparatorElement);\n    return this;\n  }\n\n  /**\n   * Añade una imagen al artículo\n   */\n  image(\n    src: string,\n    alt: string,\n    caption?: string,\n    options?: Partial<BaseArticleElement>\n  ): ArticleBuilder {\n    this.elements.push({\n      type: 'image',\n      props: { src, alt, caption },\n      ...options,\n    } as ArticleImageElement);\n    return this;\n  }\n\n  /**\n   * Añade una nota destacada al artículo\n   */\n  note(\n    text: string,\n    prefix?: string,\n    color?: Color,\n    options?: Partial<BaseArticleElement>\n  ): ArticleBuilder {\n    this.elements.push({\n      type: 'note',\n      props: {\n        text,\n        prefix: prefix || 'Nota:',\n        color: color || 'warning',\n        textColor: 'dark',\n        size: 'medium',\n        rounded: true,\n      },\n      ...options,\n    } as ArticleNoteElement);\n    return this;\n  }\n\n  /**\n   * Añade un comando de terminal al artículo\n   * Acepta un string simple o un array de comandos\n   */\n  command(command: string | string[], options?: Partial<BaseArticleElement>): ArticleBuilder {\n    const commands = Array.isArray(command) ? command : [command];\n    this.elements.push({\n      type: 'command',\n      props: {\n        lines: commands.map(cmd => ({ text: cmd, type: 'command' as const })),\n        showCopyButton: true,\n      },\n      ...options,\n    } as ArticleCommandElement);\n    return this;\n  }\n\n  /**\n   * Construye el artículo final\n   */\n  build(config?: Partial<ArticleMetadata>): ArticleMetadata {\n    return {\n      elements: this.elements,\n      maxWidth: 'auto',\n      centered: true,\n      theme: 'auto',\n      ...config,\n    };\n  }\n\n  /**\n   * Resetea el builder para crear un nuevo artículo\n   */\n  clear(): ArticleBuilder {\n    this.elements = [];\n    return this;\n  }\n}\n"]}

package/esm2022/lib/components/organisms/avatar-upload/avatar-upload.component.mjs

@@ -0,0 +1,325 @@
+import { CommonModule } from '@angular/common';
+import { Component, computed, EventEmitter, inject, input, Output, signal, ViewChild } from '@angular/core';
+import { IonIcon, IonModal, IonSpinner } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { cameraOutline } from 'ionicons/icons';
+import { firstValueFrom } from 'rxjs';
+import { AuthService } from '../../../services/auth';
+import { StorageService } from '../../../services/firebase';
+import { I18nService } from '../../../services/i18n';
+import { ImageService } from '../../../services/image';
+import { ImageCropComponent } from '../../molecules/image-crop';
+import { AVATAR_UPLOAD_DEFAULTS } from './types';
+import * as i0 from "@angular/core";
+addIcons({ cameraOutline });
+/**
+ * AvatarUploadComponent
+ *
+ * A complete avatar upload solution with:
+ * - Image selection from device
+ * - Crop modal with round preview
+ * - Automatic compression and thumbnail generation
+ * - Upload to Firebase Storage
+ * - Backend sync via AuthService
+ *
+ * @example Basic usage
+ * ```html
+ * <val-avatar-upload
+ *   [props]="{
+ *     currentUrl: user()?.avatarUrl,
+ *     initials: 'JD',
+ *     size: 120
+ *   }"
+ *   (uploaded)="onAvatarUploaded($event)"
+ *   (error)="onError($event)"
+ * />
+ * ```
+ */
+export class AvatarUploadComponent {
+    constructor() {
+        this.imageService = inject(ImageService);
+        this.storageService = inject(StorageService);
+        this.authService = inject(AuthService);
+        this.i18n = inject(I18nService);
+        /** Component configuration */
+        this.props = input({});
+        /** Emitted after successful upload and backend sync */
+        this.uploaded = new EventEmitter();
+        /** Emitted on any error during the process */
+        this.error = new EventEmitter();
+        /** Emitted when upload starts */
+        this.uploadStart = new EventEmitter();
+        // Internal state
+        this.loading = signal(false);
+        this.showCropModal = signal(false);
+        this.selectedFile = signal(null);
+        this.previewUrl = signal(null);
+        this.imageLoadError = signal(false);
+        /** Merged config with defaults */
+        this.config = computed(() => ({
+            ...AVATAR_UPLOAD_DEFAULTS,
+            ...this.props(),
+        }));
+        /** URL to display (preview takes priority over current) */
+        this.displayUrl = computed(() => {
+            if (this.imageLoadError())
+                return null;
+            return this.previewUrl() || this.config().currentUrl || null;
+        });
+        /** Aria label for edit button */
+        this.editButtonLabel = computed(() => {
+            this.i18n.lang();
+            return this.i18n.t('changePhoto', this.config().i18nNamespace) || 'Cambiar foto';
+        });
+    }
+    /** Open file picker dialog */
+    openFilePicker() {
+        this.fileInput.nativeElement.click();
+    }
+    /** Handle file selection */
+    onFileSelected(event) {
+        const input = event.target;
+        const file = input.files?.[0];
+        if (!file)
+            return;
+        // Reset input for same file selection
+        input.value = '';
+        // Validate file
+        const validation = this.imageService.validate(file, {
+            maxSize: this.config().maxFileSize,
+            allowedTypes: ['image/jpeg', 'image/png', 'image/webp'],
+        });
+        if (!validation.valid) {
+            this.emitError(validation.error, validation.message);
+            return;
+        }
+        // Open crop modal
+        this.selectedFile.set(file);
+        this.showCropModal.set(true);
+    }
+    /** Handle crop completion */
+    async onCropComplete(croppedBlob) {
+        this.showCropModal.set(false);
+        this.selectedFile.set(null);
+        await this.processAndUpload(croppedBlob);
+    }
+    /** Handle crop cancel */
+    onCropCancel() {
+        this.showCropModal.set(false);
+        this.selectedFile.set(null);
+    }
+    /** Handle crop load failure */
+    onCropLoadFailed() {
+        this.showCropModal.set(false);
+        this.selectedFile.set(null);
+        this.emitError('invalidType', this.i18n.t('loadFailed', this.config().i18nNamespace) || 'No se pudo cargar la imagen');
+    }
+    /** Handle image load error */
+    onImageError() {
+        this.imageLoadError.set(true);
+    }
+    /** Timeout for upload operations (30 seconds) */
+    static { this.UPLOAD_TIMEOUT_MS = 30000; }
+    /** Process cropped image and upload */
+    async processAndUpload(croppedBlob) {
+        this.loading.set(true);
+        this.uploadStart.emit();
+        // Timeout promise to prevent infinite loading
+        const uploadTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Upload timeout')), AvatarUploadComponent.UPLOAD_TIMEOUT_MS));
+        try {
+            const config = this.config();
+            // 1. Compress image
+            const compressed = await this.imageService.compress(croppedBlob, {
+                maxWidth: config.maxWidth,
+                maxHeight: config.maxWidth,
+                quality: config.compressQuality,
+            });
+            // 2. Generate thumbnail
+            const thumbnail = await this.imageService.thumbnail(compressed.blob, config.thumbnailSize);
+            // 3. Set preview immediately
+            this.previewUrl.set(compressed.dataUrl);
+            this.imageLoadError.set(false);
+            // 4. Get user ID for storage path
+            const userId = this.authService.user()?.userId;
+            if (!userId) {
+                throw new Error('User not authenticated');
+            }
+            // 5. Upload to Firebase Storage with predictable paths
+            // Path: users/{userId}/avatar.jpg - allows any app to construct URL with just userId
+            // skipPrefix: true - bypasses appId prefix for shared/cross-app paths
+            const avatarPath = `users/${userId}/avatar.jpg`;
+            const thumbPath = `users/${userId}/thumb.jpg`;
+            const uploadMetadata = { skipPrefix: true, contentType: 'image/jpeg' };
+            // Race against timeout to prevent infinite loading
+            const [avatarResult, thumbResult] = await Promise.race([
+                Promise.all([
+                    this.storageService.uploadAndGetUrl(avatarPath, compressed.blob, uploadMetadata),
+                    this.storageService.uploadAndGetUrl(thumbPath, thumbnail.blob, uploadMetadata),
+                ]),
+                uploadTimeout,
+            ]);
+            // 6. Update backend with URLs
+            await firstValueFrom(this.authService.updateAvatar({
+                avatarUrl: avatarResult.downloadUrl,
+                avatarThumbnail: thumbResult.downloadUrl,
+            }));
+            // 7. Update preview with cache-busting to force refresh
+            const cacheBuster = `?t=${Date.now()}`;
+            this.previewUrl.set(avatarResult.downloadUrl + cacheBuster);
+            // 8. Emit success
+            const result = {
+                avatarUrl: avatarResult.downloadUrl,
+                thumbnailUrl: thumbResult.downloadUrl,
+            };
+            this.uploaded.emit(result);
+        }
+        catch (err) {
+            console.error('[AvatarUpload] processAndUpload failed:', err);
+            // Revert preview on error
+            this.previewUrl.set(null);
+            // Determine error message based on error type
+            let message;
+            if (err instanceof Error) {
+                if (err.message === 'Upload timeout') {
+                    message =
+                        this.i18n.t('uploadTimeout', this.config().i18nNamespace) ||
+                            'La subida tardó demasiado. Verifica tu conexión.';
+                }
+                else {
+                    message = err.message;
+                }
+            }
+            else {
+                message = this.i18n.t('uploadError', this.config().i18nNamespace) || 'Error al subir la imagen';
+            }
+            this.emitError('uploadFailed', message, err);
+        }
+        finally {
+            this.loading.set(false);
+        }
+    }
+    /** Emit error event */
+    emitError(type, message, originalError) {
+        this.error.emit({ type, message, originalError });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AvatarUploadComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: AvatarUploadComponent, isStandalone: true, selector: "val-avatar-upload", inputs: { props: { classPropertyName: "props", publicName: "props", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { uploaded: "uploaded", error: "error", uploadStart: "uploadStart" }, viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }], ngImport: i0, template: `
+    <div class="avatar-upload" [style.--avatar-size.px]="config().size" [class.avatar-upload--loading]="loading()">
+      <div class="avatar-container">
+        <!-- Avatar Image or Initials -->
+        @if (displayUrl()) {
+          <img class="avatar-image" [src]="displayUrl()" alt="Avatar" (error)="onImageError()" />
+        } @else {
+          <div class="avatar-initials" [style.background-color]="config().backgroundColor">
+            {{ config().initials || '?' }}
+          </div>
+        }
+
+        <!-- Edit Button -->
+        @if (config().editable && !loading()) {
+          <button class="edit-button" type="button" (click)="openFilePicker()" [attr.aria-label]="editButtonLabel()">
+            <ion-icon name="camera-outline"></ion-icon>
+          </button>
+        }
+
+        <!-- Loading Overlay -->
+        @if (loading()) {
+          <div class="loading-overlay">
+            <ion-spinner name="crescent"></ion-spinner>
+          </div>
+        }
+      </div>
+
+      <!-- Hidden File Input -->
+      <input #fileInput type="file" accept="image/jpeg,image/png,image/webp" (change)="onFileSelected($event)" hidden />
+
+      <!-- Crop Modal -->
+      <ion-modal
+        [isOpen]="showCropModal()"
+        (didDismiss)="onCropCancel()"
+        [breakpoints]="[0, 1]"
+        [initialBreakpoint]="1"
+      >
+        <ng-template>
+          @if (selectedFile()) {
+            <val-image-crop
+              [image]="selectedFile()!"
+              [aspectRatio]="1"
+              [roundCropper]="true"
+              [i18nNamespace]="config().i18nNamespace"
+              (cropComplete)="onCropComplete($event)"
+              (cancel)="onCropCancel()"
+              (loadFailed)="onCropLoadFailed()"
+            />
+          }
+        </ng-template>
+      </ion-modal>
+    </div>
+  `, isInline: true, styles: [".avatar-upload{--avatar-size: 100px;--edit-button-size: 32px;--edit-button-offset: 4px;display:inline-block}.avatar-container{position:relative;width:var(--avatar-size);height:var(--avatar-size);border-radius:50%;overflow:visible}.avatar-image{width:100%;height:100%;border-radius:50%;object-fit:cover;background-color:var(--ion-color-light)}.avatar-initials{width:100%;height:100%;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:calc(var(--avatar-size) * .4);font-weight:600;color:#fff;text-transform:uppercase;-webkit-user-select:none;user-select:none}.edit-button{position:absolute;bottom:var(--edit-button-offset);right:var(--edit-button-offset);width:var(--edit-button-size);height:var(--edit-button-size);border-radius:50%;border:2px solid white;background:var(--ion-color-primary);color:#fff;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:transform .2s ease,background-color .2s ease;box-shadow:0 2px 8px #00000026}.edit-button ion-icon{font-size:calc(var(--edit-button-size) * .5)}.edit-button:hover{transform:scale(1.1);background:var(--ion-color-primary-shade)}.edit-button:active{transform:scale(.95)}.edit-button:focus-visible{outline:2px solid var(--ion-color-primary);outline-offset:2px}.loading-overlay{position:absolute;top:0;left:0;width:100%;height:100%;border-radius:50%;background:#00000080;display:flex;align-items:center;justify-content:center}.loading-overlay ion-spinner{--color: white;width:calc(var(--avatar-size) * .4);height:calc(var(--avatar-size) * .4)}.avatar-upload--loading .edit-button{display:none}.avatar-upload--loading .avatar-image,.avatar-upload--loading .avatar-initials{filter:brightness(.7)}@container (max-width: 60px){.edit-button{--edit-button-size: 24px;--edit-button-offset: 0}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonModal, selector: "ion-modal" }, { kind: "component", type: ImageCropComponent, selector: "val-image-crop", inputs: ["image", "aspectRatio", "roundCropper", "resizeToWidth", "i18nNamespace"], outputs: ["cropComplete", "cancel", "loadFailed"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AvatarUploadComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-avatar-upload', standalone: true, imports: [CommonModule, IonIcon, IonSpinner, IonModal, ImageCropComponent], template: `
+    <div class="avatar-upload" [style.--avatar-size.px]="config().size" [class.avatar-upload--loading]="loading()">
+      <div class="avatar-container">
+        <!-- Avatar Image or Initials -->
+        @if (displayUrl()) {
+          <img class="avatar-image" [src]="displayUrl()" alt="Avatar" (error)="onImageError()" />
+        } @else {
+          <div class="avatar-initials" [style.background-color]="config().backgroundColor">
+            {{ config().initials || '?' }}
+          </div>
+        }
+
+        <!-- Edit Button -->
+        @if (config().editable && !loading()) {
+          <button class="edit-button" type="button" (click)="openFilePicker()" [attr.aria-label]="editButtonLabel()">
+            <ion-icon name="camera-outline"></ion-icon>
+          </button>
+        }
+
+        <!-- Loading Overlay -->
+        @if (loading()) {
+          <div class="loading-overlay">
+            <ion-spinner name="crescent"></ion-spinner>
+          </div>
+        }
+      </div>
+
+      <!-- Hidden File Input -->
+      <input #fileInput type="file" accept="image/jpeg,image/png,image/webp" (change)="onFileSelected($event)" hidden />
+
+      <!-- Crop Modal -->
+      <ion-modal
+        [isOpen]="showCropModal()"
+        (didDismiss)="onCropCancel()"
+        [breakpoints]="[0, 1]"
+        [initialBreakpoint]="1"
+      >
+        <ng-template>
+          @if (selectedFile()) {
+            <val-image-crop
+              [image]="selectedFile()!"
+              [aspectRatio]="1"
+              [roundCropper]="true"
+              [i18nNamespace]="config().i18nNamespace"
+              (cropComplete)="onCropComplete($event)"
+              (cancel)="onCropCancel()"
+              (loadFailed)="onCropLoadFailed()"
+            />
+          }
+        </ng-template>
+      </ion-modal>
+    </div>
+  `, styles: [".avatar-upload{--avatar-size: 100px;--edit-button-size: 32px;--edit-button-offset: 4px;display:inline-block}.avatar-container{position:relative;width:var(--avatar-size);height:var(--avatar-size);border-radius:50%;overflow:visible}.avatar-image{width:100%;height:100%;border-radius:50%;object-fit:cover;background-color:var(--ion-color-light)}.avatar-initials{width:100%;height:100%;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:calc(var(--avatar-size) * .4);font-weight:600;color:#fff;text-transform:uppercase;-webkit-user-select:none;user-select:none}.edit-button{position:absolute;bottom:var(--edit-button-offset);right:var(--edit-button-offset);width:var(--edit-button-size);height:var(--edit-button-size);border-radius:50%;border:2px solid white;background:var(--ion-color-primary);color:#fff;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:transform .2s ease,background-color .2s ease;box-shadow:0 2px 8px #00000026}.edit-button ion-icon{font-size:calc(var(--edit-button-size) * .5)}.edit-button:hover{transform:scale(1.1);background:var(--ion-color-primary-shade)}.edit-button:active{transform:scale(.95)}.edit-button:focus-visible{outline:2px solid var(--ion-color-primary);outline-offset:2px}.loading-overlay{position:absolute;top:0;left:0;width:100%;height:100%;border-radius:50%;background:#00000080;display:flex;align-items:center;justify-content:center}.loading-overlay ion-spinner{--color: white;width:calc(var(--avatar-size) * .4);height:calc(var(--avatar-size) * .4)}.avatar-upload--loading .edit-button{display:none}.avatar-upload--loading .avatar-image,.avatar-upload--loading .avatar-initials{filter:brightness(.7)}@container (max-width: 60px){.edit-button{--edit-button-size: 24px;--edit-button-offset: 0}}\n"] }]
+        }], propDecorators: { fileInput: [{
+                type: ViewChild,
+                args: ['fileInput']
+            }], uploaded: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], uploadStart: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avatar-upload.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/avatar-upload/avatar-upload.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, computed, ElementRef, EventEmitter, inject, input, Output, signal, ViewChild } from '@angular/core';\nimport { IonIcon, IonModal, IonSpinner } from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { cameraOutline } from 'ionicons/icons';\nimport { firstValueFrom } from 'rxjs';\nimport { AuthService } from '../../../services/auth';\nimport { StorageService } from '../../../services/firebase';\nimport { I18nService } from '../../../services/i18n';\nimport { ImageService } from '../../../services/image';\nimport { ImageCropComponent } from '../../molecules/image-crop';\nimport { AVATAR_UPLOAD_DEFAULTS, AvatarUploadError, AvatarUploadMetadata, AvatarUploadResult } from './types';\n\naddIcons({ cameraOutline });\n\n/**\n * AvatarUploadComponent\n *\n * A complete avatar upload solution with:\n * - Image selection from device\n * - Crop modal with round preview\n * - Automatic compression and thumbnail generation\n * - Upload to Firebase Storage\n * - Backend sync via AuthService\n *\n * @example Basic usage\n * ```html\n * <val-avatar-upload\n *   [props]=\"{\n *     currentUrl: user()?.avatarUrl,\n *     initials: 'JD',\n *     size: 120\n *   }\"\n *   (uploaded)=\"onAvatarUploaded($event)\"\n *   (error)=\"onError($event)\"\n * />\n * ```\n */\n@Component({\n  selector: 'val-avatar-upload',\n  standalone: true,\n  imports: [CommonModule, IonIcon, IonSpinner, IonModal, ImageCropComponent],\n  template: `\n    <div class=\"avatar-upload\" [style.--avatar-size.px]=\"config().size\" [class.avatar-upload--loading]=\"loading()\">\n      <div class=\"avatar-container\">\n        <!-- Avatar Image or Initials -->\n        @if (displayUrl()) {\n          <img class=\"avatar-image\" [src]=\"displayUrl()\" alt=\"Avatar\" (error)=\"onImageError()\" />\n        } @else {\n          <div class=\"avatar-initials\" [style.background-color]=\"config().backgroundColor\">\n            {{ config().initials || '?' }}\n          </div>\n        }\n\n        <!-- Edit Button -->\n        @if (config().editable && !loading()) {\n          <button class=\"edit-button\" type=\"button\" (click)=\"openFilePicker()\" [attr.aria-label]=\"editButtonLabel()\">\n            <ion-icon name=\"camera-outline\"></ion-icon>\n          </button>\n        }\n\n        <!-- Loading Overlay -->\n        @if (loading()) {\n          <div class=\"loading-overlay\">\n            <ion-spinner name=\"crescent\"></ion-spinner>\n          </div>\n        }\n      </div>\n\n      <!-- Hidden File Input -->\n      <input #fileInput type=\"file\" accept=\"image/jpeg,image/png,image/webp\" (change)=\"onFileSelected($event)\" hidden />\n\n      <!-- Crop Modal -->\n      <ion-modal\n        [isOpen]=\"showCropModal()\"\n        (didDismiss)=\"onCropCancel()\"\n        [breakpoints]=\"[0, 1]\"\n        [initialBreakpoint]=\"1\"\n      >\n        <ng-template>\n          @if (selectedFile()) {\n            <val-image-crop\n              [image]=\"selectedFile()!\"\n              [aspectRatio]=\"1\"\n              [roundCropper]=\"true\"\n              [i18nNamespace]=\"config().i18nNamespace\"\n              (cropComplete)=\"onCropComplete($event)\"\n              (cancel)=\"onCropCancel()\"\n              (loadFailed)=\"onCropLoadFailed()\"\n            />\n          }\n        </ng-template>\n      </ion-modal>\n    </div>\n  `,\n  styleUrls: ['./avatar-upload.component.scss'],\n})\nexport class AvatarUploadComponent {\n  private imageService = inject(ImageService);\n  private storageService = inject(StorageService);\n  private authService = inject(AuthService);\n  private i18n = inject(I18nService);\n\n  @ViewChild('fileInput') fileInput!: ElementRef<HTMLInputElement>;\n\n  /** Component configuration */\n  readonly props = input<AvatarUploadMetadata>({});\n\n  /** Emitted after successful upload and backend sync */\n  @Output() uploaded = new EventEmitter<AvatarUploadResult>();\n\n  /** Emitted on any error during the process */\n  @Output() error = new EventEmitter<AvatarUploadError>();\n\n  /** Emitted when upload starts */\n  @Output() uploadStart = new EventEmitter<void>();\n\n  // Internal state\n  protected loading = signal(false);\n  protected showCropModal = signal(false);\n  protected selectedFile = signal<File | null>(null);\n  protected previewUrl = signal<string | null>(null);\n  protected imageLoadError = signal(false);\n\n  /** Merged config with defaults */\n  protected config = computed(() => ({\n    ...AVATAR_UPLOAD_DEFAULTS,\n    ...this.props(),\n  }));\n\n  /** URL to display (preview takes priority over current) */\n  protected displayUrl = computed(() => {\n    if (this.imageLoadError()) return null;\n    return this.previewUrl() || this.config().currentUrl || null;\n  });\n\n  /** Aria label for edit button */\n  protected editButtonLabel = computed(() => {\n    this.i18n.lang();\n    return this.i18n.t('changePhoto', this.config().i18nNamespace) || 'Cambiar foto';\n  });\n\n  /** Open file picker dialog */\n  openFilePicker(): void {\n    this.fileInput.nativeElement.click();\n  }\n\n  /** Handle file selection */\n  onFileSelected(event: Event): void {\n    const input = event.target as HTMLInputElement;\n    const file = input.files?.[0];\n\n    if (!file) return;\n\n    // Reset input for same file selection\n    input.value = '';\n\n    // Validate file\n    const validation = this.imageService.validate(file, {\n      maxSize: this.config().maxFileSize,\n      allowedTypes: ['image/jpeg', 'image/png', 'image/webp'],\n    });\n\n    if (!validation.valid) {\n      this.emitError(validation.error as AvatarUploadError['type'], validation.message!);\n      return;\n    }\n\n    // Open crop modal\n    this.selectedFile.set(file);\n    this.showCropModal.set(true);\n  }\n\n  /** Handle crop completion */\n  async onCropComplete(croppedBlob: Blob): Promise<void> {\n    this.showCropModal.set(false);\n    this.selectedFile.set(null);\n\n    await this.processAndUpload(croppedBlob);\n  }\n\n  /** Handle crop cancel */\n  onCropCancel(): void {\n    this.showCropModal.set(false);\n    this.selectedFile.set(null);\n  }\n\n  /** Handle crop load failure */\n  onCropLoadFailed(): void {\n    this.showCropModal.set(false);\n    this.selectedFile.set(null);\n    this.emitError(\n      'invalidType',\n      this.i18n.t('loadFailed', this.config().i18nNamespace) || 'No se pudo cargar la imagen'\n    );\n  }\n\n  /** Handle image load error */\n  onImageError(): void {\n    this.imageLoadError.set(true);\n  }\n\n  /** Timeout for upload operations (30 seconds) */\n  private static readonly UPLOAD_TIMEOUT_MS = 30000;\n\n  /** Process cropped image and upload */\n  private async processAndUpload(croppedBlob: Blob): Promise<void> {\n    this.loading.set(true);\n    this.uploadStart.emit();\n\n    // Timeout promise to prevent infinite loading\n    const uploadTimeout = new Promise<never>((_, reject) =>\n      setTimeout(() => reject(new Error('Upload timeout')), AvatarUploadComponent.UPLOAD_TIMEOUT_MS)\n    );\n\n    try {\n      const config = this.config();\n\n      // 1. Compress image\n      const compressed = await this.imageService.compress(croppedBlob, {\n        maxWidth: config.maxWidth,\n        maxHeight: config.maxWidth,\n        quality: config.compressQuality,\n      });\n\n      // 2. Generate thumbnail\n      const thumbnail = await this.imageService.thumbnail(compressed.blob, config.thumbnailSize);\n\n      // 3. Set preview immediately\n      this.previewUrl.set(compressed.dataUrl);\n      this.imageLoadError.set(false);\n\n      // 4. Get user ID for storage path\n      const userId = this.authService.user()?.userId;\n      if (!userId) {\n        throw new Error('User not authenticated');\n      }\n\n      // 5. Upload to Firebase Storage with predictable paths\n      // Path: users/{userId}/avatar.jpg - allows any app to construct URL with just userId\n      // skipPrefix: true - bypasses appId prefix for shared/cross-app paths\n      const avatarPath = `users/${userId}/avatar.jpg`;\n      const thumbPath = `users/${userId}/thumb.jpg`;\n      const uploadMetadata = { skipPrefix: true, contentType: 'image/jpeg' };\n\n      // Race against timeout to prevent infinite loading\n      const [avatarResult, thumbResult] = await Promise.race([\n        Promise.all([\n          this.storageService.uploadAndGetUrl(avatarPath, compressed.blob, uploadMetadata),\n          this.storageService.uploadAndGetUrl(thumbPath, thumbnail.blob, uploadMetadata),\n        ]),\n        uploadTimeout,\n      ]);\n\n      // 6. Update backend with URLs\n      await firstValueFrom(\n        this.authService.updateAvatar({\n          avatarUrl: avatarResult.downloadUrl,\n          avatarThumbnail: thumbResult.downloadUrl,\n        })\n      );\n\n      // 7. Update preview with cache-busting to force refresh\n      const cacheBuster = `?t=${Date.now()}`;\n      this.previewUrl.set(avatarResult.downloadUrl + cacheBuster);\n\n      // 8. Emit success\n      const result: AvatarUploadResult = {\n        avatarUrl: avatarResult.downloadUrl,\n        thumbnailUrl: thumbResult.downloadUrl,\n      };\n\n      this.uploaded.emit(result);\n    } catch (err) {\n      console.error('[AvatarUpload] processAndUpload failed:', err);\n      // Revert preview on error\n      this.previewUrl.set(null);\n\n      // Determine error message based on error type\n      let message: string;\n      if (err instanceof Error) {\n        if (err.message === 'Upload timeout') {\n          message =\n            this.i18n.t('uploadTimeout', this.config().i18nNamespace) ||\n            'La subida tardó demasiado. Verifica tu conexión.';\n        } else {\n          message = err.message;\n        }\n      } else {\n        message = this.i18n.t('uploadError', this.config().i18nNamespace) || 'Error al subir la imagen';\n      }\n\n      this.emitError('uploadFailed', message, err);\n    } finally {\n      this.loading.set(false);\n    }\n  }\n\n  /** Emit error event */\n  private emitError(type: AvatarUploadError['type'], message: string, originalError?: unknown): void {\n    this.error.emit({ type, message, originalError });\n  }\n}\n"]}

package/esm2022/lib/components/organisms/avatar-upload/types.mjs

@@ -0,0 +1,15 @@
+/**
+ * Default values
+ */
+export const AVATAR_UPLOAD_DEFAULTS = {
+    size: 100,
+    editable: true,
+    storagePath: 'avatars',
+    i18nNamespace: 'AvatarUpload',
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+    compressQuality: 0.8,
+    maxWidth: 800,
+    thumbnailSize: 150,
+    backgroundColor: '#6366f1', // Indigo
+};
+//# sourceMappingURL=data:application/json;base64,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