valtech-components 2.0.795 → 2.0.797

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

@@ -0,0 +1,193 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, inject, Input, Output } from '@angular/core';
+import { IonContent } from '@ionic/angular/standalone';
+import { HeaderComponent } from '../../organisms/header/header.component';
+import { UpdateBannerComponent } from '../../molecules/update-banner/update-banner.component';
+import { VALTECH_APP_CONFIG } from '../../../services/app-config/config';
+import { resolveColor } from '../../../shared/utils/styles';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/theme.service";
+import * as i2 from "../../../services/navigation";
+import * as i3 from "@angular/common";
+/**
+ * val-page-content
+ *
+ * A page content template with corporate header, main content area,
+ * and footer slots. Supports dark mode and customizable backgrounds.
+ *
+ * @example
+ * <val-page-content
+ *   [props]="{
+ *     header: { ... },
+ *     background: '--main-background',
+ *     homeRoute: '/'
+ *   }"
+ *   (onHeaderClick)="handleHeaderAction($event)"
+ * >
+ *   <div content>
+ *     <!-- Main page content -->
+ *   </div>
+ *   <div footer>
+ *     <val-company-footer [props]="footerProps"></val-company-footer>
+ *   </div>
+ * </val-page-content>
+ *
+ * @input props - Page content configuration
+ * @output onHeaderClick - Emits when a header action is clicked
+ */
+export class PageContentComponent {
+    constructor(theme, nav) {
+        this.theme = theme;
+        this.nav = nav;
+        /**
+         * Page content configuration.
+         */
+        this.props = {};
+        this.appConfigEnabled = inject(VALTECH_APP_CONFIG, { optional: true });
+        /**
+         * Emits when a header action is clicked.
+         */
+        this.onHeaderClick = new EventEmitter();
+        /**
+         * Default header configuration (cached to avoid infinite change detection).
+         */
+        this.defaultHeader = {
+            bordered: true,
+            translucent: true,
+            toolbar: {
+                withBack: false,
+                withActions: true,
+                textColor: 'dark',
+                withMenu: true,
+                title: '',
+                languageSelector: undefined,
+                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,
+                        },
+                    },
+                ],
+            },
+        };
+    }
+    /**
+     * Whether to show the update banner.
+     * Only shows if AppConfigService is configured and not disabled via props.
+     */
+    get showUpdateBanner() {
+        return this.appConfigEnabled !== null && this.props.showUpdateBanner !== false;
+    }
+    /**
+     * Gets header props, using cached default if not provided.
+     * Injects languageSelector into toolbar when provided at page level.
+     */
+    get headerProps() {
+        const header = this.props.header || this.defaultHeader;
+        // Inject languageSelector into toolbar if provided at page level
+        if (this.props.languageSelector && !header.toolbar.languageSelector) {
+            return {
+                ...header,
+                toolbar: {
+                    ...header.toolbar,
+                    languageSelector: this.props.languageSelector,
+                },
+            };
+        }
+        return header;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Handles header action clicks.
+     */
+    onHeaderClickHandler(token) {
+        this.onHeaderClick.emit(token);
+        // Navigate to home route if configured and logo was clicked
+        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: PageContentComponent, deps: [{ token: i1.ThemeService }, { token: i2.NavigationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PageContentComponent, isStandalone: true, selector: "val-page-content", inputs: { props: "props" }, outputs: { onHeaderClick: "onHeaderClick" }, ngImport: i0, template: `
+    <div class="ion-page">
+      <val-header
+        [props]="headerProps"
+        (onClick)="onHeaderClickHandler($event)"
+      />
+      <ion-content
+        [fullscreen]="true"
+        [ngStyle]="{
+          '--background': getBackground()
+        }"
+      >
+        @if (showUpdateBanner) {
+          <val-update-banner />
+        }
+        <div class="page-wrapper">
+          <main>
+            <ng-content select="[content]"></ng-content>
+          </main>
+          <ng-content select="[footer]"></ng-content>
+        </div>
+      </ion-content>
+      <ng-content select="[extra-footer]"></ng-content>
+    </div>
+  `, isInline: true, styles: [".page-wrapper{display:flex;flex-direction:column;min-height:100%}main{flex:1}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: HeaderComponent, selector: "val-header", inputs: ["props"], outputs: ["onClick"] }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: UpdateBannerComponent, selector: "val-update-banner" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PageContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-page-content', standalone: true, imports: [CommonModule, HeaderComponent, IonContent, UpdateBannerComponent], template: `
+    <div class="ion-page">
+      <val-header
+        [props]="headerProps"
+        (onClick)="onHeaderClickHandler($event)"
+      />
+      <ion-content
+        [fullscreen]="true"
+        [ngStyle]="{
+          '--background': getBackground()
+        }"
+      >
+        @if (showUpdateBanner) {
+          <val-update-banner />
+        }
+        <div class="page-wrapper">
+          <main>
+            <ng-content select="[content]"></ng-content>
+          </main>
+          <ng-content select="[footer]"></ng-content>
+        </div>
+      </ion-content>
+      <ng-content select="[extra-footer]"></ng-content>
+    </div>
+  `, styles: [".page-wrapper{display:flex;flex-direction:column;min-height:100%}main{flex:1}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ThemeService }, { type: i2.NavigationService }], propDecorators: { props: [{
+                type: Input
+            }], onHeaderClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page-content.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/templates/page-content/page-content.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, EventEmitter, inject, Input, Output } from '@angular/core';\nimport { IonContent } from '@ionic/angular/standalone';\nimport { HeaderComponent } from '../../organisms/header/header.component';\nimport { UpdateBannerComponent } from '../../molecules/update-banner/update-banner.component';\nimport { ThemeService } from '../../../services/theme.service';\nimport { NavigationService } from '../../../services/navigation';\nimport { VALTECH_APP_CONFIG } from '../../../services/app-config/config';\nimport { PageContentMetadata } from './types';\nimport { resolveColor } from '../../../shared/utils/styles';\n\n/**\n * val-page-content\n *\n * A page content template with corporate header, main content area,\n * and footer slots. Supports dark mode and customizable backgrounds.\n *\n * @example\n * <val-page-content\n *   [props]=\"{\n *     header: { ... },\n *     background: '--main-background',\n *     homeRoute: '/'\n *   }\"\n *   (onHeaderClick)=\"handleHeaderAction($event)\"\n * >\n *   <div content>\n *     <!-- Main page content -->\n *   </div>\n *   <div footer>\n *     <val-company-footer [props]=\"footerProps\"></val-company-footer>\n *   </div>\n * </val-page-content>\n *\n * @input props - Page content configuration\n * @output onHeaderClick - Emits when a header action is clicked\n */\n@Component({\n  selector: 'val-page-content',\n  standalone: true,\n  imports: [CommonModule, HeaderComponent, IonContent, UpdateBannerComponent],\n  template: `\n    <div class=\"ion-page\">\n      <val-header\n        [props]=\"headerProps\"\n        (onClick)=\"onHeaderClickHandler($event)\"\n      />\n      <ion-content\n        [fullscreen]=\"true\"\n        [ngStyle]=\"{\n          '--background': getBackground()\n        }\"\n      >\n        @if (showUpdateBanner) {\n          <val-update-banner />\n        }\n        <div class=\"page-wrapper\">\n          <main>\n            <ng-content select=\"[content]\"></ng-content>\n          </main>\n          <ng-content select=\"[footer]\"></ng-content>\n        </div>\n      </ion-content>\n      <ng-content select=\"[extra-footer]\"></ng-content>\n    </div>\n  `,\n  styles: `\n    .page-wrapper {\n      display: flex;\n      flex-direction: column;\n      min-height: 100%;\n    }\n\n    main {\n      flex: 1;\n    }\n  `,\n})\nexport class PageContentComponent {\n  /**\n   * Page content configuration.\n   */\n  @Input() props: PageContentMetadata = {};\n\n  private appConfigEnabled = inject(VALTECH_APP_CONFIG, { optional: true });\n\n  constructor(\n    private theme: ThemeService,\n    private nav: NavigationService\n  ) {}\n\n  /**\n   * Whether to show the update banner.\n   * Only shows if AppConfigService is configured and not disabled via props.\n   */\n  get showUpdateBanner(): boolean {\n    return this.appConfigEnabled !== null && this.props.showUpdateBanner !== false;\n  }\n\n  /**\n   * Emits when a header action is clicked.\n   */\n  @Output() onHeaderClick = new EventEmitter<string>();\n\n  /**\n   * Default header configuration (cached to avoid infinite change detection).\n   */\n  private readonly defaultHeader = {\n    bordered: true,\n    translucent: true,\n    toolbar: {\n      withBack: false,\n      withActions: true,\n      textColor: 'dark' as const,\n      withMenu: true,\n      title: '',\n      languageSelector: undefined as undefined,\n      actions: [\n        {\n          token: 'header-logo',\n          description: '',\n          position: 'left' as const,\n          type: 'IMAGE' as const,\n          image: {\n            width: 10,\n            src: '--main-logo',\n            alt: 'header logo',\n            mode: 'box' as const,\n            shaded: false,\n            bordered: false,\n            size: 'small' as const,\n            limited: false,\n            flex: true,\n          },\n        },\n      ],\n    },\n  };\n\n  /**\n   * Gets header props, using cached default if not provided.\n   * Injects languageSelector into toolbar when provided at page level.\n   */\n  get headerProps() {\n    const header = this.props.header || this.defaultHeader;\n\n    // Inject languageSelector into toolbar if provided at page level\n    if (this.props.languageSelector && !header.toolbar.languageSelector) {\n      return {\n        ...header,\n        toolbar: {\n          ...header.toolbar,\n          languageSelector: this.props.languageSelector,\n        },\n      };\n    }\n\n    return header;\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   * Handles header action clicks.\n   */\n  onHeaderClickHandler(token: string): void {\n    this.onHeaderClick.emit(token);\n\n    // Navigate to home route if configured and logo was clicked\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-content/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvdGVtcGxhdGVzL3BhZ2UtY29udGVudC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSGVhZGVyTWV0YWRhdGEgfSBmcm9tICcuLi8uLi9vcmdhbmlzbXMvaGVhZGVyL3R5cGVzJztcbmltcG9ydCB7IExhbmd1YWdlU2VsZWN0b3JNZXRhZGF0YSB9IGZyb20gJy4uLy4uL21vbGVjdWxlcy9sYW5ndWFnZS1zZWxlY3Rvci90eXBlcyc7XG5cbi8qKlxuICogQ29uZmlndXJhdGlvbiBmb3IgdGhlIHBhZ2UgY29udGVudCBjb21wb25lbnQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGFnZUNvbnRlbnRNZXRhZGF0YSB7XG4gIC8qKiBIZWFkZXIgY29uZmlndXJhdGlvbiAqL1xuICBoZWFkZXI/OiBIZWFkZXJNZXRhZGF0YTtcbiAgLyoqIEJhY2tncm91bmQgY29sb3Igb3IgQ1NTIHZhcmlhYmxlICovXG4gIGJhY2tncm91bmQ/OiBzdHJpbmc7XG4gIC8qKiBCYWNrZ3JvdW5kIGNvbG9yIGZvciBkYXJrIG1vZGUgKi9cbiAgYmFja2dyb3VuZERhcms/OiBzdHJpbmc7XG4gIC8qKiBSb3V0ZSB0byBuYXZpZ2F0ZSB0byB3aGVuIGhlYWRlciBsb2dvIGlzIGNsaWNrZWQgKi9cbiAgaG9tZVJvdXRlPzogc3RyaW5nO1xuICAvKipcbiAgICogTGFuZ3VhZ2Ugc2VsZWN0b3IgY29uZmlndXJhdGlvbi5cbiAgICogV2hlbiBwcm92aWRlZCwgZGlzcGxheXMgYSBsYW5ndWFnZSBzZWxlY3RvciBpY29uIGluIHRoZSBoZWFkZXIgKGxlZnQgb2YgbWVudSBidXR0b24pLlxuICAgKiBVc2VzICdpY29uJyBtb2RlIGJ5IGRlZmF1bHQgZm9yIGNvbXBhY3QgZGlzcGxheS5cbiAgICovXG4gIGxhbmd1YWdlU2VsZWN0b3I/OiBMYW5ndWFnZVNlbGVjdG9yTWV0YWRhdGE7XG4gIC8qKlxuICAgKiBXaGV0aGVyIHRvIHNob3cgdGhlIHVwZGF0ZSBiYW5uZXIgd2hlbiBhIG5ldyB2ZXJzaW9uIGlzIGF2YWlsYWJsZS5cbiAgICogUmVxdWlyZXMgQXBwQ29uZmlnU2VydmljZSB0byBiZSBjb25maWd1cmVkIHdpdGggcHJvdmlkZVZhbHRlY2hBcHBDb25maWcoKS5cbiAgICogQGRlZmF1bHQgdHJ1ZVxuICAgKi9cbiAgc2hvd1VwZGF0ZUJhbm5lcj86IGJvb2xlYW47XG59XG4iXX0=

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

@@ -0,0 +1,188 @@
+import { CommonModule } from '@angular/common';
+import { Component, computed, EventEmitter, inject, Input, Output } from '@angular/core';
+import { NavController } from '@ionic/angular';
+import { IonCol, IonGrid, IonHeader, IonRow, IonTitle, IonToolbar } from '@ionic/angular/standalone';
+import { ExpandableTextComponent } from '../../molecules/expandable-text/expandable-text.component';
+import { ButtonComponent } from '../../atoms/button/button.component';
+import { I18nService } from '../../../services/i18n';
+import * as i0 from "@angular/core";
+/**
+ * val-page-template
+ *
+ * A page template component with title, expandable description,
+ * content projection, and optional back navigation button.
+ *
+ * @example
+ * <val-page-template
+ *   [props]="{
+ *     pageTitle: 'Getting Started',
+ *     pageDescription: 'Learn how to use our components...',
+ *     showBackButton: true
+ *   }"
+ * >
+ *   <div extra-description>
+ *     <p>Additional info here</p>
+ *   </div>
+ *
+ *   <!-- Main content -->
+ *   <my-content></my-content>
+ *
+ *   <div extra-footer>
+ *     <p>Footer content</p>
+ *   </div>
+ * </val-page-template>
+ *
+ * @input props - Page template configuration
+ * @output onBack - Emits when back button is clicked
+ */
+export class PageTemplateComponent {
+    constructor() {
+        this.nav = inject(NavController);
+        this.i18n = inject(I18nService);
+        /**
+         * Page template configuration.
+         */
+        this.props = {};
+        /**
+         * Emits when the back button is clicked.
+         */
+        this.onBack = new EventEmitter();
+        /**
+         * Back button text - reactive to language changes.
+         */
+        this.backButtonText = computed(() => {
+            this.i18n.lang(); // Track language changes
+            return this.props.backButtonText || this.i18n.t('back');
+        });
+    }
+    /**
+     * Handles back navigation.
+     */
+    handleBack() {
+        this.onBack.emit();
+        this.nav.back();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PageTemplateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PageTemplateComponent, isStandalone: true, selector: "val-page-template", inputs: { props: "props" }, outputs: { onBack: "onBack" }, ngImport: i0, template: `
+    @if (props.pageTitle) {
+      <ion-header [class.ion-no-border]="true">
+        <ion-toolbar style="--background: transparent; --padding-start: 0; --padding-end: 0;">
+          <ion-title class="page-title" size="large" style="--padding-start: 0; --padding-end: 0; padding: 0;">{{ props.pageTitle }}</ion-title>
+        </ion-toolbar>
+      </ion-header>
+    }
+    <ion-grid>
+      <ion-row class="ion-justify-content-center description-row">
+        <ion-col size="12" size-md="10" size-lg="8">
+          @if (props.pageDescription) {
+            <div class="description-container">
+              <val-expandable-text
+                [props]="{
+                  limit: props.descriptionLimit || 180,
+                  content: props.pageDescription,
+                  color: props.descriptionColor || 'dark',
+                }"
+              />
+            </div>
+          }
+          <ng-content select="[extra-description]"></ng-content>
+        </ion-col>
+      </ion-row>
+      <ng-content></ng-content>
+      <ng-content select="[extra-footer]"></ng-content>
+      @if (props.showBackButton) {
+        <ion-row class="ion-justify-content-center back-row">
+          <ion-col size="12" size-md="10" size-lg="8">
+            <val-button
+              class="back-button"
+              [props]="{
+                text: backButtonText(),
+                color: 'dark',
+                size: 'small',
+                type: 'button',
+                state: 'ENABLED',
+                fill: 'outline',
+                shape: 'round',
+                icon: {
+                  name: 'arrow-back-outline',
+                  slot: 'start'
+                }
+              }"
+              (onClick)="handleBack()"
+            />
+          </ion-col>
+        </ion-row>
+      }
+    </ion-grid>
+  `, isInline: true, styles: [".page-title{font-size:1.6rem;font-weight:800}@media (min-width: 768px){.page-title{font-size:2rem}}.description-row{margin-bottom:16px}.description-container{margin-top:1rem}.back-row{margin-bottom:16px}.back-button{display:block;margin:1rem 0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: ExpandableTextComponent, selector: "val-expandable-text", inputs: ["props"] }, { kind: "component", type: IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { kind: "component", type: IonRow, selector: "ion-row" }, { kind: "component", type: IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: ButtonComponent, selector: "val-button", inputs: ["preset", "props"], outputs: ["onClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PageTemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-page-template', standalone: true, imports: [
+                        CommonModule,
+                        IonHeader,
+                        IonToolbar,
+                        IonTitle,
+                        ExpandableTextComponent,
+                        IonGrid,
+                        IonRow,
+                        IonCol,
+                        ButtonComponent,
+                    ], template: `
+    @if (props.pageTitle) {
+      <ion-header [class.ion-no-border]="true">
+        <ion-toolbar style="--background: transparent; --padding-start: 0; --padding-end: 0;">
+          <ion-title class="page-title" size="large" style="--padding-start: 0; --padding-end: 0; padding: 0;">{{ props.pageTitle }}</ion-title>
+        </ion-toolbar>
+      </ion-header>
+    }
+    <ion-grid>
+      <ion-row class="ion-justify-content-center description-row">
+        <ion-col size="12" size-md="10" size-lg="8">
+          @if (props.pageDescription) {
+            <div class="description-container">
+              <val-expandable-text
+                [props]="{
+                  limit: props.descriptionLimit || 180,
+                  content: props.pageDescription,
+                  color: props.descriptionColor || 'dark',
+                }"
+              />
+            </div>
+          }
+          <ng-content select="[extra-description]"></ng-content>
+        </ion-col>
+      </ion-row>
+      <ng-content></ng-content>
+      <ng-content select="[extra-footer]"></ng-content>
+      @if (props.showBackButton) {
+        <ion-row class="ion-justify-content-center back-row">
+          <ion-col size="12" size-md="10" size-lg="8">
+            <val-button
+              class="back-button"
+              [props]="{
+                text: backButtonText(),
+                color: 'dark',
+                size: 'small',
+                type: 'button',
+                state: 'ENABLED',
+                fill: 'outline',
+                shape: 'round',
+                icon: {
+                  name: 'arrow-back-outline',
+                  slot: 'start'
+                }
+              }"
+              (onClick)="handleBack()"
+            />
+          </ion-col>
+        </ion-row>
+      }
+    </ion-grid>
+  `, styles: [".page-title{font-size:1.6rem;font-weight:800}@media (min-width: 768px){.page-title{font-size:2rem}}.description-row{margin-bottom:16px}.description-container{margin-top:1rem}.back-row{margin-bottom:16px}.back-button{display:block;margin:1rem 0}\n"] }]
+        }], propDecorators: { props: [{
+                type: Input
+            }], onBack: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page-template.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/templates/page-template/page-template.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACzF,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACrG,OAAO,EAAE,uBAAuB,EAAE,MAAM,2DAA2D,CAAC;AACpG,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAEtE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAiGH,MAAM,OAAO,qBAAqB;IAhGlC;QAiGU,QAAG,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAC5B,SAAI,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QAEnC;;WAEG;QACM,UAAK,GAAyB,EAAE,CAAC;QAE1C;;WAEG;QACO,WAAM,GAAG,IAAI,YAAY,EAAQ,CAAC;QAE5C;;WAEG;QACH,mBAAc,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC7B,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,yBAAyB;YAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;KASJ;IAPC;;OAEG;IACH,UAAU;QACR,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACnB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IAClB,CAAC;+GA5BU,qBAAqB;mGAArB,qBAAqB,wIAlFtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDT,+TA7DC,YAAY,+BACZ,SAAS,oGACT,UAAU,mFACV,QAAQ,iFACR,uBAAuB,mFACvB,OAAO,wEACP,MAAM,oDACN,MAAM,kTACN,eAAe;;4FAoFN,qBAAqB;kBAhGjC,SAAS;+BACE,mBAAmB,cACjB,IAAI,WACP;wBACP,YAAY;wBACZ,SAAS;wBACT,UAAU;wBACV,QAAQ;wBACR,uBAAuB;wBACvB,OAAO;wBACP,MAAM;wBACN,MAAM;wBACN,eAAe;qBAChB,YACS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDT;8BAsCQ,KAAK;sBAAb,KAAK;gBAKI,MAAM;sBAAf,MAAM","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, computed, EventEmitter, inject, Input, Output } from '@angular/core';\nimport { NavController } from '@ionic/angular';\nimport { IonCol, IonGrid, IonHeader, IonRow, IonTitle, IonToolbar } from '@ionic/angular/standalone';\nimport { ExpandableTextComponent } from '../../molecules/expandable-text/expandable-text.component';\nimport { ButtonComponent } from '../../atoms/button/button.component';\nimport { PageTemplateMetadata } from './types';\nimport { I18nService } from '../../../services/i18n';\n\n/**\n * val-page-template\n *\n * A page template component with title, expandable description,\n * content projection, and optional back navigation button.\n *\n * @example\n * <val-page-template\n *   [props]=\"{\n *     pageTitle: 'Getting Started',\n *     pageDescription: 'Learn how to use our components...',\n *     showBackButton: true\n *   }\"\n * >\n *   <div extra-description>\n *     <p>Additional info here</p>\n *   </div>\n *\n *   <!-- Main content -->\n *   <my-content></my-content>\n *\n *   <div extra-footer>\n *     <p>Footer content</p>\n *   </div>\n * </val-page-template>\n *\n * @input props - Page template configuration\n * @output onBack - Emits when back button is clicked\n */\n@Component({\n  selector: 'val-page-template',\n  standalone: true,\n  imports: [\n    CommonModule,\n    IonHeader,\n    IonToolbar,\n    IonTitle,\n    ExpandableTextComponent,\n    IonGrid,\n    IonRow,\n    IonCol,\n    ButtonComponent,\n  ],\n  template: `\n    @if (props.pageTitle) {\n      <ion-header [class.ion-no-border]=\"true\">\n        <ion-toolbar style=\"--background: transparent; --padding-start: 0; --padding-end: 0;\">\n          <ion-title class=\"page-title\" size=\"large\" style=\"--padding-start: 0; --padding-end: 0; padding: 0;\">{{ props.pageTitle }}</ion-title>\n        </ion-toolbar>\n      </ion-header>\n    }\n    <ion-grid>\n      <ion-row class=\"ion-justify-content-center description-row\">\n        <ion-col size=\"12\" size-md=\"10\" size-lg=\"8\">\n          @if (props.pageDescription) {\n            <div class=\"description-container\">\n              <val-expandable-text\n                [props]=\"{\n                  limit: props.descriptionLimit || 180,\n                  content: props.pageDescription,\n                  color: props.descriptionColor || 'dark',\n                }\"\n              />\n            </div>\n          }\n          <ng-content select=\"[extra-description]\"></ng-content>\n        </ion-col>\n      </ion-row>\n      <ng-content></ng-content>\n      <ng-content select=\"[extra-footer]\"></ng-content>\n      @if (props.showBackButton) {\n        <ion-row class=\"ion-justify-content-center back-row\">\n          <ion-col size=\"12\" size-md=\"10\" size-lg=\"8\">\n            <val-button\n              class=\"back-button\"\n              [props]=\"{\n                text: backButtonText(),\n                color: 'dark',\n                size: 'small',\n                type: 'button',\n                state: 'ENABLED',\n                fill: 'outline',\n                shape: 'round',\n                icon: {\n                  name: 'arrow-back-outline',\n                  slot: 'start'\n                }\n              }\"\n              (onClick)=\"handleBack()\"\n            />\n          </ion-col>\n        </ion-row>\n      }\n    </ion-grid>\n  `,\n  styles: `\n    .page-title {\n      font-size: 1.6rem;\n      font-weight: 800;\n    }\n\n    @media (min-width: 768px) {\n      .page-title {\n        font-size: 2rem;\n      }\n    }\n\n    .description-row {\n      margin-bottom: 16px;\n    }\n\n    .description-container {\n      margin-top: 1rem;\n    }\n\n    .back-row {\n      margin-bottom: 16px;\n    }\n\n    .back-button {\n      display: block;\n      margin: 1rem 0;\n    }\n  `,\n})\nexport class PageTemplateComponent {\n  private nav = inject(NavController);\n  private i18n = inject(I18nService);\n\n  /**\n   * Page template configuration.\n   */\n  @Input() props: PageTemplateMetadata = {};\n\n  /**\n   * Emits when the back button is clicked.\n   */\n  @Output() onBack = new EventEmitter<void>();\n\n  /**\n   * Back button text - reactive to language changes.\n   */\n  backButtonText = computed(() => {\n    this.i18n.lang(); // Track language changes\n    return this.props.backButtonText || this.i18n.t('back');\n  });\n\n  /**\n   * Handles back navigation.\n   */\n  handleBack(): void {\n    this.onBack.emit();\n    this.nav.back();\n  }\n}\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvdGVtcGxhdGVzL3BhZ2UtdGVtcGxhdGUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29uZmlndXJhdGlvbiBmb3IgdGhlIHBhZ2UgdGVtcGxhdGUgY29tcG9uZW50LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFBhZ2VUZW1wbGF0ZU1ldGFkYXRhIHtcbiAgLyoqIFBhZ2UgdGl0bGUgZGlzcGxheWVkIGluIGxhcmdlIGhlYWRlciBzdHlsZSAqL1xuICBwYWdlVGl0bGU/OiBzdHJpbmc7XG4gIC8qKiBQYWdlIGRlc2NyaXB0aW9uIChleHBhbmRhYmxlIHRleHQpICovXG4gIHBhZ2VEZXNjcmlwdGlvbj86IHN0cmluZztcbiAgLyoqIFNob3cgYSBiYWNrIGJ1dHRvbiBhdCB0aGUgYm90dG9tICovXG4gIHNob3dCYWNrQnV0dG9uPzogYm9vbGVhbjtcbiAgLyoqIEN1c3RvbSB0ZXh0IGZvciB0aGUgYmFjayBidXR0b24gKGRlZmF1bHQ6ICdCYWNrJykgKi9cbiAgYmFja0J1dHRvblRleHQ/OiBzdHJpbmc7XG4gIC8qKiBDaGFyYWN0ZXIgbGltaXQgZm9yIGRlc2NyaXB0aW9uIGJlZm9yZSBleHBhbmQgKGRlZmF1bHQ6IDE4MCkgKi9cbiAgZGVzY3JpcHRpb25MaW1pdD86IG51bWJlcjtcbiAgLyoqIFRleHQgY29sb3IgZm9yIHRoZSBkZXNjcmlwdGlvbiAoZGVmYXVsdDogJ2RhcmsnKSAqL1xuICBkZXNjcmlwdGlvbkNvbG9yPzogc3RyaW5nO1xufVxuIl19

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

@@ -0,0 +1,192 @@
+import { CommonModule } from '@angular/common';
+import { Component, computed, 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 { ContainerComponent } from '../../atoms/container/container.component';
+import { ThemeService } from '../../../services/theme.service';
+import { NavigationService } from '../../../services/navigation';
+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.
+         * Signal-based input for full reactivity with computed().
+         */
+        this.props = input({
+            scrollToTopOnNavigate: true,
+        });
+        /**
+         * Emits when a header action is clicked.
+         */
+        this.onHeaderClick = new EventEmitter();
+        /**
+         * Default header configuration (cached to avoid infinite change detection).
+         */
+        this.defaultHeader = {
+            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,
+                        },
+                    },
+                ],
+            },
+        };
+        // Computed helpers for template bindings
+        this.headerProps = computed(() => this.props()?.header || this.defaultHeader);
+        this.contentId = computed(() => this.props()?.contentId || 'page-wrapper');
+        this.propsFooter = computed(() => this.props()?.footer);
+        this.contentMaxWidth = computed(() => this.props()?.contentMaxWidth ?? 'fluid');
+        this.background = computed(() => {
+            if (this.theme.IsDark) {
+                return 'var(--ion-background-color)';
+            }
+            const bg = this.props()?.background;
+            if (!bg) {
+                return 'var(--ion-background-color)';
+            }
+            return resolveColor(bg);
+        });
+    }
+    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();
+    }
+    /**
+     * Scrolls the content to the top.
+     */
+    scrollToTop() {
+        const id = this.props()?.contentId || 'page-wrapper';
+        const ionContent = document.querySelector(`#${id}`);
+        if (ionContent && ionContent.scrollToTop) {
+            ionContent.scrollToTop(300);
+        }
+        else {
+            window.scrollTo({ top: 0, behavior: 'smooth' });
+        }
+    }
+    /**
+     * Handles header action clicks.
+     */
+    onHeaderClickHandler(token) {
+        this.onHeaderClick.emit(token);
+        const homeRoute = this.props()?.homeRoute;
+        if (token === 'header-logo' && homeRoute) {
+            this.nav.navigateByUrl(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: { classPropertyName: "props", publicName: "props", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onHeaderClick: "onHeaderClick" }, ngImport: i0, template: `
+    <div class="ion-page">
+      <val-header [props]="headerProps()" (onClick)="onHeaderClickHandler($event)" />
+      <ion-content
+        [id]="contentId()"
+        [fullscreen]="true"
+        [ngStyle]="{
+          '--background': background(),
+        }"
+      >
+        <val-container [props]="{ size: contentMaxWidth() }">
+          <main>
+            <router-outlet></router-outlet>
+          </main>
+        </val-container>
+        @if (propsFooter()) {
+          <val-company-footer [props]="propsFooter()" />
+        }
+      </ion-content>
+    </div>
+  `, isInline: true, styles: ["main{min-height:60vh;padding-bottom:calc(var(--val-bottom-nav-height, 0px) + env(safe-area-inset-bottom,0px) + 16px)}\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: "component", type: ContainerComponent, selector: "val-container", 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, ContainerComponent, RouterOutlet, IonContent], template: `
+    <div class="ion-page">
+      <val-header [props]="headerProps()" (onClick)="onHeaderClickHandler($event)" />
+      <ion-content
+        [id]="contentId()"
+        [fullscreen]="true"
+        [ngStyle]="{
+          '--background': background(),
+        }"
+      >
+        <val-container [props]="{ size: contentMaxWidth() }">
+          <main>
+            <router-outlet></router-outlet>
+          </main>
+        </val-container>
+        @if (propsFooter()) {
+          <val-company-footer [props]="propsFooter()" />
+        }
+      </ion-content>
+    </div>
+  `, styles: ["main{min-height:60vh;padding-bottom:calc(var(--val-bottom-nav-height, 0px) + env(safe-area-inset-bottom,0px) + 16px)}\n"] }]
+        }], propDecorators: { 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, computed, 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 { ContainerComponent } from '../../atoms/container/container.component';\nimport { ContainerSize } from '../../atoms/container/types';\nimport { ThemeService } from '../../../services/theme.service';\nimport { NavigationService } from '../../../services/navigation';\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, ContainerComponent, RouterOutlet, IonContent],\n  template: `\n    <div class=\"ion-page\">\n      <val-header [props]=\"headerProps()\" (onClick)=\"onHeaderClickHandler($event)\" />\n      <ion-content\n        [id]=\"contentId()\"\n        [fullscreen]=\"true\"\n        [ngStyle]=\"{\n          '--background': background(),\n        }\"\n      >\n        <val-container [props]=\"{ size: contentMaxWidth() }\">\n          <main>\n            <router-outlet></router-outlet>\n          </main>\n        </val-container>\n        @if (propsFooter()) {\n          <val-company-footer [props]=\"propsFooter()\" />\n        }\n      </ion-content>\n    </div>\n  `,\n  styles: `\n    main {\n      min-height: 60vh;\n      /* Reserva espacio para el bottom-nav floating + safe-area (iOS home indicator)\n         + breathing room (16px). Sin esto, el último elemento queda tapado por\n         el nav en mobile/PWA. */\n      padding-bottom: calc(var(--val-bottom-nav-height, 0px) + env(safe-area-inset-bottom, 0px) + 16px);\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   * Signal-based input for full reactivity with computed().\n   */\n  readonly props = input<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 (cached to avoid infinite change detection).\n   */\n  private readonly defaultHeader = {\n    bordered: true,\n    translucent: true,\n    toolbar: {\n      withBack: false,\n      withActions: true,\n      textColor: 'dark' as const,\n      withMenu: true,\n      title: '',\n      actions: [\n        {\n          token: 'header-logo',\n          description: '',\n          position: 'left' as const,\n          type: 'IMAGE' as const,\n          image: {\n            width: 10,\n            src: '--main-logo',\n            alt: 'header logo',\n            mode: 'box' as const,\n            shaded: false,\n            bordered: false,\n            size: 'small' as const,\n            limited: false,\n            flex: true,\n          },\n        },\n      ],\n    },\n  };\n\n  // Computed helpers for template bindings\n  headerProps = computed(() => this.props()?.header || this.defaultHeader);\n  contentId = computed(() => this.props()?.contentId || 'page-wrapper');\n  propsFooter = computed(() => this.props()?.footer);\n  contentMaxWidth = computed<ContainerSize>(() => this.props()?.contentMaxWidth ?? 'fluid');\n  background = computed(() => {\n    if (this.theme.IsDark) {\n      return 'var(--ion-background-color)';\n    }\n    const bg = this.props()?.background;\n    if (!bg) {\n      return 'var(--ion-background-color)';\n    }\n    return resolveColor(bg);\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   * Scrolls the content to the top.\n   */\n  private scrollToTop(): void {\n    const id = this.props()?.contentId || 'page-wrapper';\n    const ionContent = document.querySelector(`#${id}`) 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    const homeRoute = this.props()?.homeRoute;\n    if (token === 'header-logo' && homeRoute) {\n      this.nav.navigateByUrl(homeRoute);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvdGVtcGxhdGVzL3BhZ2Utd3JhcHBlci90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSGVhZGVyTWV0YWRhdGEgfSBmcm9tICcuLi8uLi9vcmdhbmlzbXMvaGVhZGVyL3R5cGVzJztcbmltcG9ydCB7IENvbXBhbnlGb290ZXJNZXRhZGF0YSB9IGZyb20gJy4uLy4uL29yZ2FuaXNtcy9jb21wYW55LWZvb3Rlci90eXBlcyc7XG5pbXBvcnQgeyBDb250YWluZXJTaXplIH0gZnJvbSAnLi4vLi4vYXRvbXMvY29udGFpbmVyL3R5cGVzJztcblxuLyoqXG4gKiBDb25maWd1cmF0aW9uIGZvciB0aGUgcGFnZSB3cmFwcGVyIGNvbXBvbmVudC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBQYWdlV3JhcHBlck1ldGFkYXRhIHtcbiAgLyoqIEhlYWRlciBjb25maWd1cmF0aW9uICovXG4gIGhlYWRlcj86IEhlYWRlck1ldGFkYXRhO1xuICAvKiogRm9vdGVyIGNvbmZpZ3VyYXRpb24gKi9cbiAgZm9vdGVyPzogQ29tcGFueUZvb3Rlck1ldGFkYXRhO1xuICAvKiogQmFja2dyb3VuZCBjb2xvciBvciBDU1MgdmFyaWFibGUgKi9cbiAgYmFja2dyb3VuZD86IHN0cmluZztcbiAgLyoqIFJvdXRlIHRvIG5hdmlnYXRlIHRvIHdoZW4gaGVhZGVyIGxvZ28gaXMgY2xpY2tlZCAqL1xuICBob21lUm91dGU/OiBzdHJpbmc7XG4gIC8qKiBDb250ZW50IElEIGZvciBzY3JvbGwgaGFuZGxpbmcgKi9cbiAgY29udGVudElkPzogc3RyaW5nO1xuICAvKiogRW5hYmxlIHNjcm9sbC10by10b3Agb24gcm91dGUgY2hhbmdlICovXG4gIHNjcm9sbFRvVG9wT25OYXZpZ2F0ZT86IGJvb2xlYW47XG4gIC8qKlxuICAgKiBNYXgtd2lkdGggY2FwIGZvciB0aGUgcm91dGVkIGNvbnRlbnQgdXNpbmcgZGVzaWduIHRva2Vucy5cbiAgICogJ2ZsdWlkJyA9IG5vIGNhcCAoZGVmYXVsdCwgYmFja3dhcmRzLWNvbXBhdGlibGUpLlxuICAgKiBSZWNvbW1lbmRlZDogJ3hsJyBmb3IgdHlwaWNhbCBhcHAgcGFnZXMuXG4gICAqL1xuICBjb250ZW50TWF4V2lkdGg/OiBDb250YWluZXJTaXplO1xufVxuIl19