flowbite-angular 0.0.2 → 1.0.0-alpha.1

package/esm2022/lib/components/form-field/directives/label.directive.theme.mjs

@@ -0,0 +1,51 @@
+import { createTheme } from '../../../utils/theme/create-theme';
+export const labelDirectiveTheme = createTheme({
+    base: 'block mb-2 text-sm font-medium',
+    default: 'text-gray-900 dark:text-white',
+    validation: {
+        success: 'text-green-700 dark:text-green-500',
+        error: 'text-red-700 dark:text-red-500',
+    },
+    floatingLabel: {
+        standard: {
+            base: 'absolute text-sm duration-300 transform -translate-y-6 scale-75 top-3 -z-10 origin-[0] peer-focus:left-0 peer-placeholder-shown:scale-100 peer-placeholder-shown:translate-y-0 peer-focus:scale-75 peer-focus:-translate-y-6',
+            default: 'text-gray-500 dark:text-gray-400 peer-focus:text-blue-600 peer-focus:dark:text-blue-500',
+            disabled: {
+                enabled: 'text-gray-400 dark:text-gray-500 peer-focus:text-blue-600 peer-focus:dark:text-blue-500',
+                disabled: '',
+            },
+            validation: {
+                success: 'text-green-600 dark:text-green-500',
+                error: 'text-red-600 dark:text-red-500',
+            },
+        },
+        outline: {
+            base: 'absolute text-sm duration-300 transform -translate-y-4 scale-75 top-2 z-10 origin-[0] px-2 peer-focus:px-2 peer-placeholder-shown:scale-100 peer-placeholder-shown:-translate-y-1/2 peer-placeholder-shown:top-1/2 peer-focus:top-2 peer-focus:scale-75 peer-focus:-translate-y-4 left-1',
+            default: 'text-gray-500 dark:text-gray-400 bg-white dark:bg-gray-900 peer-focus:text-blue-600 peer-focus:dark:text-blue-500',
+            disabled: {
+                enabled: 'text-gray-400 dark:text-gray-500 bg-white dark:bg-gray-900 peer-focus:text-blue-600 peer-focus:dark:text-blue-500',
+                disabled: '',
+            },
+            validation: {
+                success: 'text-green-600 dark:text-green-500 bg-white dark:bg-gray-900',
+                error: 'text-red-600 dark:text-red-500 bg-white dark:bg-gray-900',
+            },
+        },
+        fill: {
+            base: 'absolute text-sm duration-300 transform -translate-y-4 scale-75 top-4 z-10 origin-[0] left-2.5 peer-placeholder-shown:scale-100 peer-placeholder-shown:translate-y-0 peer-focus:scale-75 peer-focus:-translate-y-4',
+            default: 'text-gray-500 dark:text-gray-400 peer-focus:text-blue-600 peer-focus:dark:text-blue-500',
+            disabled: {
+                enabled: 'text-gray-400 dark:text-gray-500 peer-focus:text-blue-600 peer-focus:dark:text-blue-500',
+                disabled: '',
+            },
+            validation: {
+                success: 'text-green-600 dark:text-green-500',
+                error: 'text-red-600 dark:text-red-500',
+            },
+        },
+    },
+});
+export const labelDirectiveClassInstance = {
+    rootClass: '',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-field/directives/label.directive.theme.service.mjs

@@ -0,0 +1,21 @@
+import { mergeTheme } from '../../../utils/theme/merge-theme';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_DIRECTIVE_LABEL_THEME_TOKEN = new InjectionToken('FLOWBITE_DIRECTIVE_LABEL_THEME_TOKEN');
+export class LabelDirectiveThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_DIRECTIVE_LABEL_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(properties.floatingLabelType && theme.floatingLabel[properties.floatingLabelType].base, properties.floatingLabelType &&
+                properties.validate &&
+                theme.floatingLabel[properties.floatingLabelType].validation[properties.validate], properties.floatingLabelType &&
+                !properties.validate &&
+                theme.floatingLabel[properties.floatingLabelType].default, !properties.floatingLabelType && theme.base, !properties.floatingLabelType && properties.validate && theme.validation[properties.validate], !properties.floatingLabelType && !properties.validate && theme.default),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-field/form-field.component.mjs

@@ -0,0 +1,40 @@
+import { booleanToFlowbiteBoolean } from '../../utils/boolean.util';
+import { BaseComponent } from '../base-component.directive';
+import { FormFieldThemeService } from './form-field.theme.service';
+import { AsyncPipe, NgClass, NgIf, NgTemplateOutlet } from '@angular/common';
+import { Component, inject, model } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormFieldComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.themeService = inject(FormFieldThemeService);
+        //#region properties
+        this.type = model('text');
+        this.size = model('md');
+        this.isDisabled = model(false);
+        this.validate = model(undefined);
+        this.floatingLabelType = model(undefined);
+        this.prefix = model(undefined);
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            type: this.type(),
+            floatingLabelType: this.floatingLabelType(),
+            size: this.size(),
+            disabled: booleanToFlowbiteBoolean(this.isDisabled()),
+            validate: this.validate(),
+            prefix: this.prefix(),
+            customStyle: this.customStyle(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: FormFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.5", type: FormFieldComponent, isStandalone: true, selector: "flowbite-form-field", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, isDisabled: { classPropertyName: "isDisabled", publicName: "isDisabled", isSignal: true, isRequired: false, transformFunction: null }, validate: { classPropertyName: "validate", publicName: "validate", isSignal: true, isRequired: false, transformFunction: null }, floatingLabelType: { classPropertyName: "floatingLabelType", publicName: "floatingLabelType", isSignal: true, isRequired: false, transformFunction: null }, prefix: { classPropertyName: "prefix", publicName: "prefix", isSignal: true, isRequired: false, transformFunction: null }, customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { type: "typeChange", size: "sizeChange", isDisabled: "isDisabledChange", validate: "validateChange", floatingLabelType: "floatingLabelTypeChange", prefix: "prefixChange", customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"floatingLabelType(); else nonFloatingTemplate\">\n  <div\n    [ngClass]=\"{\n      relative: floatingLabelType(),\n      'z-0': floatingLabelType() === 'standard',\n    }\">\n    <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"labelTemplate\"></ng-container>\n  </div>\n  <ng-container *ngTemplateOutlet=\"hintTemplate\"></ng-container>\n</ng-container>\n<ng-template #nonFloatingTemplate>\n  <ng-container *ngTemplateOutlet=\"labelTemplate\"></ng-container>\n  <ng-container *ngIf=\"prefix(); else inputTemplate\">\n    <ng-container *ngIf=\"prefix() === 'icon'; else inputWithAddon\">\n      <div class=\"relative\">\n        <div class=\"pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3\">\n          <ng-container *ngTemplateOutlet=\"iconTemplate\"></ng-container>\n        </div>\n        <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\n      </div>\n    </ng-container>\n  </ng-container>\n  <ng-container *ngTemplateOutlet=\"hintTemplate\"></ng-container>\n</ng-template>\n\n<ng-template #inputWithAddon>\n  <div class=\"flex\">\n    <ng-container *ngTemplateOutlet=\"addonTemplate\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\n  </div>\n</ng-template>\n\n<ng-template #inputTemplate>\n  <ng-content select=\"input[flowbiteInput]\"></ng-content>\n</ng-template>\n<ng-template #labelTemplate>\n  <ng-content select=\"label[flowbiteLabel]\"></ng-content>\n</ng-template>\n<ng-template #hintTemplate>\n  <ng-content select=\"[flowbiteHelper]\"></ng-content>\n</ng-template>\n<ng-template #iconTemplate>\n  <ng-content select=\"[flowbiteIcon]\"></ng-content>\n</ng-template>\n<ng-template #addonTemplate>\n  <ng-content select=\"[flowbiteAddon]\"></ng-content>\n</ng-template>\n", dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: FormFieldComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [NgIf, NgClass, AsyncPipe, NgTemplateOutlet], selector: 'flowbite-form-field', template: "<ng-container *ngIf=\"floatingLabelType(); else nonFloatingTemplate\">\n  <div\n    [ngClass]=\"{\n      relative: floatingLabelType(),\n      'z-0': floatingLabelType() === 'standard',\n    }\">\n    <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"labelTemplate\"></ng-container>\n  </div>\n  <ng-container *ngTemplateOutlet=\"hintTemplate\"></ng-container>\n</ng-container>\n<ng-template #nonFloatingTemplate>\n  <ng-container *ngTemplateOutlet=\"labelTemplate\"></ng-container>\n  <ng-container *ngIf=\"prefix(); else inputTemplate\">\n    <ng-container *ngIf=\"prefix() === 'icon'; else inputWithAddon\">\n      <div class=\"relative\">\n        <div class=\"pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3\">\n          <ng-container *ngTemplateOutlet=\"iconTemplate\"></ng-container>\n        </div>\n        <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\n      </div>\n    </ng-container>\n  </ng-container>\n  <ng-container *ngTemplateOutlet=\"hintTemplate\"></ng-container>\n</ng-template>\n\n<ng-template #inputWithAddon>\n  <div class=\"flex\">\n    <ng-container *ngTemplateOutlet=\"addonTemplate\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"inputTemplate\"></ng-container>\n  </div>\n</ng-template>\n\n<ng-template #inputTemplate>\n  <ng-content select=\"input[flowbiteInput]\"></ng-content>\n</ng-template>\n<ng-template #labelTemplate>\n  <ng-content select=\"label[flowbiteLabel]\"></ng-content>\n</ng-template>\n<ng-template #hintTemplate>\n  <ng-content select=\"[flowbiteHelper]\"></ng-content>\n</ng-template>\n<ng-template #iconTemplate>\n  <ng-content select=\"[flowbiteIcon]\"></ng-content>\n</ng-template>\n<ng-template #addonTemplate>\n  <ng-content select=\"[flowbiteAddon]\"></ng-content>\n</ng-template>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-field/form-field.theme.mjs

@@ -0,0 +1,8 @@
+import { createTheme } from '../../utils/theme/create-theme';
+export const formFieldTheme = createTheme({
+    base: '',
+});
+export const FormFieldClassInstance = {
+    rootClass: '',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-field/form-field.theme.service.mjs

@@ -0,0 +1,17 @@
+import { mergeTheme } from '../../utils/theme/merge-theme';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_FORM_FIELD_THEME_TOKEN = new InjectionToken('FLOWBITE_FORM_FIELD_THEME_TOKEN');
+export class FormFieldThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_FORM_FIELD_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(theme.base),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-field/index.mjs

@@ -0,0 +1,5 @@
+export * from './directives';
+export { FormFieldComponent } from './form-field.component';
+export { FormFieldClassInstance, formFieldTheme } from './form-field.theme';
+export { FormFieldThemeService, FLOWBITE_FORM_FIELD_THEME_TOKEN } from './form-field.theme.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL2Zvcm0tZmllbGQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFFN0IsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFXNUQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzVFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSwrQkFBK0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzJztcblxuZXhwb3J0IHsgRm9ybUZpZWxkQ29tcG9uZW50IH0gZnJvbSAnLi9mb3JtLWZpZWxkLmNvbXBvbmVudCc7XG5leHBvcnQgdHlwZSB7XG4gIEZvcm1GaWVsZFByb3BlcnRpZXMsXG4gIEZvcm1GaWVsZEZsb2F0aW5nTGFiZWxUeXBlcyxcbiAgRm9ybUZpZWxkUHJlZml4ZXMsXG4gIEZvcm1GaWVsZFNpemVzLFxuICBGb3JtRmllbGRUeXBlcyxcbiAgRm9ybUZpZWxkVmFsaWRhdGlvbnMsXG4gIEZvcm1GaWVsZENsYXNzLFxuICBGb3JtRmllbGRCYXNlVGhlbWUsXG59IGZyb20gJy4vZm9ybS1maWVsZC50aGVtZSc7XG5leHBvcnQgeyBGb3JtRmllbGRDbGFzc0luc3RhbmNlLCBmb3JtRmllbGRUaGVtZSB9IGZyb20gJy4vZm9ybS1maWVsZC50aGVtZSc7XG5leHBvcnQgeyBGb3JtRmllbGRUaGVtZVNlcnZpY2UsIEZMT1dCSVRFX0ZPUk1fRklFTERfVEhFTUVfVE9LRU4gfSBmcm9tICcuL2Zvcm0tZmllbGQudGhlbWUuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/components/icon/icon-registry.mjs

@@ -0,0 +1,159 @@
+/**
+ * Thanks to Angular Material for Icon part of this library : https://github.com/angular/components
+ */
+import { trustedHTMLFromString } from './trusted-types';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { inject, Injectable, PLATFORM_ID, SecurityContext } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { finalize, map, of, share, tap, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+export function getSvgIconFromNamedError(iconName) {
+    return Error(`Unable to find icon with name ${iconName}`);
+}
+export function getSvgIconFailedToSanitizeRawError(raw) {
+    return Error(`The raw provided to IconRegistry was not trusted as safe HTML by ANGULAR's DOMSanitizer. Attempted raw was : ${raw}`);
+}
+export function getSvgIconFailedToSanitizeUrlError(url) {
+    return Error(`The URL provided to IconRegistry was not trusted as a resource URL via Angular's DOMSanitizer. Attempted URL was : ${url}`);
+}
+export function getSvgIconNoHttpClientProvidedError() {
+    return Error(`Could not fid HttpClient provider for use with flowbite-angular icons. Please include the HttpClientModule from @angular/common/http in your app imports`);
+}
+export class SvgIconConfig {
+    constructor(url, svgText, options) {
+        this.url = url;
+        this.svgText = svgText;
+        this.options = options;
+        this.svgElement = null;
+    }
+}
+export class IconRegistry {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this._httpClient = inject(HttpClient, { optional: true });
+        this._sanitizer = inject(DomSanitizer);
+        this._document = inject(DOCUMENT);
+        this._svgIconConfig = new Map();
+        this._cachedSvgIconByUrl = new Map();
+        this._inProgressSvgIconFetch = new Map();
+    }
+    addSvgIcon(iconName, url, options) {
+        return this.addSvgIconInNamespace('', iconName, url, options);
+    }
+    addRawSvgIcon(iconName, raw, options) {
+        return this.addRawSvgIconInNamepsace('', iconName, raw, options);
+    }
+    addSvgIconInNamespace(namespace, iconName, url, options) {
+        return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig(url, undefined, options));
+    }
+    addRawSvgIconInNamepsace(namespace, iconName, raw, options) {
+        const cleanRaw = this._sanitizer.sanitize(SecurityContext.HTML, raw);
+        if (!cleanRaw) {
+            throw getSvgIconFailedToSanitizeRawError(raw);
+        }
+        const trustedRaw = trustedHTMLFromString(cleanRaw);
+        return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig('', trustedRaw, options));
+    }
+    getSvgIconFromUrl(safeUrl) {
+        const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);
+        if (!url) {
+            throw getSvgIconFailedToSanitizeUrlError(safeUrl);
+        }
+        const cachedIcon = this._cachedSvgIconByUrl.get(url);
+        if (cachedIcon) {
+            return of(cloneSvg(cachedIcon));
+        }
+        return this._loadSvgIconFromConfig(new SvgIconConfig(safeUrl, undefined));
+    }
+    getSvgIconFromName(iconName, namespace) {
+        const key = iconKey(namespace, iconName);
+        const config = this._svgIconConfig.get(key);
+        if (config) {
+            return this._getSvgIconFromConfig(config);
+        }
+        return throwError(() => getSvgIconFromNamedError(key));
+    }
+    ngOnDestroy() {
+        this._svgIconConfig.clear();
+        this._cachedSvgIconByUrl.clear();
+    }
+    _addSvgIconConfig(namespace, iconName, config) {
+        this._svgIconConfig.set(iconKey(namespace, iconName), config);
+        return this;
+    }
+    _getSvgIconFromConfig(config) {
+        if (config.svgText) {
+            return of(cloneSvg(this._svgElementFromConfig(config)));
+        }
+        else {
+            return this._loadSvgIconFromConfig(config).pipe(map((svg) => cloneSvg(svg)));
+        }
+    }
+    _loadSvgIconFromConfig(config) {
+        return this._fetchIcon(config).pipe(tap((svgText) => (config.svgText = svgText)), map(() => this._svgElementFromConfig(config)));
+    }
+    _setSvgAttributes(svg, options) {
+        svg.setAttribute('fit', '');
+        svg.setAttribute('height', '100%');
+        svg.setAttribute('width', '100%');
+        svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
+        svg.setAttribute('focusable', 'false');
+        if (options?.viewBox) {
+            svg.setAttribute('viewBox', options.viewBox);
+        }
+        return svg;
+    }
+    _svgElementFromConfig(config) {
+        if (!config.svgElement) {
+            const svg = this._svgElementFromString(config.svgText);
+            this._setSvgAttributes(svg, config.options);
+            config.svgElement = svg;
+        }
+        return config.svgElement;
+    }
+    _svgElementFromString(str) {
+        const div = this._document.createElement('div');
+        div.innerHTML = str;
+        const svg = div.querySelector('svg');
+        return svg;
+    }
+    _fetchIcon(iconConfig) {
+        if (isPlatformBrowser(this.platformId)) {
+            if (!this._httpClient) {
+                throw getSvgIconNoHttpClientProvidedError();
+            }
+            const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, iconConfig.url);
+            if (!url) {
+                throw getSvgIconFailedToSanitizeUrlError(iconConfig.url);
+            }
+            const inProgressFetch = this._inProgressSvgIconFetch.get(url);
+            if (inProgressFetch) {
+                return inProgressFetch;
+            }
+            const req = this._httpClient.get(url, { responseType: 'text' }).pipe(map((svg) => {
+                return trustedHTMLFromString(svg);
+            }), finalize(() => this._inProgressSvgIconFetch.delete(url)), share());
+            this._inProgressSvgIconFetch.set(url, req);
+            return req;
+        }
+        else {
+            return of(trustedHTMLFromString('<svg></svg>'));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IconRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IconRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IconRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+function cloneSvg(svg) {
+    return svg.cloneNode(true);
+}
+function iconKey(namespace, iconName) {
+    return `${namespace}:${iconName}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon-registry.js","sourceRoot":"","sources":["../../../../../../../libs/flowbite-angular/src/lib/components/icon/icon-registry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Thanks to Angular Material for Icon part of this library : https://github.com/angular/components\n */\n\nimport { trustedHTMLFromString } from './trusted-types';\nimport type { TrustedHTML } from './trusted-types';\n\nimport { DOCUMENT, isPlatformBrowser } from '@angular/common';\nimport { HttpClient } from '@angular/common/http';\nimport type { OnDestroy } from '@angular/core';\nimport { inject, Injectable, PLATFORM_ID, SecurityContext } from '@angular/core';\nimport type { SafeHtml } from '@angular/platform-browser';\nimport { DomSanitizer, type SafeResourceUrl } from '@angular/platform-browser';\nimport { finalize, map, of, share, tap, throwError, type Observable } from 'rxjs';\n\nexport function getSvgIconFromNamedError(iconName: string): Error {\n  return Error(`Unable to find icon with name ${iconName}`);\n}\n\nexport function getSvgIconFailedToSanitizeRawError(raw: SafeHtml): Error {\n  return Error(\n    `The raw provided to IconRegistry was not trusted as safe HTML by ANGULAR's DOMSanitizer. Attempted raw was : ${raw as string}`,\n  );\n}\n\nexport function getSvgIconFailedToSanitizeUrlError(url: SafeResourceUrl): Error {\n  return Error(\n    `The URL provided to IconRegistry was not trusted as a resource URL via Angular's DOMSanitizer. Attempted URL was : ${url as string}`,\n  );\n}\n\nexport function getSvgIconNoHttpClientProvidedError(): Error {\n  return Error(\n    `Could not fid HttpClient provider for use with flowbite-angular icons. Please include the HttpClientModule from @angular/common/http in your app imports`,\n  );\n}\n\nexport interface SvgIconOptions {\n  viewBox: string;\n}\n\nexport class SvgIconConfig {\n  svgElement: SVGElement | null = null;\n\n  constructor(\n    public url: SafeResourceUrl,\n    public svgText: TrustedHTML | undefined,\n    public options?: SvgIconOptions,\n  ) {}\n}\n\ntype LoadedSvgIconConfig = SvgIconConfig & { svgText: TrustedHTML };\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IconRegistry implements OnDestroy {\n  private platformId = inject(PLATFORM_ID);\n\n  private _httpClient = inject(HttpClient, { optional: true });\n  private _sanitizer = inject(DomSanitizer);\n  private _document = inject(DOCUMENT);\n\n  private _svgIconConfig = new Map<string, SvgIconConfig>();\n  private _cachedSvgIconByUrl = new Map<string, SVGElement>();\n  private _inProgressSvgIconFetch = new Map<string, Observable<TrustedHTML>>();\n\n  public addSvgIcon(iconName: string, url: SafeResourceUrl, options?: SvgIconOptions): this {\n    return this.addSvgIconInNamespace('', iconName, url, options);\n  }\n\n  public addRawSvgIcon(iconName: string, raw: SafeHtml, options?: SvgIconOptions): this {\n    return this.addRawSvgIconInNamepsace('', iconName, raw, options);\n  }\n\n  public addSvgIconInNamespace(\n    namespace: string,\n    iconName: string,\n    url: SafeResourceUrl,\n    options?: SvgIconOptions,\n  ): this {\n    return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig(url, undefined, options));\n  }\n\n  public addRawSvgIconInNamepsace(namespace: string, iconName: string, raw: SafeHtml, options?: SvgIconOptions): this {\n    const cleanRaw = this._sanitizer.sanitize(SecurityContext.HTML, raw);\n\n    if (!cleanRaw) {\n      throw getSvgIconFailedToSanitizeRawError(raw);\n    }\n\n    const trustedRaw = trustedHTMLFromString(cleanRaw);\n    return this._addSvgIconConfig(namespace, iconName, new SvgIconConfig('', trustedRaw, options));\n  }\n\n  public getSvgIconFromUrl(safeUrl: SafeResourceUrl): Observable<SVGElement> {\n    const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, safeUrl);\n\n    if (!url) {\n      throw getSvgIconFailedToSanitizeUrlError(safeUrl);\n    }\n\n    const cachedIcon = this._cachedSvgIconByUrl.get(url);\n\n    if (cachedIcon) {\n      return of(cloneSvg(cachedIcon));\n    }\n\n    return this._loadSvgIconFromConfig(new SvgIconConfig(safeUrl, undefined));\n  }\n\n  public getSvgIconFromName(iconName: string, namespace: string): Observable<SVGElement> {\n    const key = iconKey(namespace, iconName);\n    const config = this._svgIconConfig.get(key);\n\n    if (config) {\n      return this._getSvgIconFromConfig(config);\n    }\n\n    return throwError(() => getSvgIconFromNamedError(key));\n  }\n\n  public ngOnDestroy(): void {\n    this._svgIconConfig.clear();\n    this._cachedSvgIconByUrl.clear();\n  }\n\n  private _addSvgIconConfig(namespace: string, iconName: string, config: SvgIconConfig): this {\n    this._svgIconConfig.set(iconKey(namespace, iconName), config);\n\n    return this;\n  }\n\n  private _getSvgIconFromConfig(config: SvgIconConfig): Observable<SVGElement> {\n    if (config.svgText) {\n      return of(cloneSvg(this._svgElementFromConfig(config as LoadedSvgIconConfig)));\n    } else {\n      return this._loadSvgIconFromConfig(config).pipe(map((svg) => cloneSvg(svg)));\n    }\n  }\n\n  private _loadSvgIconFromConfig(config: SvgIconConfig): Observable<SVGElement> {\n    return this._fetchIcon(config).pipe(\n      tap((svgText) => (config.svgText = svgText)),\n      map(() => this._svgElementFromConfig(config as LoadedSvgIconConfig)),\n    );\n  }\n\n  private _setSvgAttributes(svg: SVGElement, options?: SvgIconOptions): SVGElement {\n    svg.setAttribute('fit', '');\n    svg.setAttribute('height', '100%');\n    svg.setAttribute('width', '100%');\n    svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');\n    svg.setAttribute('focusable', 'false');\n\n    if (options?.viewBox) {\n      svg.setAttribute('viewBox', options.viewBox);\n    }\n\n    return svg;\n  }\n\n  private _svgElementFromConfig(config: LoadedSvgIconConfig): SVGElement {\n    if (!config.svgElement) {\n      const svg = this._svgElementFromString(config.svgText);\n\n      this._setSvgAttributes(svg, config.options);\n      config.svgElement = svg;\n    }\n\n    return config.svgElement;\n  }\n\n  private _svgElementFromString(str: TrustedHTML): SVGElement {\n    const div = this._document.createElement('div');\n    div.innerHTML = str as unknown as string;\n\n    const svg = div.querySelector('svg') as SVGElement;\n\n    return svg;\n  }\n\n  private _fetchIcon(iconConfig: SvgIconConfig): Observable<TrustedHTML> {\n    if (isPlatformBrowser(this.platformId)) {\n      if (!this._httpClient) {\n        throw getSvgIconNoHttpClientProvidedError();\n      }\n\n      const url = this._sanitizer.sanitize(SecurityContext.RESOURCE_URL, iconConfig.url);\n\n      if (!url) {\n        throw getSvgIconFailedToSanitizeUrlError(iconConfig.url);\n      }\n\n      const inProgressFetch = this._inProgressSvgIconFetch.get(url);\n\n      if (inProgressFetch) {\n        return inProgressFetch;\n      }\n\n      const req = this._httpClient.get(url, { responseType: 'text' }).pipe(\n        map((svg) => {\n          return trustedHTMLFromString(svg);\n        }),\n        finalize(() => this._inProgressSvgIconFetch.delete(url)),\n        share(),\n      );\n\n      this._inProgressSvgIconFetch.set(url, req);\n      return req;\n    } else {\n      return of(trustedHTMLFromString('<svg></svg>'));\n    }\n  }\n}\n\nfunction cloneSvg(svg: SVGElement): SVGElement {\n  return svg.cloneNode(true) as SVGElement;\n}\n\nfunction iconKey(namespace: string, iconName: string): string {\n  return `${namespace}:${iconName}`;\n}\n"]}

package/esm2022/lib/components/icon/icon.component.mjs

@@ -0,0 +1,67 @@
+import { BaseComponent } from '../base-component.directive';
+import { IconRegistry } from './icon-registry';
+import { Component, effect, ElementRef, inject, model } from '@angular/core';
+import { take } from 'rxjs';
+import * as i0 from "@angular/core";
+export class IconComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this._elementRef = inject((ElementRef));
+        this._iconRegistry = inject(IconRegistry);
+        this.svgIcon = model.required();
+    }
+    init() {
+        effect(() => {
+            this._updateSvgIcon();
+        }, { injector: this.injector });
+    }
+    fetchClass() {
+        return { rootClass: '' };
+    }
+    _splitIconName(iconName) {
+        if (!iconName) {
+            return ['', ''];
+        }
+        const parts = iconName.split(':');
+        switch (parts.length) {
+            case 1:
+                return ['', parts[0]];
+            case 2:
+                return parts;
+            default:
+                throw Error(`Invalid icon name: "${iconName}"`);
+        }
+    }
+    _updateSvgIcon() {
+        const [namespace, iconName] = this._splitIconName(this.svgIcon());
+        this._iconRegistry
+            .getSvgIconFromName(iconName, namespace)
+            .pipe(take(1))
+            .subscribe((svg) => this._setSvgElement(svg));
+    }
+    _setSvgElement(svg) {
+        this._clearSvgElements();
+        this._elementRef.nativeElement.appendChild(svg);
+    }
+    _clearSvgElements() {
+        const layoutElement = this._elementRef.nativeElement;
+        let childCount = layoutElement.childNodes.length;
+        while (childCount--) {
+            const child = layoutElement.childNodes[childCount];
+            if (child.nodeType !== 1 || child.nodeName.toLowerCase() === 'svg') {
+                child.remove();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IconComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.5", type: IconComponent, isStandalone: true, selector: "flowbite-icon", inputs: { svgIcon: { classPropertyName: "svgIcon", publicName: "svgIcon", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { svgIcon: "svgIconChange" }, usesInheritance: true, ngImport: i0, template: `<ng-content />`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IconComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'flowbite-icon',
+                    standalone: true,
+                    template: `<ng-content />`,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/icon/index.mjs

@@ -0,0 +1,4 @@
+export { IconComponent } from './icon.component';
+export { IconRegistry, SvgIconConfig, getSvgIconFailedToSanitizeRawError, getSvgIconFailedToSanitizeUrlError, getSvgIconFromNamedError, getSvgIconNoHttpClientProvidedError, } from './icon-registry';
+export { trustedHTMLFromString } from './trusted-types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL2ljb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELE9BQU8sRUFDTCxZQUFZLEVBQ1osYUFBYSxFQUNiLGtDQUFrQyxFQUNsQyxrQ0FBa0MsRUFDbEMsd0JBQXdCLEVBQ3hCLG1DQUFtQyxHQUNwQyxNQUFNLGlCQUFpQixDQUFDO0FBRXpCLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgSWNvbkNvbXBvbmVudCB9IGZyb20gJy4vaWNvbi5jb21wb25lbnQnO1xuZXhwb3J0IHR5cGUgeyBTdmdJY29uT3B0aW9ucyB9IGZyb20gJy4vaWNvbi1yZWdpc3RyeSc7XG5leHBvcnQge1xuICBJY29uUmVnaXN0cnksXG4gIFN2Z0ljb25Db25maWcsXG4gIGdldFN2Z0ljb25GYWlsZWRUb1Nhbml0aXplUmF3RXJyb3IsXG4gIGdldFN2Z0ljb25GYWlsZWRUb1Nhbml0aXplVXJsRXJyb3IsXG4gIGdldFN2Z0ljb25Gcm9tTmFtZWRFcnJvcixcbiAgZ2V0U3ZnSWNvbk5vSHR0cENsaWVudFByb3ZpZGVkRXJyb3IsXG59IGZyb20gJy4vaWNvbi1yZWdpc3RyeSc7XG5leHBvcnQgdHlwZSB7IFRydXN0ZWRIVE1MLCBUcnVzdGVkVHlwZVBvbGljeSwgVHJ1c3RlZFR5cGVQb2xpY3lGYWN0b3J5IH0gZnJvbSAnLi90cnVzdGVkLXR5cGVzJztcbmV4cG9ydCB7IHRydXN0ZWRIVE1MRnJvbVN0cmluZyB9IGZyb20gJy4vdHJ1c3RlZC10eXBlcyc7XG4iXX0=

package/esm2022/lib/components/icon/trusted-types.mjs

@@ -0,0 +1,21 @@
+/**
+ * Thanks to Angular Material for Icon part of this library : https://github.com/angular/components
+ */
+let policy;
+function getPolicy() {
+    if (!policy) {
+        if (typeof window !== 'undefined') {
+            const tWindow = window;
+            if (tWindow.trustedTypes !== undefined) {
+                policy = tWindow.trustedTypes.createPolicy('angular#components', {
+                    createHTML: (s) => s,
+                });
+            }
+        }
+    }
+    return policy;
+}
+export function trustedHTMLFromString(raw) {
+    return getPolicy()?.createHTML(raw) || raw;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3RlZC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZmxvd2JpdGUtYW5ndWxhci9zcmMvbGliL2NvbXBvbmVudHMvaWNvbi90cnVzdGVkLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBbUJILElBQUksTUFBcUMsQ0FBQztBQUUxQyxTQUFTLFNBQVM7SUFDaEIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osSUFBSSxPQUFPLE1BQU0sS0FBSyxXQUFXLEVBQUUsQ0FBQztZQUNsQyxNQUFNLE9BQU8sR0FBRyxNQUFnRSxDQUFDO1lBRWpGLElBQUksT0FBTyxDQUFDLFlBQVksS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDdkMsTUFBTSxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUFDLG9CQUFvQixFQUFFO29CQUMvRCxVQUFVLEVBQUUsQ0FBQyxDQUFTLEVBQUUsRUFBRSxDQUFDLENBQUM7aUJBQzdCLENBQUMsQ0FBQztZQUNMLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRCxNQUFNLFVBQVUscUJBQXFCLENBQUMsR0FBVztJQUMvQyxPQUFPLFNBQVMsRUFBRSxFQUFFLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSyxHQUE4QixDQUFDO0FBQ3pFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoYW5rcyB0byBBbmd1bGFyIE1hdGVyaWFsIGZvciBJY29uIHBhcnQgb2YgdGhpcyBsaWJyYXJ5IDogaHR0cHM6Ly9naXRodWIuY29tL2FuZ3VsYXIvY29tcG9uZW50c1xuICovXG5cbmV4cG9ydCBkZWNsYXJlIGludGVyZmFjZSBUcnVzdGVkSFRNTCB7XG4gIF9fYnJhbmRfXzogJ1RydXN0ZWRIVE1MJztcbn1cblxuZXhwb3J0IGRlY2xhcmUgaW50ZXJmYWNlIFRydXN0ZWRUeXBlUG9saWN5RmFjdG9yeSB7XG4gIGNyZWF0ZVBvbGljeShcbiAgICBwb2xpY3lOYW1lOiBzdHJpbmcsXG4gICAgcG9saWN5T3B0aW9uczoge1xuICAgICAgY3JlYXRlSFRNTD86IChpbnB1dDogc3RyaW5nKSA9PiBzdHJpbmc7XG4gICAgfSxcbiAgKTogVHJ1c3RlZFR5cGVQb2xpY3k7XG59XG5cbmV4cG9ydCBkZWNsYXJlIGludGVyZmFjZSBUcnVzdGVkVHlwZVBvbGljeSB7XG4gIGNyZWF0ZUhUTUwoaW5wdXQ6IHN0cmluZyk6IFRydXN0ZWRIVE1MO1xufVxuXG5sZXQgcG9saWN5OiBUcnVzdGVkVHlwZVBvbGljeSB8IHVuZGVmaW5lZDtcblxuZnVuY3Rpb24gZ2V0UG9saWN5KCk6IFRydXN0ZWRUeXBlUG9saWN5IHwgdW5kZWZpbmVkIHtcbiAgaWYgKCFwb2xpY3kpIHtcbiAgICBpZiAodHlwZW9mIHdpbmRvdyAhPT0gJ3VuZGVmaW5lZCcpIHtcbiAgICAgIGNvbnN0IHRXaW5kb3cgPSB3aW5kb3cgYXMgdW5rbm93biBhcyB7IHRydXN0ZWRUeXBlcz86IFRydXN0ZWRUeXBlUG9saWN5RmFjdG9yeSB9O1xuXG4gICAgICBpZiAodFdpbmRvdy50cnVzdGVkVHlwZXMgIT09IHVuZGVmaW5lZCkge1xuICAgICAgICBwb2xpY3kgPSB0V2luZG93LnRydXN0ZWRUeXBlcy5jcmVhdGVQb2xpY3koJ2FuZ3VsYXIjY29tcG9uZW50cycsIHtcbiAgICAgICAgICBjcmVhdGVIVE1MOiAoczogc3RyaW5nKSA9PiBzLFxuICAgICAgICB9KTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICByZXR1cm4gcG9saWN5O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gdHJ1c3RlZEhUTUxGcm9tU3RyaW5nKHJhdzogc3RyaW5nKTogVHJ1c3RlZEhUTUwge1xuICByZXR1cm4gZ2V0UG9saWN5KCk/LmNyZWF0ZUhUTUwocmF3KSB8fCAocmF3IGFzIHVua25vd24gYXMgVHJ1c3RlZEhUTUwpO1xufVxuIl19

package/esm2022/lib/components/index.mjs

@@ -0,0 +1,16 @@
+export * from './accordion';
+export * from './alert';
+export * from './badge';
+export * from './breadcrumb';
+export * from './button';
+export * from './dark-theme-toggle';
+export * from './dropdown';
+export * from './form-field';
+export * from './icon';
+export * from './indicators';
+export * from './modal';
+export * from './navbar';
+export * from './scroll-top';
+export * from './sidebar';
+export { BaseComponent } from './base-component.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFFMUIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hY2NvcmRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9hbGVydCc7XG5leHBvcnQgKiBmcm9tICcuL2JhZGdlJztcbmV4cG9ydCAqIGZyb20gJy4vYnJlYWRjcnVtYic7XG5leHBvcnQgKiBmcm9tICcuL2J1dHRvbic7XG5leHBvcnQgKiBmcm9tICcuL2RhcmstdGhlbWUtdG9nZ2xlJztcbmV4cG9ydCAqIGZyb20gJy4vZHJvcGRvd24nO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWZpZWxkJztcbmV4cG9ydCAqIGZyb20gJy4vaWNvbic7XG5leHBvcnQgKiBmcm9tICcuL2luZGljYXRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RhbCc7XG5leHBvcnQgKiBmcm9tICcuL25hdmJhcic7XG5leHBvcnQgKiBmcm9tICcuL3Njcm9sbC10b3AnO1xuZXhwb3J0ICogZnJvbSAnLi9zaWRlYmFyJztcblxuZXhwb3J0IHsgQmFzZUNvbXBvbmVudCB9IGZyb20gJy4vYmFzZS1jb21wb25lbnQuZGlyZWN0aXZlJzsiXX0=

package/esm2022/lib/components/indicators/index.mjs

@@ -0,0 +1,4 @@
+export { IndicatorComponent } from './indicators.component';
+export { indicatorTheme } from './indicators.theme';
+export { FLOWBITE_INDICATOR_THEME_TOKEN, IndicatorThemeService } from './indicators.theme.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL2luZGljYXRvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFTNUQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3BELE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgSW5kaWNhdG9yQ29tcG9uZW50IH0gZnJvbSAnLi9pbmRpY2F0b3JzLmNvbXBvbmVudCc7XG5leHBvcnQgdHlwZSB7XG4gIEluZGljYXRvclByb3BlcnRpZXMsXG4gIGluZGljYXRvckNsYXNzLFxuICBJbmRpY2F0b3JDb2xvcnMsXG4gIEluZGljYXRvclRoZW1lLFxuICBJbmRpY2F0b3JQb3NpdGlvbnMsXG4gIEluZGljYXRvclNpemVzLFxufSBmcm9tICcuL2luZGljYXRvcnMudGhlbWUnO1xuZXhwb3J0IHsgaW5kaWNhdG9yVGhlbWUgfSBmcm9tICcuL2luZGljYXRvcnMudGhlbWUnO1xuZXhwb3J0IHsgRkxPV0JJVEVfSU5ESUNBVE9SX1RIRU1FX1RPS0VOLCBJbmRpY2F0b3JUaGVtZVNlcnZpY2UgfSBmcm9tICcuL2luZGljYXRvcnMudGhlbWUuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/components/indicators/indicators.component.mjs

@@ -0,0 +1,54 @@
+import { booleanToFlowbiteBoolean } from '../../utils/boolean.util';
+import { BaseComponent } from '../base-component.directive';
+import { IndicatorThemeService } from './indicators.theme.service';
+import { NgClass } from '@angular/common';
+import { Component, inject, model } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/indicators/
+ */
+export class IndicatorComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.themeService = inject(IndicatorThemeService);
+        //#region properties
+        this.isPill = model(false);
+        this.isOutline = model(false);
+        this.isDisabled = model(false);
+        this.hasOffset = model(false);
+        this.isRounded = model(false);
+        this.hasBorder = model(false);
+        this.color = model('primary');
+        this.size = model('md');
+        this.placement = model(undefined);
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            hasBorder: booleanToFlowbiteBoolean(this.hasBorder()),
+            color: this.color(),
+            isDisabled: booleanToFlowbiteBoolean(this.isDisabled()),
+            hasOffset: booleanToFlowbiteBoolean(this.hasOffset()),
+            isOutline: booleanToFlowbiteBoolean(this.isOutline()),
+            isPill: booleanToFlowbiteBoolean(this.isPill()),
+            isRounded: booleanToFlowbiteBoolean(this.isRounded()),
+            size: this.size(),
+            placement: this.placement(),
+            customStyle: this.customStyle(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IndicatorComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.5", type: IndicatorComponent, isStandalone: true, selector: "flowbite-indicator", inputs: { isPill: { classPropertyName: "isPill", publicName: "isPill", isSignal: true, isRequired: false, transformFunction: null }, isOutline: { classPropertyName: "isOutline", publicName: "isOutline", isSignal: true, isRequired: false, transformFunction: null }, isDisabled: { classPropertyName: "isDisabled", publicName: "isDisabled", isSignal: true, isRequired: false, transformFunction: null }, hasOffset: { classPropertyName: "hasOffset", publicName: "hasOffset", isSignal: true, isRequired: false, transformFunction: null }, isRounded: { classPropertyName: "isRounded", publicName: "isRounded", isSignal: true, isRequired: false, transformFunction: null }, hasBorder: { classPropertyName: "hasBorder", publicName: "hasBorder", isSignal: true, isRequired: false, transformFunction: null }, color: { classPropertyName: "color", publicName: "color", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, placement: { classPropertyName: "placement", publicName: "placement", isSignal: true, isRequired: false, transformFunction: null }, customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { isPill: "isPillChange", isOutline: "isOutlineChange", isDisabled: "isDisabledChange", hasOffset: "hasOffsetChange", isRounded: "isRoundedChange", hasBorder: "hasBorderChange", color: "colorChange", size: "sizeChange", placement: "placementChange", customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: `<ng-content />`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: IndicatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [NgClass],
+                    selector: 'flowbite-indicator',
+                    template: `<ng-content />`,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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