flowbite-angular 1.0.0-alpha.2 → 1.0.0-alpha.3

package/esm2022/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.0.0", ngImport: i0, type: IconRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: IconRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", 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/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(\n    namespace: string,\n    iconName: string,\n    raw: SafeHtml,\n    options?: SvgIconOptions\n  ): 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/icon/icon.component.mjs

@@ -0,0 +1,72 @@
+/**
+ * Thanks to Angular Material for Icon part of this library : https://github.com/angular/components
+ */
+import { IconRegistry } from './icon-registry';
+import { BaseComponent } from 'flowbite-angular';
+import { ChangeDetectionStrategy, Component, effect, ElementRef, inject, model, ViewEncapsulation, } 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.0.0", ngImport: i0, type: IconComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", 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, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: IconComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'flowbite-icon',
+                    standalone: true,
+                    template: `<ng-content />`,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvaWNvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFakQsT0FBTyxFQUNMLFlBQVksRUFDWixhQUFhLEVBQ2Isa0NBQWtDLEVBQ2xDLGtDQUFrQyxFQUNsQyx3QkFBd0IsRUFDeEIsbUNBQW1DLEdBQ3BDLE1BQU0saUJBQWlCLENBQUM7QUFFekIsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBJY29uQ29tcG9uZW50IH0gZnJvbSAnLi9pY29uLmNvbXBvbmVudCc7XG5leHBvcnQgdHlwZSB7IFN2Z0ljb25PcHRpb25zIH0gZnJvbSAnLi9pY29uLXJlZ2lzdHJ5JztcbmV4cG9ydCB7XG4gIEljb25SZWdpc3RyeSxcbiAgU3ZnSWNvbkNvbmZpZyxcbiAgZ2V0U3ZnSWNvbkZhaWxlZFRvU2FuaXRpemVSYXdFcnJvcixcbiAgZ2V0U3ZnSWNvbkZhaWxlZFRvU2FuaXRpemVVcmxFcnJvcixcbiAgZ2V0U3ZnSWNvbkZyb21OYW1lZEVycm9yLFxuICBnZXRTdmdJY29uTm9IdHRwQ2xpZW50UHJvdmlkZWRFcnJvcixcbn0gZnJvbSAnLi9pY29uLXJlZ2lzdHJ5JztcbmV4cG9ydCB0eXBlIHsgVHJ1c3RlZEhUTUwsIFRydXN0ZWRUeXBlUG9saWN5LCBUcnVzdGVkVHlwZVBvbGljeUZhY3RvcnkgfSBmcm9tICcuL3RydXN0ZWQtdHlwZXMnO1xuZXhwb3J0IHsgdHJ1c3RlZEhUTUxGcm9tU3RyaW5nIH0gZnJvbSAnLi90cnVzdGVkLXR5cGVzJztcbiJdfQ==

package/esm2022/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,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

package/esm2022/index.mjs

@@ -0,0 +1,4 @@
+export * from './type-definitions';
+export { FlowbiteThemeService } from './flowbite.theme.service';
+export { BaseComponent } from './base-component.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvY29tbW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDaEUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90eXBlLWRlZmluaXRpb25zJztcbmV4cG9ydCB7IEZsb3diaXRlVGhlbWVTZXJ2aWNlIH0gZnJvbSAnLi9mbG93Yml0ZS50aGVtZS5zZXJ2aWNlJztcbmV4cG9ydCB7IEJhc2VDb21wb25lbnQgfSBmcm9tICcuL2Jhc2UtY29tcG9uZW50LmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/indicator/flowbite-angular-indicator.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvd2JpdGUtYW5ndWxhci1pbmRpY2F0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvaW5kaWNhdG9yL2Zsb3diaXRlLWFuZ3VsYXItaW5kaWNhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/indicator/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvaW5kaWNhdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBUzVELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsOEJBQThCLEVBQUUscUJBQXFCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEluZGljYXRvckNvbXBvbmVudCB9IGZyb20gJy4vaW5kaWNhdG9ycy5jb21wb25lbnQnO1xuZXhwb3J0IHR5cGUge1xuICBJbmRpY2F0b3JQcm9wZXJ0aWVzLFxuICBpbmRpY2F0b3JDbGFzcyxcbiAgSW5kaWNhdG9yQ29sb3JzLFxuICBJbmRpY2F0b3JUaGVtZSxcbiAgSW5kaWNhdG9yUG9zaXRpb25zLFxuICBJbmRpY2F0b3JTaXplcyxcbn0gZnJvbSAnLi9pbmRpY2F0b3JzLnRoZW1lJztcbmV4cG9ydCB7IGluZGljYXRvclRoZW1lIH0gZnJvbSAnLi9pbmRpY2F0b3JzLnRoZW1lJztcbmV4cG9ydCB7IEZMT1dCSVRFX0lORElDQVRPUl9USEVNRV9UT0tFTiwgSW5kaWNhdG9yVGhlbWVTZXJ2aWNlIH0gZnJvbSAnLi9pbmRpY2F0b3JzLnRoZW1lLnNlcnZpY2UnO1xuIl19

