valtech-components 2.0.407 → 2.0.410

package/esm2022/lib/components/templates/page-wrapper/page-wrapper.component.mjs

@@ -0,0 +1,195 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, inject, Input, Output } from '@angular/core';
+import { NavigationEnd, Router, RouterOutlet } from '@angular/router';
+import { IonContent } from '@ionic/angular/standalone';
+import { filter } from 'rxjs';
+import { HeaderComponent } from '../../organisms/header/header.component';
+import { CompanyFooterComponent } from '../../organisms/company-footer/company-footer.component';
+import { ThemeService } from '../../../services/theme.service';
+import { NavigationService } from '../../../services/navigation.service';
+import { resolveColor } from '../../../shared/utils/styles';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * val-page-wrapper
+ *
+ * A complete page wrapper template with header, router outlet, footer,
+ * and automatic scroll-to-top on navigation.
+ *
+ * @example
+ * <val-page-wrapper
+ *   [props]="{
+ *     homeRoute: '/',
+ *     scrollToTopOnNavigate: true,
+ *     footer: {
+ *       links: { ... },
+ *       rights: { companyName: 'Acme' }
+ *     }
+ *   }"
+ * ></val-page-wrapper>
+ *
+ * @input props - Page wrapper configuration
+ * @output onHeaderClick - Emits when a header action is clicked
+ */
+export class PageWrapperComponent {
+    constructor() {
+        this.theme = inject(ThemeService);
+        this.nav = inject(NavigationService);
+        this.router = inject(Router);
+        /**
+         * Page wrapper configuration.
+         */
+        this.props = {
+            scrollToTopOnNavigate: true,
+        };
+        /**
+         * Emits when a header action is clicked.
+         */
+        this.onHeaderClick = new EventEmitter();
+    }
+    /**
+     * Default header configuration.
+     */
+    get headerProps() {
+        return (this.props.header || {
+            bordered: true,
+            translucent: true,
+            toolbar: {
+                withBack: false,
+                withActions: true,
+                textColor: 'dark',
+                withMenu: true,
+                title: '',
+                actions: [
+                    {
+                        token: 'header-logo',
+                        description: '',
+                        position: 'left',
+                        type: 'IMAGE',
+                        image: {
+                            width: 10,
+                            src: '--main-logo',
+                            alt: 'header logo',
+                            mode: 'box',
+                            shaded: false,
+                            bordered: false,
+                            size: 'small',
+                            limited: false,
+                            flex: true,
+                        },
+                    },
+                ],
+            },
+        });
+    }
+    ngOnInit() {
+        if (this.props.scrollToTopOnNavigate !== false) {
+            this.routerSubscription = this.router.events
+                .pipe(filter((event) => event instanceof NavigationEnd))
+                .subscribe(() => {
+                this.scrollToTop();
+            });
+        }
+    }
+    ngOnDestroy() {
+        if (this.routerSubscription) {
+            this.routerSubscription.unsubscribe();
+        }
+    }
+    ionViewWillLeave() {
+        // Optional: can add logic on view leave
+    }
+    ionViewWillEnter() {
+        this.scrollToTop();
+    }
+    /**
+     * Gets the background color based on theme.
+     */
+    getBackground() {
+        if (this.theme.IsDark) {
+            return 'var(--ion-background-color)';
+        }
+        const bg = this.props.background;
+        if (!bg) {
+            return 'var(--ion-background-color)';
+        }
+        return resolveColor(bg);
+    }
+    /**
+     * Scrolls the content to the top.
+     */
+    scrollToTop() {
+        const contentId = this.props.contentId || 'page-wrapper';
+        const ionContent = document.querySelector(`#${contentId}`);
+        if (ionContent && ionContent.scrollToTop) {
+            ionContent.scrollToTop(300);
+        }
+        else {
+            window.scrollTo({ top: 0, behavior: 'smooth' });
+        }
+    }
+    /**
+     * Handles header action clicks.
+     */
+    onHeaderClickHandler(token) {
+        this.onHeaderClick.emit(token);
+        if (token === 'header-logo' && this.props.homeRoute) {
+            this.nav.navigateByUrl(this.props.homeRoute);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PageWrapperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PageWrapperComponent, isStandalone: true, selector: "val-page-wrapper", inputs: { props: "props" }, outputs: { onHeaderClick: "onHeaderClick" }, ngImport: i0, template: `
+    <div class="ion-page">
+      <val-header
+        [props]="headerProps"
+        (onClick)="onHeaderClickHandler($event)"
+      />
+      <ion-content
+        [id]="props.contentId || 'page-wrapper'"
+        class="ion-padding"
+        [fullscreen]="true"
+        [ngStyle]="{
+          '--background': getBackground()
+        }"
+      >
+        <main>
+          <router-outlet></router-outlet>
+        </main>
+        @if (props.footer) {
+          <val-company-footer [props]="props.footer" />
+        }
+      </ion-content>
+    </div>
+  `, isInline: true, styles: ["main{min-height:60vh}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: HeaderComponent, selector: "val-header", inputs: ["props"], outputs: ["onClick"] }, { kind: "component", type: CompanyFooterComponent, selector: "val-company-footer", inputs: ["props"] }, { kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PageWrapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-page-wrapper', standalone: true, imports: [CommonModule, HeaderComponent, CompanyFooterComponent, RouterOutlet, IonContent], template: `
+    <div class="ion-page">
+      <val-header
+        [props]="headerProps"
+        (onClick)="onHeaderClickHandler($event)"
+      />
+      <ion-content
+        [id]="props.contentId || 'page-wrapper'"
+        class="ion-padding"
+        [fullscreen]="true"
+        [ngStyle]="{
+          '--background': getBackground()
+        }"
+      >
+        <main>
+          <router-outlet></router-outlet>
+        </main>
+        @if (props.footer) {
+          <val-company-footer [props]="props.footer" />
+        }
+      </ion-content>
+    </div>
+  `, styles: ["main{min-height:60vh}\n"] }]
+        }], propDecorators: { props: [{
+                type: Input
+            }], onHeaderClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page-wrapper.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/templates/page-wrapper/page-wrapper.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, inject, Input, OnDestroy, OnInit, Output } from '@angular/core';\nimport { NavigationEnd, Router, RouterOutlet } from '@angular/router';\nimport { IonContent, ViewWillEnter, ViewWillLeave } from '@ionic/angular/standalone';\nimport { filter, Subscription } from 'rxjs';\nimport { HeaderComponent } from '../../organisms/header/header.component';\nimport { CompanyFooterComponent } from '../../organisms/company-footer/company-footer.component';\nimport { ThemeService } from '../../../services/theme.service';\nimport { NavigationService } from '../../../services/navigation.service';\nimport { PageWrapperMetadata } from './types';\nimport { resolveColor } from '../../../shared/utils/styles';\n\n/**\n * val-page-wrapper\n *\n * A complete page wrapper template with header, router outlet, footer,\n * and automatic scroll-to-top on navigation.\n *\n * @example\n * <val-page-wrapper\n *   [props]=\"{\n *     homeRoute: '/',\n *     scrollToTopOnNavigate: true,\n *     footer: {\n *       links: { ... },\n *       rights: { companyName: 'Acme' }\n *     }\n *   }\"\n * ></val-page-wrapper>\n *\n * @input props - Page wrapper configuration\n * @output onHeaderClick - Emits when a header action is clicked\n */\n@Component({\n  selector: 'val-page-wrapper',\n  standalone: true,\n  imports: [CommonModule, HeaderComponent, CompanyFooterComponent, RouterOutlet, IonContent],\n  template: `\n    <div class=\"ion-page\">\n      <val-header\n        [props]=\"headerProps\"\n        (onClick)=\"onHeaderClickHandler($event)\"\n      />\n      <ion-content\n        [id]=\"props.contentId || 'page-wrapper'\"\n        class=\"ion-padding\"\n        [fullscreen]=\"true\"\n        [ngStyle]=\"{\n          '--background': getBackground()\n        }\"\n      >\n        <main>\n          <router-outlet></router-outlet>\n        </main>\n        @if (props.footer) {\n          <val-company-footer [props]=\"props.footer\" />\n        }\n      </ion-content>\n    </div>\n  `,\n  styles: `\n    main {\n      min-height: 60vh;\n    }\n  `,\n})\nexport class PageWrapperComponent implements ViewWillEnter, ViewWillLeave, OnInit, OnDestroy {\n  private theme = inject(ThemeService);\n  private nav = inject(NavigationService);\n  private router = inject(Router);\n  private routerSubscription?: Subscription;\n\n  /**\n   * Page wrapper configuration.\n   */\n  @Input() props: PageWrapperMetadata = {\n    scrollToTopOnNavigate: true,\n  };\n\n  /**\n   * Emits when a header action is clicked.\n   */\n  @Output() onHeaderClick = new EventEmitter<string>();\n\n  /**\n   * Default header configuration.\n   */\n  get headerProps() {\n    return (\n      this.props.header || {\n        bordered: true,\n        translucent: true,\n        toolbar: {\n          withBack: false,\n          withActions: true,\n          textColor: 'dark',\n          withMenu: true,\n          title: '',\n          actions: [\n            {\n              token: 'header-logo',\n              description: '',\n              position: 'left',\n              type: 'IMAGE',\n              image: {\n                width: 10,\n                src: '--main-logo',\n                alt: 'header logo',\n                mode: 'box',\n                shaded: false,\n                bordered: false,\n                size: 'small',\n                limited: false,\n                flex: true,\n              },\n            },\n          ],\n        },\n      }\n    );\n  }\n\n  ngOnInit(): void {\n    if (this.props.scrollToTopOnNavigate !== false) {\n      this.routerSubscription = this.router.events\n        .pipe(filter((event) => event instanceof NavigationEnd))\n        .subscribe(() => {\n          this.scrollToTop();\n        });\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.routerSubscription) {\n      this.routerSubscription.unsubscribe();\n    }\n  }\n\n  ionViewWillLeave(): void {\n    // Optional: can add logic on view leave\n  }\n\n  ionViewWillEnter(): void {\n    this.scrollToTop();\n  }\n\n  /**\n   * Gets the background color based on theme.\n   */\n  getBackground(): string {\n    if (this.theme.IsDark) {\n      return 'var(--ion-background-color)';\n    }\n\n    const bg = this.props.background;\n    if (!bg) {\n      return 'var(--ion-background-color)';\n    }\n\n    return resolveColor(bg);\n  }\n\n  /**\n   * Scrolls the content to the top.\n   */\n  private scrollToTop(): void {\n    const contentId = this.props.contentId || 'page-wrapper';\n    const ionContent = document.querySelector(`#${contentId}`) as any;\n    if (ionContent && ionContent.scrollToTop) {\n      ionContent.scrollToTop(300);\n    } else {\n      window.scrollTo({ top: 0, behavior: 'smooth' });\n    }\n  }\n\n  /**\n   * Handles header action clicks.\n   */\n  onHeaderClickHandler(token: string): void {\n    this.onHeaderClick.emit(token);\n\n    if (token === 'header-logo' && this.props.homeRoute) {\n      this.nav.navigateByUrl(this.props.homeRoute);\n    }\n  }\n}\n"]}

package/esm2022/lib/components/templates/page-wrapper/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvdGVtcGxhdGVzL3BhZ2Utd3JhcHBlci90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSGVhZGVyTWV0YWRhdGEgfSBmcm9tICcuLi8uLi9vcmdhbmlzbXMvaGVhZGVyL3R5cGVzJztcbmltcG9ydCB7IENvbXBhbnlGb290ZXJNZXRhZGF0YSB9IGZyb20gJy4uLy4uL29yZ2FuaXNtcy9jb21wYW55LWZvb3Rlci90eXBlcyc7XG5cbi8qKlxuICogQ29uZmlndXJhdGlvbiBmb3IgdGhlIHBhZ2Ugd3JhcHBlciBjb21wb25lbnQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGFnZVdyYXBwZXJNZXRhZGF0YSB7XG4gIC8qKiBIZWFkZXIgY29uZmlndXJhdGlvbiAqL1xuICBoZWFkZXI/OiBIZWFkZXJNZXRhZGF0YTtcbiAgLyoqIEZvb3RlciBjb25maWd1cmF0aW9uICovXG4gIGZvb3Rlcj86IENvbXBhbnlGb290ZXJNZXRhZGF0YTtcbiAgLyoqIEJhY2tncm91bmQgY29sb3Igb3IgQ1NTIHZhcmlhYmxlICovXG4gIGJhY2tncm91bmQ/OiBzdHJpbmc7XG4gIC8qKiBSb3V0ZSB0byBuYXZpZ2F0ZSB0byB3aGVuIGhlYWRlciBsb2dvIGlzIGNsaWNrZWQgKi9cbiAgaG9tZVJvdXRlPzogc3RyaW5nO1xuICAvKiogQ29udGVudCBJRCBmb3Igc2Nyb2xsIGhhbmRsaW5nICovXG4gIGNvbnRlbnRJZD86IHN0cmluZztcbiAgLyoqIEVuYWJsZSBzY3JvbGwtdG8tdG9wIG9uIHJvdXRlIGNoYW5nZSAqL1xuICBzY3JvbGxUb1RvcE9uTmF2aWdhdGU/OiBib29sZWFuO1xufVxuIl19

package/esm2022/lib/components/types.mjs

@@ -55,4 +55,4 @@ export var ToolbarActionType;
     ToolbarActionType["IMAGE"] = "IMAGE";
     ToolbarActionType["BUTTON"] = "BUTTON";
 })(ToolbarActionType || (ToolbarActionType = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/components/types.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,QAAQ,GAAmB,UAAU,CAAC;AAC5C,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,KAAK,GAAmB,OAAO,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAN,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iEAAe,CAAA;IACf,mEAAgB,CAAA;IAChB,iEAAe,CAAA;IACf,+DAAc,CAAA;IACd,uEAAkB,CAAA;AACpB,CAAC,EANW,UAAU,KAAV,UAAU,QAMrB;AAcD;;GAEG;AACH,MAAM,CAAN,IAAY,SAuBX;AAvBD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;IACR,2CAAK,CAAA;IACL,iDAAQ,CAAA;IACR,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6DAAc,CAAA;IACd,iDAAQ,CAAA;IACR,yCAAI,CAAA;IACJ,qDAAU,CAAA;IACV,0CAAI,CAAA;IACJ,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,8CAAM,CAAA;IACN,4DAAa,CAAA;IACb,0DAAY,CAAA;IACZ,wEAAmB,CAAA;IACnB,0CAAI,CAAA;IACJ,8CAAM,CAAA;IACN,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,kDAAQ,CAAA;AACV,CAAC,EAvBW,SAAS,KAAT,SAAS,QAuBpB;AAyGD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["import { FormControl, ValidatorFn } from '@angular/forms';\nimport { Color } from '@ionic/core';\nimport { ImageMetadata } from './atoms/image/types';\n\n/**\n * Possible states for an interactive component.\n */\nexport type ComponentState = 'ENABLED' | 'DISABLED' | 'WORKING' | 'ERROR';\nconst ENABLED: ComponentState = 'ENABLED';\nconst DISABLED: ComponentState = 'DISABLED';\nconst WORKING: ComponentState = 'WORKING';\nconst ERROR: ComponentState = 'ERROR';\n\n/**\n * Object containing all possible component states.\n */\nexport const ComponentStates = { ENABLED, DISABLED, WORKING, ERROR };\n\n/**\n * Types of actions that a button or link can perform.\n */\nexport enum ActionType {\n  BROWSER_NEW_TAB, // Open in a new browser tab\n  BROWSER_DOWNLOAD, // Download via browser\n  NATIVE_DOWNLOAD, // Download using native capabilities\n  APP_NAVIGATION, // Internal app navigation\n  BROWSER_NAVIGATION, // Navigation in the browser\n}\n\n/**\n * Represents an executable action for a button or link.\n */\nexport type Action = {\n  /** Action description */\n  description: string;\n  /** Action type */\n  type: ActionType;\n  /** Action source or destination */\n  source: string;\n};\n\n/**\n * Supported input types for forms.\n */\nexport enum InputType {\n  TEXT,\n  TEXTAREA,\n  EMAIL,\n  PASSWORD,\n  COMMENT,\n  NUMBER,\n  NUMBER_FROM_TO,\n  PIN_CODE,\n  DATE,\n  DATE_RANGE,\n  HOUR,\n  CHECK,\n  RADIO,\n  SELECT,\n  SEARCH_SELECT,\n  MULTI_SELECT,\n  MULTI_SELECT_SIMPLE,\n  FILE,\n  TOGGLE,\n  RANGE,\n  PHONE,\n  CURRENCY,\n}\n\n/**\n * Option for select, radio, etc. inputs.\n */\nexport type InputOption = {\n  /** Unique option identifier */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Whether the option is selected by default */\n  selected?: boolean;\n  /** Display order */\n  order: number;\n};\n\n/**\n * Metadata for a form field.\n */\nexport type InputMetadata = {\n  /** Associated form control */\n  control: FormControl;\n  /** From control (only for NUMBER_FROM_TO type) */\n  fromControl?: FormControl;\n  /** To control (only for NUMBER_FROM_TO type) */\n  toControl?: FormControl;\n  /** Unique token for the input */\n  token: string;\n  /** Display label */\n  label: string;\n  /** Field name */\n  name: string;\n  /** Help text */\n  hint: string;\n  /** Input placeholder */\n  placeholder: string;\n  /** Input type */\n  type: InputType;\n  /** Display order */\n  order: number;\n  /** Associated validators */\n  validators: ValidatorFn[];\n  /** Options (for select, radio, etc.) */\n  options?: InputOption[];\n  /** Allowed range (for number, date, etc.) */\n  range?: {\n    min: number;\n    max: number;\n  };\n  /** Custom error messages */\n  errors: {\n    [key: string]: string;\n  };\n  /** Initial value for the field */\n  value?: string;\n  /** Default value configuration - string for custom defaults, true for auto defaults */\n  withDefault?: string | boolean;\n  /** Field state */\n  state: ComponentState;\n  /** Label for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromLabel?: string;\n  /** Label for \"to\" field (only for NUMBER_FROM_TO type) */\n  toLabel?: string;\n  /** Placeholder for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromPlaceholder?: string;\n  /** Placeholder for \"to\" field (only for NUMBER_FROM_TO type) */\n  toPlaceholder?: string;\n};\n\n/**\n * A section in a form, grouping multiple fields.\n */\nexport type FormSection = {\n  /** Section name */\n  name: string;\n  /** Display order */\n  order: number;\n  /** Fields included in the section */\n  fields: InputMetadata[];\n};\n\n/**\n * Data sent when submitting a form.\n */\nexport type FormSubmit = {\n  /** List of fields and their values */\n  fields: { key: string; value: string }[];\n  /** Optional token for the operation */\n  token?: string;\n};\n\n/**\n * Metadata for a complete form.\n */\nexport type FormMetadata = {\n  /** Form name */\n  name: string;\n  /** Form sections */\n  sections: FormSection[];\n  /** Action buttons configuration */\n  actions: ButtonMetadata;\n  /** Global form state */\n  state: ComponentState;\n};\n\n/**\n * Possible action types for a toolbar.\n */\nexport enum ToolbarActionType {\n  AVATAR = 'AVATAR',\n  ICON = 'ICON',\n  IMAGE = 'IMAGE',\n  BUTTON = 'BUTTON',\n}\n\n/**\n * Toolbar action definition.\n */\nexport type ToolbarAction = {\n  /** Action type */\n  type: 'AVATAR' | 'ICON' | 'IMAGE' | 'BUTTON';\n  /** Optional token identifier */\n  token?: string;\n  /** Toolbar position */\n  position: 'left' | 'right' | 'center';\n  /** Optional description */\n  description?: string;\n  /** Associated image (if any) */\n  image?: ImageMetadata;\n};\n\n/**\n * Metadata for an icon.\n */\nexport interface IconMetada {\n  /** Icon name */\n  name: string;\n  /** Icon slot position */\n  slot: 'start' | 'end';\n}\n\n/**\n * Button configuration object.\n * Supports both static and reactive content.\n * @type {ButtonMetadata}\n * @property text - Static button label (takes precedence over textConfig).\n * @property textConfig - Reactive content configuration for button text.\n * @property color - The button color (Ionic color string).\n * @property icon - Icon to display (optional).\n * @property state - Button state (enabled, disabled, working, etc.).\n * @property expand, fill, size, shape, href, target, download, handler, etc. - See ButtonMetadata for all options.\n */\nexport interface ButtonMetadata {\n  /** Associated action type */\n  actionType?: ActionType;\n  /** Button expansion */\n  expand?: 'full' | 'block';\n  /** Associated link */\n  link?: string;\n  /** Associated href link */\n  href?: string;\n  /** Link target */\n  target?: '_blank' | '_self' | '_parent' | '_top';\n  /** Download file name */\n  download?: string;\n  /** Button color */\n  color: Color;\n  /** Button state */\n  state: ComponentState;\n  /** Static display text (takes precedence over reactive content) */\n  text?: string;\n  /** Reactive content configuration for button text */\n  contentKey?: string;\n  /** Component class name for content lookup (required with contentKey) */\n  contentClass?: string;\n  /** Fallback text if contentKey is not found */\n  contentFallback?: string;\n  /** Values to interpolate into the content string */\n  contentInterpolation?: Record<string, string | number>;\n  /** Associated icon */\n  icon?: IconMetada;\n  /** Button shape */\n  shape?: 'round';\n  /** Button size */\n  size?: 'small' | 'default' | 'large';\n  /** Button fill */\n  fill?: 'clear' | 'outline' | 'solid' | 'default';\n  /** Button type */\n  type: 'button' | 'submit' | 'reset';\n  /** Optional token identifier */\n  token?: string;\n  /** Optional reference */\n  ref?: any;\n  /** Action handler */\n  handler?: (value: any) => any | Promise<any>;\n}\n\n/**\n * Configuration for reactive content in val-button component.\n * Use this interface when you only need to specify content-related properties.\n * This follows the same pattern as TextContentConfig for consistency.\n */\nexport interface ButtonContentConfig {\n  contentKey: string;\n  contentClass: string;\n  contentFallback?: string;\n  contentInterpolation?: Record<string, string | number>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/components/types.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,QAAQ,GAAmB,UAAU,CAAC;AAC5C,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,KAAK,GAAmB,OAAO,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAN,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iEAAe,CAAA;IACf,mEAAgB,CAAA;IAChB,iEAAe,CAAA;IACf,+DAAc,CAAA;IACd,uEAAkB,CAAA;AACpB,CAAC,EANW,UAAU,KAAV,UAAU,QAMrB;AAcD;;GAEG;AACH,MAAM,CAAN,IAAY,SAuBX;AAvBD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;IACR,2CAAK,CAAA;IACL,iDAAQ,CAAA;IACR,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6DAAc,CAAA;IACd,iDAAQ,CAAA;IACR,yCAAI,CAAA;IACJ,qDAAU,CAAA;IACV,0CAAI,CAAA;IACJ,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,8CAAM,CAAA;IACN,4DAAa,CAAA;IACb,0DAAY,CAAA;IACZ,wEAAmB,CAAA;IACnB,0CAAI,CAAA;IACJ,8CAAM,CAAA;IACN,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,kDAAQ,CAAA;AACV,CAAC,EAvBW,SAAS,KAAT,SAAS,QAuBpB;AA6HD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["import { FormControl, ValidatorFn } from '@angular/forms';\nimport { Color } from '@ionic/core';\nimport { ImageMetadata } from './atoms/image/types';\n\n/**\n * Possible states for an interactive component.\n */\nexport type ComponentState = 'ENABLED' | 'DISABLED' | 'WORKING' | 'ERROR';\nconst ENABLED: ComponentState = 'ENABLED';\nconst DISABLED: ComponentState = 'DISABLED';\nconst WORKING: ComponentState = 'WORKING';\nconst ERROR: ComponentState = 'ERROR';\n\n/**\n * Object containing all possible component states.\n */\nexport const ComponentStates = { ENABLED, DISABLED, WORKING, ERROR };\n\n/**\n * Types of actions that a button or link can perform.\n */\nexport enum ActionType {\n  BROWSER_NEW_TAB, // Open in a new browser tab\n  BROWSER_DOWNLOAD, // Download via browser\n  NATIVE_DOWNLOAD, // Download using native capabilities\n  APP_NAVIGATION, // Internal app navigation\n  BROWSER_NAVIGATION, // Navigation in the browser\n}\n\n/**\n * Represents an executable action for a button or link.\n */\nexport type Action = {\n  /** Action description */\n  description: string;\n  /** Action type */\n  type: ActionType;\n  /** Action source or destination */\n  source: string;\n};\n\n/**\n * Supported input types for forms.\n */\nexport enum InputType {\n  TEXT,\n  TEXTAREA,\n  EMAIL,\n  PASSWORD,\n  COMMENT,\n  NUMBER,\n  NUMBER_FROM_TO,\n  PIN_CODE,\n  DATE,\n  DATE_RANGE,\n  HOUR,\n  CHECK,\n  RADIO,\n  SELECT,\n  SEARCH_SELECT,\n  MULTI_SELECT,\n  MULTI_SELECT_SIMPLE,\n  FILE,\n  TOGGLE,\n  RANGE,\n  PHONE,\n  CURRENCY,\n}\n\n/**\n * Option for select, radio, etc. inputs.\n */\nexport type InputOption = {\n  /** Unique option identifier */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Whether the option is selected by default */\n  selected?: boolean;\n  /** Display order */\n  order: number;\n};\n\n/**\n * Metadata for a form field.\n */\nexport type InputMetadata = {\n  /** Associated form control */\n  control: FormControl;\n  /** From control (only for NUMBER_FROM_TO type) */\n  fromControl?: FormControl;\n  /** To control (only for NUMBER_FROM_TO type) */\n  toControl?: FormControl;\n  /** Unique token for the input */\n  token: string;\n  /** Display label */\n  label: string;\n  /** Field name */\n  name: string;\n  /** Help text */\n  hint: string;\n  /** Input placeholder */\n  placeholder: string;\n  /** Input type */\n  type: InputType;\n  /** Display order */\n  order: number;\n  /** Associated validators */\n  validators: ValidatorFn[];\n  /** Options (for select, radio, etc.) */\n  options?: InputOption[];\n  /** Allowed range (for number, date, etc.) */\n  range?: {\n    min: number;\n    max: number;\n  };\n  /** Custom error messages */\n  errors: {\n    [key: string]: string;\n  };\n  /** Initial value for the field */\n  value?: string;\n  /** Default value configuration - string for custom defaults, true for auto defaults */\n  withDefault?: string | boolean;\n  /** Field state */\n  state: ComponentState;\n  /** Label for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromLabel?: string;\n  /** Label for \"to\" field (only for NUMBER_FROM_TO type) */\n  toLabel?: string;\n  /** Placeholder for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromPlaceholder?: string;\n  /** Placeholder for \"to\" field (only for NUMBER_FROM_TO type) */\n  toPlaceholder?: string;\n\n  // i18n support properties\n  /** Key for reactive content from LangService */\n  contentKey?: string;\n  /** Component class name for content lookup */\n  contentClass?: string;\n  /** Fallback text if content key is not found */\n  contentFallback?: string;\n\n  // select-input specific i18n properties\n  /** Custom header text for select modal */\n  modalHeader?: string;\n  /** Custom cancel button text for select modal */\n  cancelText?: string;\n  /** Custom OK button text for select modal */\n  okText?: string;\n\n  // check-input specific properties\n  /** Position of label for checkbox ('start' | 'end') */\n  labelPlacement?: 'start' | 'end';\n};\n\n/**\n * A section in a form, grouping multiple fields.\n */\nexport type FormSection = {\n  /** Section name */\n  name: string;\n  /** Display order */\n  order: number;\n  /** Fields included in the section */\n  fields: InputMetadata[];\n};\n\n/**\n * Data sent when submitting a form.\n */\nexport type FormSubmit = {\n  /** List of fields and their values */\n  fields: { key: string; value: string }[];\n  /** Optional token for the operation */\n  token?: string;\n};\n\n/**\n * Metadata for a complete form.\n */\nexport type FormMetadata = {\n  /** Form name */\n  name: string;\n  /** Form sections */\n  sections: FormSection[];\n  /** Action buttons configuration */\n  actions: ButtonMetadata;\n  /** Global form state */\n  state: ComponentState;\n};\n\n/**\n * Possible action types for a toolbar.\n */\nexport enum ToolbarActionType {\n  AVATAR = 'AVATAR',\n  ICON = 'ICON',\n  IMAGE = 'IMAGE',\n  BUTTON = 'BUTTON',\n}\n\n/**\n * Toolbar action definition.\n */\nexport type ToolbarAction = {\n  /** Action type */\n  type: 'AVATAR' | 'ICON' | 'IMAGE' | 'BUTTON';\n  /** Optional token identifier */\n  token?: string;\n  /** Toolbar position */\n  position: 'left' | 'right' | 'center';\n  /** Optional description */\n  description?: string;\n  /** Associated image (if any) */\n  image?: ImageMetadata;\n};\n\n/**\n * Metadata for an icon.\n */\nexport interface IconMetada {\n  /** Icon name */\n  name: string;\n  /** Icon slot position */\n  slot: 'start' | 'end';\n}\n\n/**\n * Button configuration object.\n * Supports both static and reactive content.\n * @type {ButtonMetadata}\n * @property text - Static button label (takes precedence over textConfig).\n * @property textConfig - Reactive content configuration for button text.\n * @property color - The button color (Ionic color string).\n * @property icon - Icon to display (optional).\n * @property state - Button state (enabled, disabled, working, etc.).\n * @property expand, fill, size, shape, href, target, download, handler, etc. - See ButtonMetadata for all options.\n */\nexport interface ButtonMetadata {\n  /** Associated action type */\n  actionType?: ActionType;\n  /** Button expansion */\n  expand?: 'full' | 'block';\n  /** Associated link */\n  link?: string;\n  /** Associated href link */\n  href?: string;\n  /** Link target */\n  target?: '_blank' | '_self' | '_parent' | '_top';\n  /** Download file name */\n  download?: string;\n  /** Button color */\n  color: Color;\n  /** Button state */\n  state: ComponentState;\n  /** Static display text (takes precedence over reactive content) */\n  text?: string;\n  /** Reactive content configuration for button text */\n  contentKey?: string;\n  /** Component class name for content lookup (required with contentKey) */\n  contentClass?: string;\n  /** Fallback text if contentKey is not found */\n  contentFallback?: string;\n  /** Values to interpolate into the content string */\n  contentInterpolation?: Record<string, string | number>;\n  /** Associated icon */\n  icon?: IconMetada;\n  /** Button shape */\n  shape?: 'round';\n  /** Button size */\n  size?: 'small' | 'default' | 'large';\n  /** Button fill */\n  fill?: 'clear' | 'outline' | 'solid' | 'default';\n  /** Button type */\n  type: 'button' | 'submit' | 'reset';\n  /** Optional token identifier */\n  token?: string;\n  /** Optional reference */\n  ref?: any;\n  /** Action handler */\n  handler?: (value: any) => any | Promise<any>;\n}\n\n/**\n * Configuration for reactive content in val-button component.\n * Use this interface when you only need to specify content-related properties.\n * This follows the same pattern as TextContentConfig for consistency.\n */\nexport interface ButtonContentConfig {\n  contentKey: string;\n  contentClass: string;\n  contentFallback?: string;\n  contentInterpolation?: Record<string, string | number>;\n}\n"]}

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

@@ -0,0 +1,103 @@
+/**
+ * Firebase Configuration
+ *
+ * Configuración e inicialización de Firebase para aplicaciones Angular.
+ * Usa provideValtechFirebase() en el bootstrap de tu aplicación.
+ */
+import { InjectionToken, makeEnvironmentProviders } from '@angular/core';
+import { initializeApp, provideFirebaseApp } from '@angular/fire/app';
+import { connectAuthEmulator, getAuth, provideAuth } from '@angular/fire/auth';
+import { connectFirestoreEmulator, enableIndexedDbPersistence, getFirestore, provideFirestore, } from '@angular/fire/firestore';
+import { getMessaging, provideMessaging } from '@angular/fire/messaging';
+import { connectStorageEmulator, getStorage, provideStorage } from '@angular/fire/storage';
+/**
+ * Token de inyección para la configuración de Firebase.
+ * Usado internamente por los servicios de Firebase.
+ */
+export const VALTECH_FIREBASE_CONFIG = new InjectionToken('ValtechFirebaseConfig');
+/**
+ * Provee Firebase a la aplicación Angular.
+ *
+ * @param config - Configuración de Firebase
+ * @returns EnvironmentProviders para usar en bootstrapApplication
+ *
+ * @example
+ * ```typescript
+ * // main.ts
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { provideValtechFirebase } from 'valtech-components';
+ * import { environment } from './environments/environment';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideValtechFirebase({
+ *       firebase: environment.firebase,
+ *       persistence: true,
+ *       emulator: environment.useEmulators ? {
+ *         firestore: { host: 'localhost', port: 8080 },
+ *         auth: { host: 'localhost', port: 9099 },
+ *         storage: { host: 'localhost', port: 9199 },
+ *       } : undefined,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function provideValtechFirebase(config) {
+    return makeEnvironmentProviders([
+        // Guardar configuración para uso en servicios
+        { provide: VALTECH_FIREBASE_CONFIG, useValue: config },
+        // Inicializar Firebase App
+        provideFirebaseApp(() => initializeApp(config.firebase)),
+        // Firestore con soporte para emuladores y persistencia
+        provideFirestore(() => {
+            const firestore = getFirestore();
+            // Conectar a emulador si está configurado
+            if (config.emulator?.firestore) {
+                connectFirestoreEmulator(firestore, config.emulator.firestore.host, config.emulator.firestore.port);
+            }
+            // Habilitar persistencia offline si está configurada
+            if (config.persistence) {
+                enableIndexedDbPersistence(firestore).catch((err) => {
+                    if (err.code === 'failed-precondition') {
+                        console.warn('[ValtechFirebase] Persistencia no disponible: múltiples pestañas abiertas');
+                    }
+                    else if (err.code === 'unimplemented') {
+                        console.warn('[ValtechFirebase] Persistencia no soportada en este navegador');
+                    }
+                });
+            }
+            return firestore;
+        }),
+        // Auth con soporte para emulador
+        provideAuth(() => {
+            const auth = getAuth();
+            // Conectar a emulador si está configurado
+            if (config.emulator?.auth) {
+                connectAuthEmulator(auth, `http://${config.emulator.auth.host}:${config.emulator.auth.port}`, { disableWarnings: true });
+            }
+            return auth;
+        }),
+        // Storage con soporte para emulador
+        provideStorage(() => {
+            const storage = getStorage();
+            // Conectar a emulador si está configurado
+            if (config.emulator?.storage) {
+                connectStorageEmulator(storage, config.emulator.storage.host, config.emulator.storage.port);
+            }
+            return storage;
+        }),
+        // Messaging (FCM) - solo si está soportado
+        provideMessaging(() => getMessaging()),
+    ]);
+}
+/**
+ * Verifica si los emuladores están configurados.
+ *
+ * @param config - Configuración de Firebase
+ * @returns true si hay al menos un emulador configurado
+ */
+export function hasEmulators(config) {
+    return !!(config.emulator?.firestore || config.emulator?.auth || config.emulator?.storage);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../../src/lib/services/firebase/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Firebase Configuration\n *\n * Configuración e inicialización de Firebase para aplicaciones Angular.\n * Usa provideValtechFirebase() en el bootstrap de tu aplicación.\n */\n\nimport { EnvironmentProviders, InjectionToken, makeEnvironmentProviders } from '@angular/core';\nimport { initializeApp, provideFirebaseApp } from '@angular/fire/app';\nimport { connectAuthEmulator, getAuth, provideAuth } from '@angular/fire/auth';\nimport {\n  connectFirestoreEmulator,\n  enableIndexedDbPersistence,\n  getFirestore,\n  provideFirestore,\n} from '@angular/fire/firestore';\nimport { getMessaging, provideMessaging } from '@angular/fire/messaging';\nimport { connectStorageEmulator, getStorage, provideStorage } from '@angular/fire/storage';\n\nimport { ValtechFirebaseConfig } from './types';\n\n/**\n * Token de inyección para la configuración de Firebase.\n * Usado internamente por los servicios de Firebase.\n */\nexport const VALTECH_FIREBASE_CONFIG = new InjectionToken<ValtechFirebaseConfig>(\n  'ValtechFirebaseConfig'\n);\n\n/**\n * Provee Firebase a la aplicación Angular.\n *\n * @param config - Configuración de Firebase\n * @returns EnvironmentProviders para usar en bootstrapApplication\n *\n * @example\n * ```typescript\n * // main.ts\n * import { bootstrapApplication } from '@angular/platform-browser';\n * import { provideValtechFirebase } from 'valtech-components';\n * import { environment } from './environments/environment';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     provideValtechFirebase({\n *       firebase: environment.firebase,\n *       persistence: true,\n *       emulator: environment.useEmulators ? {\n *         firestore: { host: 'localhost', port: 8080 },\n *         auth: { host: 'localhost', port: 9099 },\n *         storage: { host: 'localhost', port: 9199 },\n *       } : undefined,\n *     }),\n *   ],\n * });\n * ```\n */\nexport function provideValtechFirebase(config: ValtechFirebaseConfig): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    // Guardar configuración para uso en servicios\n    { provide: VALTECH_FIREBASE_CONFIG, useValue: config },\n\n    // Inicializar Firebase App\n    provideFirebaseApp(() => initializeApp(config.firebase)),\n\n    // Firestore con soporte para emuladores y persistencia\n    provideFirestore(() => {\n      const firestore = getFirestore();\n\n      // Conectar a emulador si está configurado\n      if (config.emulator?.firestore) {\n        connectFirestoreEmulator(\n          firestore,\n          config.emulator.firestore.host,\n          config.emulator.firestore.port\n        );\n      }\n\n      // Habilitar persistencia offline si está configurada\n      if (config.persistence) {\n        enableIndexedDbPersistence(firestore).catch((err) => {\n          if (err.code === 'failed-precondition') {\n            console.warn(\n              '[ValtechFirebase] Persistencia no disponible: múltiples pestañas abiertas'\n            );\n          } else if (err.code === 'unimplemented') {\n            console.warn('[ValtechFirebase] Persistencia no soportada en este navegador');\n          }\n        });\n      }\n\n      return firestore;\n    }),\n\n    // Auth con soporte para emulador\n    provideAuth(() => {\n      const auth = getAuth();\n\n      // Conectar a emulador si está configurado\n      if (config.emulator?.auth) {\n        connectAuthEmulator(\n          auth,\n          `http://${config.emulator.auth.host}:${config.emulator.auth.port}`,\n          { disableWarnings: true }\n        );\n      }\n\n      return auth;\n    }),\n\n    // Storage con soporte para emulador\n    provideStorage(() => {\n      const storage = getStorage();\n\n      // Conectar a emulador si está configurado\n      if (config.emulator?.storage) {\n        connectStorageEmulator(\n          storage,\n          config.emulator.storage.host,\n          config.emulator.storage.port\n        );\n      }\n\n      return storage;\n    }),\n\n    // Messaging (FCM) - solo si está soportado\n    provideMessaging(() => getMessaging()),\n  ]);\n}\n\n/**\n * Verifica si los emuladores están configurados.\n *\n * @param config - Configuración de Firebase\n * @returns true si hay al menos un emulador configurado\n */\nexport function hasEmulators(config: ValtechFirebaseConfig): boolean {\n  return !!(config.emulator?.firestore || config.emulator?.auth || config.emulator?.storage);\n}\n"]}