@decaf-ts/for-angular 0.0.12 → 0.0.14

package/esm2022/components/empty-state/empty-state.component.mjs

@@ -0,0 +1,348 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, inject, Input } from '@angular/core';
+import { IonCard, IonCardContent, IonIcon, IonTitle, NavController } from '@ionic/angular/standalone';
+import * as allIcons from 'ionicons/icons';
+import { addIcons } from 'ionicons';
+import { ForAngularModule } from '../../for-angular.module';
+import { Dynamic } from '../../engine';
+import { stringToBoolean } from '../../helpers';
+import { NgxBaseComponent } from '../../engine/NgxBaseComponent';
+import { DomSanitizer } from '@angular/platform-browser';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular/standalone";
+import * as i2 from "@angular/common";
+/**
+ * @description Component for displaying empty state messages with optional actions.
+ * @summary This component provides a standardized way to display empty state messages
+ * when no data is available or when a user needs to take an action to populate content.
+ * It includes customizable title, subtitle, icon, and action button elements that can be
+ * styled and configured through input properties. The component supports localization
+ * and can trigger navigation or custom actions when the button is clicked.
+ *
+ * @mermaid
+ * classDiagram
+ *   class EmptyStateComponent {
+ *     +string title
+ *     +string titleColor
+ *     +string subtitle
+ *     +string subtitleColor
+ *     +StringOrBoolean showIcon
+ *     +string icon
+ *     +string iconSize
+ *     +PredefinedColors iconColor
+ *     +string|Function buttonLink
+ *     +string buttonText
+ *     +string buttonFill
+ *     +Color buttonColor
+ *     +string buttonSize
+ *     +string searchValue
+ *     -NavController navController
+ *     +ngOnInit()
+ *     +handleClick()
+ *   }
+ *   EmptyStateComponent --|> NgxBaseComponent
+ *   EmptyStateComponent --|> OnInit
+ *
+ * @extends {NgxBaseComponent}
+ * @implements {OnInit}
+ */
+let EmptyStateComponent = class EmptyStateComponent extends NgxBaseComponent {
+    /**
+     * @description Creates an instance of EmptyStateComponent.
+     * @summary Initializes a new EmptyStateComponent by calling the parent class constructor
+     * with the component name for logging and identification purposes. This component provides
+     * a standardized way to display empty state messages with optional icons and action buttons.
+     *
+     * @memberOf EmptyStateComponent
+     */
+    constructor() {
+        super("EmptyStateComponent");
+        /**
+         * @description The main title displayed in the empty state.
+         * @summary Specifies the primary message to show in the empty state component.
+         * This text is typically used to inform the user about why they're seeing an empty view.
+         * If translatable is true, this will be processed through the localization system.
+         *
+         * @type {string}
+         * @default "title"
+         * @memberOf EmptyStateComponent
+         */
+        this.title = "title";
+        /**
+         * @description The color of the title text.
+         * @summary Specifies the color for the title text using the application's color system.
+         * The value should correspond to a color variable defined in the application's theme.
+         * The component will automatically prefix this with "color-" to create the CSS class.
+         *
+         * @type {string}
+         * @default 'gray-6'
+         * @memberOf EmptyStateComponent
+         */
+        this.titleColor = 'gray-6';
+        /**
+         * @description The secondary message displayed in the empty state.
+         * @summary Provides additional context or instructions below the main title.
+         * This text is typically used to guide the user on what actions they can take.
+         * If translatable is true, this will be processed through the localization system.
+         *
+         * @type {string | undefined}
+         * @memberOf EmptyStateComponent
+         */
+        this.subtitle = "";
+        /**
+         * @description The color of the subtitle text.
+         * @summary Specifies the color for the subtitle text using the application's color system.
+         * The value should correspond to a color variable defined in the application's theme.
+         * The component will automatically prefix this with "color-" to create the CSS class.
+         *
+         * @type {string}
+         * @default 'gray-4'
+         * @memberOf EmptyStateComponent
+         */
+        this.subtitleColor = 'gray-4';
+        /**
+         * @description Controls whether the icon is displayed.
+         * @summary Determines if the visual icon should be shown in the empty state.
+         * This can be provided as a boolean or a string that will be converted to a boolean.
+         * Icons help visually communicate the empty state context to users.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf EmptyStateComponent
+         */
+        this.showIcon = true;
+        /**
+         * @description The name of the icon to display.
+         * @summary Specifies which icon to show when showIcon is true.
+         * The component uses the icon system defined in the application,
+         * and this value should correspond to an available icon name.
+         *
+         * @type {string}
+         * @default "ti-info-square-rounded"
+         * @memberOf EmptyStateComponent
+         */
+        this.icon = "ti-info-square-rounded";
+        /**
+         * @description The size of the displayed icon.
+         * @summary Controls the size of the icon shown in the empty state.
+         * Can be either 'large' or 'small' to accommodate different layout needs.
+         *
+         * @type {'large' | 'small' | undefined}
+         * @default 'large'
+         * @memberOf EmptyStateComponent
+         */
+        this.iconSize = 'large';
+        /**
+         * @description The color of the displayed icon.
+         * @summary Specifies the color for the icon using Ionic's predefined color system.
+         * This allows the icon to match the application's color scheme.
+         *
+         * @type {PredefinedColors | undefined}
+         * @default 'medium'
+         * @memberOf EmptyStateComponent
+         */
+        this.iconColor = 'medium';
+        /**
+         * @description The fill style of the action button.
+         * @summary Controls the visual style of the button using Ionic's button fill options.
+         * 'solid' creates a button with a solid background, 'outline' creates a button with
+         * just a border, and 'clear' creates a button with no background or border.
+         *
+         * @type {'clear' | 'solid' | 'outline'}
+         * @default 'solid'
+         * @memberOf EmptyStateComponent
+         */
+        this.buttonFill = 'solid';
+        /**
+         * @description The color of the action button.
+         * @summary Specifies the color for the button using Ionic's color system.
+         * This allows the button to match the application's color scheme.
+         *
+         * @type {Color}
+         * @default 'primary'
+         * @memberOf EmptyStateComponent
+         */
+        this.buttonColor = 'primary';
+        /**
+         * @description The size of the action button.
+         * @summary Controls the size of the button shown in the empty state.
+         * Can be 'large', 'small', or 'default' to accommodate different layout needs.
+         *
+         * @type {'large' | 'small' | 'default'}
+         * @default 'default'
+         * @memberOf EmptyStateComponent
+         */
+        this.buttonSize = 'default';
+        /**
+         * @description Service for handling navigation operations.
+         * @summary Injected service that provides methods for navigating between routes.
+         * This service is used when the buttonLink is a string URL to navigate to that location.
+         *
+         * @private
+         * @type {NavController}
+         * @memberOf EmptyStateComponent
+         */
+        this.navController = inject(NavController);
+        this.sanitizer = inject(DomSanitizer);
+        this.translate = inject(TranslateService);
+        addIcons(allIcons);
+    }
+    /**
+     * @description Initializes the component after Angular first displays the data-bound properties.
+     * @summary Sets up the component by processing boolean inputs, applying localization to text
+     * elements if translation is enabled, and formatting CSS classes for title and subtitle colors.
+     * This method prepares the component for user interaction by ensuring all properties are
+     * properly initialized and localized.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant E as EmptyStateComponent
+     *
+     *   A->>E: ngOnInit()
+     *   E->>E: Process translatable flag
+     *   E->>E: Process showIcon flag
+     *   E->>E: Get locale settings
+     *   alt translatable is true
+     *     E->>E: Localize title
+     *     E->>E: Localize subtitle
+     *     E->>E: Localize buttonText
+     *   end
+     *   E->>E: Format title CSS class
+     *   E->>E: Format subtitle CSS class
+     *
+     * @return {Promise<void>}
+     * @memberOf EmptyStateComponent
+     */
+    async ngOnInit() {
+        this.parseProps(this);
+        this.translatable = stringToBoolean(this.translatable);
+        this.showIcon = stringToBoolean(this.showIcon);
+        this.locale = this.getLocale(this.translatable);
+        // if(this.translatable) {
+        //   this.title = generateLocaleFromString(this.locale, this.title);
+        //   this.subtitle = generateLocaleFromString(this.locale, this.subtitle);
+        //   this.buttonText = generateLocaleFromString(this.locale, this.buttonText);
+        // }
+        this.titleColor = `dcf-title color-${this.titleColor}`;
+        this.subtitleColor = `dcf-subtitle color-${this.titleColor}`;
+        if (this.searchValue && this.translatable)
+            this.searchSubtitle = await this.getSearchSubtitle(this.subtitle);
+    }
+    /**
+     * @description Handles click events on the action button.
+     * @summary This method is triggered when the user clicks the action button in the empty state
+     * component. It supports three navigation patterns: 1) no action when buttonLink is not provided,
+     * 2) custom function execution when buttonLink is a function, and 3) navigation to a specific URL
+     * when buttonLink is a string. This flexibility allows the empty state to trigger various actions
+     * based on the context in which it's used.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant E as EmptyStateComponent
+     *   participant N as NavController
+     *
+     *   U->>E: Click action button
+     *   E->>E: handleClick()
+     *   alt buttonLink is not provided
+     *     E-->>U: Return false (no action)
+     *   else buttonLink is a function
+     *     E->>E: Execute buttonLink function
+     *     E-->>U: Return function result
+     *   else buttonLink is a URL string
+     *     E->>N: navigateForward(buttonLink)
+     *     N-->>E: Return navigation result
+     *     E-->>U: Return navigation result
+     *   end
+     *
+     * @return {boolean | void | Promise<boolean>}
+     *   - false if no action is taken
+     *   - The result of the buttonLink function if it's a function
+     *   - A Promise resolving to the navigation result if buttonLink is a URL
+     * @memberOf EmptyStateComponent
+     */
+    handleClick() {
+        const fn = this.buttonLink;
+        if (!fn)
+            return false;
+        if (fn instanceof Function)
+            return fn();
+        return this.navController.navigateForward(fn);
+    }
+    /**
+      * @description Generates a localized and sanitized subtitle for search results.
+      * @summary This method takes a content string, typically the subtitle, and processes it
+      * through the translation service. It replaces a placeholder ('value0') with the actual
+      * search value, then sanitizes the result to safely use as HTML. This is particularly
+      * useful for displaying dynamic, localized messages in the empty state when a search
+      * yields no results.
+      *
+      * @param {string} content - The content string to be translated and processed
+      * @return {Promise<SafeHtml>} A promise that resolves to a sanitized HTML string
+      *
+      * @mermaid
+      * sequenceDiagram
+      *   participant E as EmptyStateComponent
+      *   participant T as TranslateService
+      *   participant S as DomSanitizer
+      *
+      *   E->>T: instant(content, {'value0': searchValue})
+      *   T-->>E: Return translated string
+      *   E->>S: bypassSecurityTrustHtml(translatedString)
+      *   S-->>E: Return sanitized SafeHtml
+      *
+      * @memberOf EmptyStateComponent
+      */
+    async getSearchSubtitle(content) {
+        const result = await this.translate.instant(content, { 'value0': this.searchValue });
+        return this.sanitizer.bypassSecurityTrustHtml(result);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyStateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: EmptyStateComponent, isStandalone: true, selector: "ngx-decaf-empty-state", inputs: { title: "title", titleColor: "titleColor", subtitle: "subtitle", subtitleColor: "subtitleColor", showIcon: "showIcon", icon: "icon", iconSize: "iconSize", iconColor: "iconColor", buttonLink: "buttonLink", buttonText: "buttonText", buttonFill: "buttonFill", buttonColor: "buttonColor", buttonSize: "buttonSize", searchValue: "searchValue" }, usesInheritance: true, ngImport: i0, template: "\n<ion-card id=\"dcf-card-empty-state\" [ngClass]=\"className\">\n  <ion-card-content>\n    @if(icon && showIcon) {\n      <div class=\"dcf-icon-container\">\n        <ion-icon\n          name=\"alert-circle-outline\"\n          size=\"large\"\n          color=\"danger\"\n          />\n      </div>\n    }\n    @if(title) {\n      <h5 [class]=\"titleColor\" [innerHTML]=\"title\"></h5>\n    }\n    @if(subtitle) {\n      @if(!searchValue) {\n        <p [class]=\"subtitleColor\" [innerHTML]=\"subtitle\"></p>\n      } @else {\n        <p [class]=\"subtitleColor\" [innerHTML]=\"searchSubtitle\"></p>\n      }\n    }\n    @if(buttonLink && buttonText) {\n      <div>\n        <ion-button\n          [size]=\"buttonSize\"\n          [fill]=\"buttonFill\"\n          [color]=\"buttonColor\"\n          (click)=\"handleClick()\">\n          {{  buttonText }}\n        </ion-button>\n      </div>\n    }\n  </ion-card-content>\n</ion-card>\n", styles: ["ion-card{text-align:center}ion-card ion-button{margin-top:.75rem}ion-card ion-icon{font-size:2.5rem}ion-card .dcf-icon-container{transform:scale(1.25);opacity:.75;margin-top:1.25rem!important;margin-bottom:.5rem!important}ion-card .dcf-ititle{font-weight:600!important;color:var(--ion-color-gray-6)!important}ion-card .dcf-isubtitle{font-weight:500!important}\n"], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "component", type: i1.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: IonCard, selector: "ion-card", inputs: ["button", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }, { kind: "component", type: IonCardContent, selector: "ion-card-content", inputs: ["mode"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }] }); }
+};
+EmptyStateComponent = __decorate([
+    Dynamic(),
+    __metadata("design:paramtypes", [])
+], EmptyStateComponent);
+export { EmptyStateComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EmptyStateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-decaf-empty-state', standalone: true, imports: [
+                        ForAngularModule,
+                        IonCard,
+                        IonCardContent,
+                        IonTitle,
+                        IonIcon
+                    ], template: "\n<ion-card id=\"dcf-card-empty-state\" [ngClass]=\"className\">\n  <ion-card-content>\n    @if(icon && showIcon) {\n      <div class=\"dcf-icon-container\">\n        <ion-icon\n          name=\"alert-circle-outline\"\n          size=\"large\"\n          color=\"danger\"\n          />\n      </div>\n    }\n    @if(title) {\n      <h5 [class]=\"titleColor\" [innerHTML]=\"title\"></h5>\n    }\n    @if(subtitle) {\n      @if(!searchValue) {\n        <p [class]=\"subtitleColor\" [innerHTML]=\"subtitle\"></p>\n      } @else {\n        <p [class]=\"subtitleColor\" [innerHTML]=\"searchSubtitle\"></p>\n      }\n    }\n    @if(buttonLink && buttonText) {\n      <div>\n        <ion-button\n          [size]=\"buttonSize\"\n          [fill]=\"buttonFill\"\n          [color]=\"buttonColor\"\n          (click)=\"handleClick()\">\n          {{  buttonText }}\n        </ion-button>\n      </div>\n    }\n  </ion-card-content>\n</ion-card>\n", styles: ["ion-card{text-align:center}ion-card ion-button{margin-top:.75rem}ion-card ion-icon{font-size:2.5rem}ion-card .dcf-icon-container{transform:scale(1.25);opacity:.75;margin-top:1.25rem!important;margin-bottom:.5rem!important}ion-card .dcf-ititle{font-weight:600!important;color:var(--ion-color-gray-6)!important}ion-card .dcf-isubtitle{font-weight:500!important}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { title: [{
+                type: Input
+            }], titleColor: [{
+                type: Input
+            }], subtitle: [{
+                type: Input
+            }], subtitleColor: [{
+                type: Input
+            }], showIcon: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], iconSize: [{
+                type: Input
+            }], iconColor: [{
+                type: Input
+            }], buttonLink: [{
+                type: Input
+            }], buttonText: [{
+                type: Input
+            }], buttonFill: [{
+                type: Input
+            }], buttonColor: [{
+                type: Input
+            }], buttonSize: [{
+                type: Input
+            }], searchValue: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"empty-state.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/empty-state/empty-state.component.ts","../../../../../src/lib/components/empty-state/empty-state.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, inject, Input, OnInit  } from '@angular/core';\nimport { Color, PredefinedColors } from '@ionic/core';\nimport {\n  IonCard,\n  IonCardContent,\n  IonIcon,\n  IonTitle,\n  NavController\n}\nfrom '@ionic/angular/standalone';\nimport * as allIcons from 'ionicons/icons';\nimport { addIcons } from 'ionicons';\nimport { ForAngularModule } from '../../for-angular.module';\nimport { Dynamic, StringOrBoolean } from '../../engine';\nimport { stringToBoolean } from '../../helpers';\nimport { NgxBaseComponent } from '../../engine/NgxBaseComponent';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\nimport { TranslateService } from '@ngx-translate/core';\nimport { FunctionLike } from '../../engine/types';\n\n\n/**\n * @description Component for displaying empty state messages with optional actions.\n * @summary This component provides a standardized way to display empty state messages\n * when no data is available or when a user needs to take an action to populate content.\n * It includes customizable title, subtitle, icon, and action button elements that can be\n * styled and configured through input properties. The component supports localization\n * and can trigger navigation or custom actions when the button is clicked.\n *\n * @mermaid\n * classDiagram\n *   class EmptyStateComponent {\n *     +string title\n *     +string titleColor\n *     +string subtitle\n *     +string subtitleColor\n *     +StringOrBoolean showIcon\n *     +string icon\n *     +string iconSize\n *     +PredefinedColors iconColor\n *     +string|Function buttonLink\n *     +string buttonText\n *     +string buttonFill\n *     +Color buttonColor\n *     +string buttonSize\n *     +string searchValue\n *     -NavController navController\n *     +ngOnInit()\n *     +handleClick()\n *   }\n *   EmptyStateComponent --|> NgxBaseComponent\n *   EmptyStateComponent --|> OnInit\n *\n * @extends {NgxBaseComponent}\n * @implements {OnInit}\n */\n@Dynamic()\n@Component({\n  selector: 'ngx-decaf-empty-state',\n  templateUrl: './empty-state.component.html',\n  styleUrls: ['./empty-state.component.scss'],\n  standalone: true,\n  imports: [\n    ForAngularModule,\n    IonCard,\n    IonCardContent,\n    IonTitle,\n    IonIcon\n  ]\n\n})\nexport class EmptyStateComponent extends NgxBaseComponent implements OnInit {\n\n  /**\n   * @description The main title displayed in the empty state.\n   * @summary Specifies the primary message to show in the empty state component.\n   * This text is typically used to inform the user about why they're seeing an empty view.\n   * If translatable is true, this will be processed through the localization system.\n   *\n   * @type {string}\n   * @default \"title\"\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  title: string = \"title\";\n\n  /**\n   * @description The color of the title text.\n   * @summary Specifies the color for the title text using the application's color system.\n   * The value should correspond to a color variable defined in the application's theme.\n   * The component will automatically prefix this with \"color-\" to create the CSS class.\n   *\n   * @type {string}\n   * @default 'gray-6'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  titleColor = 'gray-6';\n\n  /**\n   * @description The secondary message displayed in the empty state.\n   * @summary Provides additional context or instructions below the main title.\n   * This text is typically used to guide the user on what actions they can take.\n   * If translatable is true, this will be processed through the localization system.\n   *\n   * @type {string | undefined}\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  subtitle: string = \"\";\n\n  /**\n   * @description The color of the subtitle text.\n   * @summary Specifies the color for the subtitle text using the application's color system.\n   * The value should correspond to a color variable defined in the application's theme.\n   * The component will automatically prefix this with \"color-\" to create the CSS class.\n   *\n   * @type {string}\n   * @default 'gray-4'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  subtitleColor: string = 'gray-4';\n\n  /**\n   * @description Controls whether the icon is displayed.\n   * @summary Determines if the visual icon should be shown in the empty state.\n   * This can be provided as a boolean or a string that will be converted to a boolean.\n   * Icons help visually communicate the empty state context to users.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  showIcon: StringOrBoolean = true;\n\n  /**\n   * @description The name of the icon to display.\n   * @summary Specifies which icon to show when showIcon is true.\n   * The component uses the icon system defined in the application,\n   * and this value should correspond to an available icon name.\n   *\n   * @type {string}\n   * @default \"ti-info-square-rounded\"\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  icon: string = \"ti-info-square-rounded\";\n\n  /**\n   * @description The size of the displayed icon.\n   * @summary Controls the size of the icon shown in the empty state.\n   * Can be either 'large' or 'small' to accommodate different layout needs.\n   *\n   * @type {'large' | 'small' | undefined}\n   * @default 'large'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  iconSize?: 'large' | 'small' = 'large';\n\n  /**\n   * @description The color of the displayed icon.\n   * @summary Specifies the color for the icon using Ionic's predefined color system.\n   * This allows the icon to match the application's color scheme.\n   *\n   * @type {PredefinedColors | undefined}\n   * @default 'medium'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  iconColor?: PredefinedColors = 'medium';\n\n  /**\n   * @description The navigation target or action for the button.\n   * @summary Specifies where the button should navigate to when clicked or what function\n   * it should execute. This can be either a URL string or a function that handles navigation.\n   * When not provided, the button will not perform any action.\n   *\n   * @type {string | FunctionLike | undefined}\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  buttonLink?: string | FunctionLike;\n\n  /**\n   * @description The text displayed on the action button.\n   * @summary Specifies the label for the action button in the empty state.\n   * If translatable is true, this will be processed through the localization system.\n   * If not provided, the button will not display any text.\n   *\n   * @type {string | undefined}\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  buttonText?: string;\n\n  /**\n   * @description The fill style of the action button.\n   * @summary Controls the visual style of the button using Ionic's button fill options.\n   * 'solid' creates a button with a solid background, 'outline' creates a button with\n   * just a border, and 'clear' creates a button with no background or border.\n   *\n   * @type {'clear' | 'solid' | 'outline'}\n   * @default 'solid'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  buttonFill: 'clear' | 'solid' | 'outline' =  'solid';\n\n  /**\n   * @description The color of the action button.\n   * @summary Specifies the color for the button using Ionic's color system.\n   * This allows the button to match the application's color scheme.\n   *\n   * @type {Color}\n   * @default 'primary'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  buttonColor: Color =  'primary';\n\n  /**\n   * @description The size of the action button.\n   * @summary Controls the size of the button shown in the empty state.\n   * Can be 'large', 'small', or 'default' to accommodate different layout needs.\n   *\n   * @type {'large' | 'small' | 'default'}\n   * @default 'default'\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  buttonSize: 'large' | 'small' | 'default' =  'default';\n\n  /**\n   * @description The search value that resulted in no results.\n   * @summary When the empty state is shown due to a search with no results,\n   * this property can hold the search term that was used. This can be displayed\n   * in the empty state message to provide context to the user.\n   *\n   * @type {string}\n   * @memberOf EmptyStateComponent\n   */\n  @Input()\n  searchValue!: string;\n\n  /**\n   * @description Service for handling navigation operations.\n   * @summary Injected service that provides methods for navigating between routes.\n   * This service is used when the buttonLink is a string URL to navigate to that location.\n   *\n   * @private\n   * @type {NavController}\n   * @memberOf EmptyStateComponent\n   */\n  private navController: NavController = inject(NavController);\n\n  private sanitizer: DomSanitizer = inject(DomSanitizer);\n\n  private translate: TranslateService = inject(TranslateService);\n\n  searchSubtitle!: SafeHtml\n\n\n  /**\n   * @description Creates an instance of EmptyStateComponent.\n   * @summary Initializes a new EmptyStateComponent by calling the parent class constructor\n   * with the component name for logging and identification purposes. This component provides\n   * a standardized way to display empty state messages with optional icons and action buttons.\n   *\n   * @memberOf EmptyStateComponent\n   */\n  constructor() {\n    super(\"EmptyStateComponent\");\n    addIcons(allIcons);\n  }\n\n  /**\n   * @description Initializes the component after Angular first displays the data-bound properties.\n   * @summary Sets up the component by processing boolean inputs, applying localization to text\n   * elements if translation is enabled, and formatting CSS classes for title and subtitle colors.\n   * This method prepares the component for user interaction by ensuring all properties are\n   * properly initialized and localized.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant E as EmptyStateComponent\n   *\n   *   A->>E: ngOnInit()\n   *   E->>E: Process translatable flag\n   *   E->>E: Process showIcon flag\n   *   E->>E: Get locale settings\n   *   alt translatable is true\n   *     E->>E: Localize title\n   *     E->>E: Localize subtitle\n   *     E->>E: Localize buttonText\n   *   end\n   *   E->>E: Format title CSS class\n   *   E->>E: Format subtitle CSS class\n   *\n   * @return {Promise<void>}\n   * @memberOf EmptyStateComponent\n   */\n  async ngOnInit(): Promise<void> {\n    this.parseProps(this);\n    this.translatable = stringToBoolean(this.translatable);\n    this.showIcon = stringToBoolean(this.showIcon);\n    this.locale = this.getLocale(this.translatable);\n\n    // if(this.translatable) {\n    //   this.title = generateLocaleFromString(this.locale, this.title);\n    //   this.subtitle = generateLocaleFromString(this.locale, this.subtitle);\n    //   this.buttonText = generateLocaleFromString(this.locale, this.buttonText);\n    // }\n\n    this.titleColor = `dcf-title color-${this.titleColor}`;\n    this.subtitleColor = `dcf-subtitle color-${this.titleColor}`;\n\n    if(this.searchValue && this.translatable)\n      this.searchSubtitle = await this.getSearchSubtitle(this.subtitle as string);\n  }\n\n  /**\n   * @description Handles click events on the action button.\n   * @summary This method is triggered when the user clicks the action button in the empty state\n   * component. It supports three navigation patterns: 1) no action when buttonLink is not provided,\n   * 2) custom function execution when buttonLink is a function, and 3) navigation to a specific URL\n   * when buttonLink is a string. This flexibility allows the empty state to trigger various actions\n   * based on the context in which it's used.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant E as EmptyStateComponent\n   *   participant N as NavController\n   *\n   *   U->>E: Click action button\n   *   E->>E: handleClick()\n   *   alt buttonLink is not provided\n   *     E-->>U: Return false (no action)\n   *   else buttonLink is a function\n   *     E->>E: Execute buttonLink function\n   *     E-->>U: Return function result\n   *   else buttonLink is a URL string\n   *     E->>N: navigateForward(buttonLink)\n   *     N-->>E: Return navigation result\n   *     E-->>U: Return navigation result\n   *   end\n   *\n   * @return {boolean | void | Promise<boolean>}\n   *   - false if no action is taken\n   *   - The result of the buttonLink function if it's a function\n   *   - A Promise resolving to the navigation result if buttonLink is a URL\n   * @memberOf EmptyStateComponent\n   */\n  handleClick(): boolean | void | Promise<boolean> {\n    const fn = this.buttonLink;\n    if(!fn)\n      return false;\n    if(fn instanceof Function)\n      return fn();\n    return this.navController.navigateForward(fn as string);\n  }\n\n\n /**\n   * @description Generates a localized and sanitized subtitle for search results.\n   * @summary This method takes a content string, typically the subtitle, and processes it\n   * through the translation service. It replaces a placeholder ('value0') with the actual\n   * search value, then sanitizes the result to safely use as HTML. This is particularly\n   * useful for displaying dynamic, localized messages in the empty state when a search\n   * yields no results.\n   *\n   * @param {string} content - The content string to be translated and processed\n   * @return {Promise<SafeHtml>} A promise that resolves to a sanitized HTML string\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant E as EmptyStateComponent\n   *   participant T as TranslateService\n   *   participant S as DomSanitizer\n   *\n   *   E->>T: instant(content, {'value0': searchValue})\n   *   T-->>E: Return translated string\n   *   E->>S: bypassSecurityTrustHtml(translatedString)\n   *   S-->>E: Return sanitized SafeHtml\n   *\n   * @memberOf EmptyStateComponent\n   */\n  async getSearchSubtitle(content: string): Promise<SafeHtml> {\n    const result = await this.translate.instant(content, {'value0': this.searchValue});\n    return this.sanitizer.bypassSecurityTrustHtml(result);\n  }\n}\n","\n<ion-card id=\"dcf-card-empty-state\" [ngClass]=\"className\">\n  <ion-card-content>\n    @if(icon && showIcon) {\n      <div class=\"dcf-icon-container\">\n        <ion-icon\n          name=\"alert-circle-outline\"\n          size=\"large\"\n          color=\"danger\"\n          />\n      </div>\n    }\n    @if(title) {\n      <h5 [class]=\"titleColor\" [innerHTML]=\"title\"></h5>\n    }\n    @if(subtitle) {\n      @if(!searchValue) {\n        <p [class]=\"subtitleColor\" [innerHTML]=\"subtitle\"></p>\n      } @else {\n        <p [class]=\"subtitleColor\" [innerHTML]=\"searchSubtitle\"></p>\n      }\n    }\n    @if(buttonLink && buttonText) {\n      <div>\n        <ion-button\n          [size]=\"buttonSize\"\n          [fill]=\"buttonFill\"\n          [color]=\"buttonColor\"\n          (click)=\"handleClick()\">\n          {{  buttonText }}\n        </ion-button>\n      </div>\n    }\n  </ion-card-content>\n</ion-card>\n"]}