package/esm2022/indicator/indicators.component.mjs

@@ -0,0 +1,55 @@
+import { IndicatorThemeService } from './indicators.theme.service';
+import { BaseComponent, booleanToFlowbiteBoolean } from 'flowbite-angular';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } 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.0.0", ngImport: i0, type: IndicatorComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", 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, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: IndicatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [NgClass],
+                    selector: 'flowbite-indicator',
+                    template: `<ng-content />`,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/indicator/indicators.theme.mjs

@@ -0,0 +1,68 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const indicatorTheme = createTheme({
+    root: {
+        base: 'inline-flex items-center justify-center shrink-0 font-bold',
+        hasBorder: {
+            enabled: 'border-2',
+            disabled: '',
+        },
+        color: {
+            dark: 'bg-gray-900 dark:bg-gray-700 border-white dark:border-gray-800 text-white',
+            primary: 'bg-primary-500 border-white dark:border-gray-800 text-white',
+            gray: 'bg-gray-200 border-white dark:border-gray-800 text-gray-900',
+            blue: 'bg-blue-600 border-white dark:border-gray-800 text-white',
+            green: 'bg-green-500 border-white dark:border-gray-800 text-white',
+            red: 'bg-red-500 border-white dark:border-gray-800 text-white',
+            purple: 'bg-purple-500 border-white dark:border-gray-800 text-white',
+            indigo: 'bg-indigo-500 border-white dark:border-gray-800 text-white',
+            yellow: 'bg-yellow-300 border-white dark:border-gray-800 text-gray-900',
+            teal: 'bg-teal-500 border-white dark:border-gray-800 text-white',
+        },
+        isDisabled: {
+            enabled: 'opacity-50',
+            disabled: '',
+        },
+        hasOffset: {
+            'top-left': '-translate-x-1/3 -translate-y-1/3',
+            'top-center': '-translate-y-1/3',
+            'top-right': 'translate-x-1/3 -translate-y-1/3',
+            'center-left': '-translate-x-1/3',
+            center: '',
+            'center-right': 'translate-x-1/3',
+            'bottom-left': '-translate-x-1/3 translate-y-1/3',
+            'bottom-center': 'translate-y-1/3',
+            'bottom-right': 'translate-x-1/3 translate-y-1/3',
+        },
+        placement: {
+            'top-left': 'top-0 left-0',
+            'top-center': 'top-0 left-1/2 -translate-x-1/2',
+            'top-right': 'top-0 right-0',
+            'center-left': 'top-1/2 -translate-y-1/2 left-0',
+            center: 'top-1/2 -translate-y-1/2 left-1/2 -translate-x-1/2',
+            'center-right': 'top-1/2 -translate-y-1/2 right-0',
+            'bottom-left': 'bottom-0 left-0',
+            'bottom-center': 'bottom-0 left-1/2 -translate-x-1/2',
+            'bottom-right': 'bottom-0 right-0',
+        },
+        isOutline: {
+            enabled: '',
+            disabled: '',
+        },
+        isPill: {
+            enabled: '',
+            disabled: '',
+        },
+        isRounded: {
+            enabled: 'rounded',
+            disabled: 'rounded-full',
+        },
+        size: {
+            xs: 'w-2 h-2 text-xs',
+            sm: 'w-2.5 h-2.5 text-sm',
+            md: 'w-3 h-3 text-sm',
+            lg: 'w-3.5 h-3.5 text-sm',
+            xl: 'w-6 h-6 text-sm',
+        },
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/indicator/indicators.theme.service.mjs

@@ -0,0 +1,19 @@
+import { mergeTheme } from 'flowbite-angular/utils';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_INDICATOR_THEME_TOKEN = new InjectionToken('FLOWBITE_INDICATOR_THEME_TOKEN');
+export class IndicatorThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_INDICATOR_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(theme.root.base, theme.root.hasBorder[properties.hasBorder], theme.root.color[properties.color], theme.root.isDisabled[properties.isDisabled], properties.placement &&
+                properties.hasOffset == 'enabled' &&
+                theme.root.hasOffset[properties.placement], theme.root.isOutline[properties.isOutline], theme.root.isPill[properties.isPill], properties.placement && 'absolute ' + theme.root.placement[properties.placement], theme.root.isRounded[properties.isRounded], theme.root.size[properties.size]),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/flowbite-angular-modal.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvd2JpdGUtYW5ndWxhci1tb2RhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvZmxvd2JpdGUtYW5ndWxhci9tb2RhbC9mbG93Yml0ZS1hbmd1bGFyLW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/modal/index.mjs

@@ -0,0 +1,13 @@
+export { ModalComponent } from './modal.component';
+export { modalTheme } from './modal.theme';
+export { FLOWBITE_MODAL_THEME_TOKEN, ModalThemeService } from './modal.theme.service';
+export { ModalHeaderComponent } from './modal-header.component';
+export { modalHeaderTheme } from './modal-header.theme';
+export { FLOWBITE_MODAL_HEADER_THEME_TOKEN, ModalHeaderThemeService, } from './modal-header.theme.service';
+export { ModalBodyComponent } from './modal-body.component';
+export { modalBodyTheme } from './modal-body.theme';
+export { FLOWBITE_MODAL_BODY_THEME_TOKEN, ModalBodyThemeService } from './modal-body.theme.service';
+export { ModalFooterComponent } from './modal-footer.component';
+export { modalFooterTheme } from './modal-footer.theme';
+export { FLOWBITE_MODAL_FOOTER_THEME_TOKEN, ModalFooterThemeService, } from './modal-footer.theme.service';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal-body.component.mjs

@@ -0,0 +1,36 @@
+import { ModalBodyThemeService } from './modal-body.theme.service';
+import { ModalComponent } from './modal.component';
+import { BaseComponent } from 'flowbite-angular';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ModalBodyComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.themeService = inject(ModalBodyThemeService);
+        this.modalComponent = inject(ModalComponent);
+        //#region properties
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            customStyle: this.customStyle(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalBodyComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", type: ModalBodyComponent, isStandalone: true, selector: "flowbite-modal-body", inputs: { customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalBodyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [NgClass],
+                    selector: 'flowbite-modal-body',
+                    template: `<ng-content />`,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal-body.theme.mjs

@@ -0,0 +1,7 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const modalBodyTheme = createTheme({
+    root: {
+        base: 'block p-6 space-y-6',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtYm9keS50aGVtZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvZmxvd2JpdGUtYW5ndWxhci9tb2RhbC9tb2RhbC1ib2R5LnRoZW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQVlyRCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQW1CLFdBQVcsQ0FBQztJQUN4RCxJQUFJLEVBQUU7UUFDSixJQUFJLEVBQUUscUJBQXFCO0tBQzVCO0NBQ0YsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEZWVwUGFydGlhbCwgRmxvd2JpdGVDbGFzcyB9IGZyb20gJ2Zsb3diaXRlLWFuZ3VsYXInO1xuaW1wb3J0IHsgY3JlYXRlVGhlbWUgfSBmcm9tICdmbG93Yml0ZS1hbmd1bGFyL3V0aWxzJztcblxuZXhwb3J0IGludGVyZmFjZSBNb2RhbEJvZHlQcm9wZXJ0aWVzIHtcbiAgY3VzdG9tU3R5bGU6IERlZXBQYXJ0aWFsPE1vZGFsQm9keVRoZW1lPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBNb2RhbEJvZHlUaGVtZSB7XG4gIHJvb3Q6IHtcbiAgICBiYXNlOiBzdHJpbmc7XG4gIH07XG59XG5cbmV4cG9ydCBjb25zdCBtb2RhbEJvZHlUaGVtZTogTW9kYWxCb2R5VGhlbWUgPSBjcmVhdGVUaGVtZSh7XG4gIHJvb3Q6IHtcbiAgICBiYXNlOiAnYmxvY2sgcC02IHNwYWNlLXktNicsXG4gIH0sXG59KTtcblxuZXhwb3J0IHR5cGUgTW9kYWxCb2R5Q2xhc3MgPSBGbG93Yml0ZUNsYXNzO1xuIl19

package/esm2022/modal/modal-body.theme.service.mjs

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