@design-factory/design-factory 15.2.0

package/esm2022/lib/angular/mediaqueries/media.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { distinctUntilChanged, map, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./mediaUtils.service";
+/**
+ * Services you can use to get indication about the current width screen of your application
+ * the matchMedia JS feature (https://developer.mozilla.org/fr/docs/Web/API/Window/matchMedia)
+ */
+export class DfMedia {
+    constructor(mediaObserver, _breakPointsService) {
+        this.mediaObserver = mediaObserver;
+        this._breakPointsService = _breakPointsService;
+    }
+    initQueries(mediaOrBreakpoints, breakPoints = {}) {
+        const queries = [];
+        if (Array.isArray(mediaOrBreakpoints)) {
+            for (const el of mediaOrBreakpoints) {
+                queries.push(breakPoints[el] ? breakPoints[el] : el);
+            }
+        }
+        else {
+            queries.push(breakPoints[mediaOrBreakpoints] ? breakPoints[mediaOrBreakpoints] : mediaOrBreakpoints);
+        }
+        return queries;
+    }
+    /**
+     * Getter to have the observable indication if you are or not in the current scope of your queries
+     * If one queries is matching result is `True` otherwise result is `False`
+     * @param mediaOrBreakpoints either media query string/Array of string or/and in case of BS usage a
+     * string/Array of string of the breakpoints name (sm...).
+     */
+    getObservable(mediaOrBreakpoints) {
+        return this._breakPointsService.breakPoints$.pipe(map(breakpoints => {
+            return breakpoints ? this.initQueries(mediaOrBreakpoints, breakpoints) : this.initQueries(mediaOrBreakpoints);
+        }), switchMap(query => {
+            return this.mediaObserver.observe(query);
+        }), map(value => value.matches), distinctUntilChanged());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMedia, deps: [{ token: i1.DfMediaObserver }, { token: i1.DfBreakpoints }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMedia, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMedia, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.DfMediaObserver }, { type: i1.DfBreakpoints }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/mediaqueries/mediaUtils.service.mjs

@@ -0,0 +1,185 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Inject, Injectable, InjectionToken, PLATFORM_ID } from '@angular/core';
+import { BehaviorSubject, combineLatest, fromEvent, Subscription } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+// Default DF breakpoints
+export const DF_BREAKPOINTS_VAR_DEFAULT = {
+    xs: '--df-breakpoint-xs',
+    sm: '--df-breakpoint-sm',
+    md: '--df-breakpoint-md',
+    lg: '--df-breakpoint-lg',
+    xl: '--df-breakpoint-xl',
+    xxl: '--df-breakpoint-xxl',
+    xxxl: '--df-breakpoint-xxxl'
+};
+export const BREAKPOINTS_VARS = new InjectionToken('Bootstrap Breakpoints', {
+    providedIn: 'root',
+    factory() {
+        return DF_BREAKPOINTS_VAR_DEFAULT;
+    }
+});
+export class DfBreakpoints {
+    constructor(_breakPointsVar, platformID) {
+        this._breakPointsVar = _breakPointsVar;
+        this.platformID = platformID;
+        this._breakPoints$ = new BehaviorSubject(null);
+        this.initBreakpoints();
+    }
+    get breakPoints$() {
+        return this._breakPoints$.asObservable();
+    }
+    initBreakpoints() {
+        let breakPoints = null;
+        if (isPlatformBrowser(this.platformID) && this._breakPoints$.value === null) {
+            // we are in a browser so CSS variable are accessible
+            // we init the BP only once
+            const styles = window.getComputedStyle(document.documentElement);
+            const bpArray = [];
+            for (const el of Object.keys(this._breakPointsVar)) {
+                const curValue = this._breakPointsVar[el];
+                const bpValue = Number.parseInt(styles.getPropertyValue(curValue), 10);
+                if (isNaN(bpValue)) {
+                    // We should never enter here. Only if people did not put the correct list of CSS vars...
+                    // Or if the CSS is not arrived yet.
+                    // What should we do then?
+                    // TODO init from the default list provided if we want to?
+                }
+                else {
+                    bpArray.push([el, bpValue]);
+                }
+            }
+            breakPoints = this.generate(bpArray);
+            // In case the first page contains the directive and the CSS vars are not available
+            // We may need to launch a second init at load time.
+            if (Object.keys(breakPoints).length === 0) {
+                fromEvent(window, 'load')
+                    .pipe(take(1))
+                    .subscribe(() => {
+                    // Init once as the service is available everywhere
+                    // We do not check if the CSS variable are changing over time
+                    // here onload the CSS var should be available
+                    this.initBreakpoints();
+                });
+            }
+        }
+        this._breakPoints$.next(breakPoints);
+    }
+    // Utilities to use if you want to create your own queries with your values.
+    // sizes is an array of array BreakPoints with sizes[0] --> identifier of the BreakPoint
+    // sizes[1] px value of the BreakPoint
+    generate(sizes) {
+        sizes = sizes.sort((a, b) => a[1] - b[1]);
+        const dict = {};
+        for (let i = 0; i < sizes.length; i++) {
+            const name = sizes[i][0];
+            const min = sizes[i][1];
+            const max = i === sizes.length - 1 ? undefined : sizes[i + 1][1];
+            if (min === 0) {
+                dict[name] = `(max-width: ${max - 0.01}px)`;
+            }
+            else if (max) {
+                dict[name] = `(max-width: ${max - 0.01}px) and (min-width: ${min}px)`;
+            }
+            else {
+                dict[name] = `(min-width: ${min}px)`;
+            }
+        }
+        return dict;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfBreakpoints, deps: [{ token: BREAKPOINTS_VARS }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfBreakpoints, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfBreakpoints, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BREAKPOINTS_VARS]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+export class DfMediaQuery {
+    constructor(platformId) {
+        this._isBrowser = isPlatformBrowser(platformId);
+    }
+    notSupported(query) {
+        return { matches: false, media: query, addEventListener: () => { }, removeEventListener: () => { } };
+    }
+    matchMedia(query) {
+        if (this._isBrowser && window.matchMedia) {
+            return window.matchMedia(query);
+        }
+        else {
+            return this.notSupported(query);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMediaQuery, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMediaQuery, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMediaQuery, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+export class DfMediaObserver {
+    constructor(_mediaQuery) {
+        this._mediaQuery = _mediaQuery;
+        this._subscription = new Subscription();
+        this._queries = new Map();
+    }
+    /**
+     * Verifies if at least one of the provided media-queries is matching
+     * the current viewport
+     */
+    matches(queries) {
+        queries = this._flattenQueries(Array.isArray(queries) ? queries : [queries]);
+        return queries.some(q => this._registerQuery(q).mediaQueryList.matches);
+    }
+    /**
+     * Produces an observable for a set of media-queries that will emit
+     * meta information for any changes of the given queries.
+     * @param value One or more media-queries to be observed.
+     * @returns A stream of matches meta object for the given media-queries.
+     */
+    observe(queries) {
+        queries = this._flattenQueries(Array.isArray(queries) ? queries : [queries]);
+        return combineLatest(queries.map(q => this._registerQuery(q).mediaQueryList$)).pipe(map((events) => events.reduce((result, event) => {
+            result.matches = result.matches || event.matches;
+            result.breakpoints[event.media] = event.matches;
+            return result;
+        }, { matches: false, breakpoints: {} })));
+    }
+    ngOnDestroy() {
+        this._subscription.unsubscribe();
+    }
+    _flattenQueries(queries) {
+        return queries.map(q => q.split(',')).reduce((flat, a) => flat.concat(a));
+    }
+    _registerQuery(query) {
+        if (this._queries.has(query)) {
+            return this._queries.get(query);
+        }
+        const queryList = this._mediaQuery.matchMedia(query);
+        const queryList$ = new BehaviorSubject({
+            media: query,
+            matches: queryList.matches
+        });
+        this._subscription.add(fromEvent(queryList, 'change').subscribe((event) => {
+            queryList$.next(event);
+        }));
+        const meta = { mediaQueryList: queryList, mediaQueryList$: queryList$ };
+        this._queries.set(query, meta);
+        return meta;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMediaObserver, deps: [{ token: DfMediaQuery }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMediaObserver, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfMediaObserver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: DfMediaQuery }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mediaUtils.service.js","sourceRoot":"","sources":["../../../../../../projects/design-factory/src/lib/angular/mediaqueries/mediaUtils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlatformBrowser } from '@angular/common';\nimport { Inject, Injectable, InjectionToken, OnDestroy, PLATFORM_ID } from '@angular/core';\nimport { BehaviorSubject, combineLatest, fromEvent, Observable, Subscription } from 'rxjs';\nimport { map, take } from 'rxjs/operators';\n\n// Default DF breakpoints\nexport const DF_BREAKPOINTS_VAR_DEFAULT = {\n  xs: '--df-breakpoint-xs',\n  sm: '--df-breakpoint-sm',\n  md: '--df-breakpoint-md',\n  lg: '--df-breakpoint-lg',\n  xl: '--df-breakpoint-xl',\n  xxl: '--df-breakpoint-xxl',\n  xxxl: '--df-breakpoint-xxxl'\n};\n\nexport const BREAKPOINTS_VARS = new InjectionToken('Bootstrap Breakpoints', {\n  providedIn: 'root',\n  factory() {\n    return DF_BREAKPOINTS_VAR_DEFAULT;\n  }\n});\n\n@Injectable({ providedIn: 'root' })\nexport class DfBreakpoints {\n  private readonly _breakPoints$ = new BehaviorSubject<{} | null>(null);\n\n  constructor(\n    @Inject(BREAKPOINTS_VARS) private readonly _breakPointsVar: { [breakpoint: string]: string },\n    @Inject(PLATFORM_ID) private readonly platformID: Object\n  ) {\n    this.initBreakpoints();\n  }\n\n  get breakPoints$(): Observable<{} | null> {\n    return this._breakPoints$.asObservable();\n  }\n\n  private initBreakpoints() {\n    let breakPoints = null;\n    if (isPlatformBrowser(this.platformID) && this._breakPoints$.value === null) {\n      // we are in a browser so CSS variable are accessible\n      // we init the BP only once\n      const styles = window.getComputedStyle(document.documentElement) as any;\n      const bpArray = [];\n      for (const el of Object.keys(this._breakPointsVar)) {\n        const curValue = this._breakPointsVar[el];\n        const bpValue = Number.parseInt(styles.getPropertyValue(curValue), 10);\n        if (isNaN(bpValue)) {\n          // We should never enter here. Only if people did not put the correct list of CSS vars...\n          // Or if the CSS is not arrived yet.\n          // What should we do then?\n          // TODO init from the default list provided if we want to?\n        } else {\n          bpArray.push([el, bpValue]);\n        }\n      }\n      breakPoints = this.generate(bpArray);\n      // In case the first page contains the directive and the CSS vars are not available\n      // We may need to launch a second init at load time.\n      if (Object.keys(breakPoints).length === 0) {\n        fromEvent(window, 'load')\n          .pipe(take(1))\n          .subscribe(() => {\n            // Init once as the service is available everywhere\n            // We do not check if the CSS variable are changing over time\n            // here onload the CSS var should be available\n            this.initBreakpoints();\n          });\n      }\n    }\n    this._breakPoints$.next(breakPoints);\n  }\n\n  // Utilities to use if you want to create your own queries with your values.\n  // sizes is an array of array BreakPoints with sizes[0] --> identifier of the BreakPoint\n  // sizes[1] px value of the BreakPoint\n  generate(sizes: any[][]): {} {\n    sizes = sizes.sort((a, b) => a[1] - b[1]);\n    const dict: { [key: string]: string } = {};\n    for (let i = 0; i < sizes.length; i++) {\n      const name = sizes[i][0];\n      const min = sizes[i][1];\n      const max = i === sizes.length - 1 ? undefined : sizes[i + 1][1];\n      if (min === 0) {\n        dict[name] = `(max-width: ${max - 0.01}px)`;\n      } else if (max) {\n        dict[name] = `(max-width: ${max - 0.01}px) and (min-width: ${min}px)`;\n      } else {\n        dict[name] = `(min-width: ${min}px)`;\n      }\n    }\n    return dict;\n  }\n}\n\nexport interface MediaQueryListMeta {\n  mediaQueryList: MediaQueryList;\n  mediaQueryList$: BehaviorSubject<MediaQueryListEvent>;\n}\n\nexport interface MediaBreakpointsState {\n  matches: boolean;\n  breakpoints: { [key: string]: boolean };\n}\n\n@Injectable({ providedIn: 'root' })\nexport class DfMediaQuery {\n  private readonly _isBrowser: boolean;\n\n  constructor(@Inject(PLATFORM_ID) platformId: Object) {\n    this._isBrowser = isPlatformBrowser(platformId);\n  }\n\n  notSupported(query: string): Partial<MediaQueryList> {\n    return { matches: false, media: query, addEventListener: () => {}, removeEventListener: () => {} };\n  }\n\n  matchMedia(query: string): MediaQueryList {\n    if (this._isBrowser && window.matchMedia) {\n      return window.matchMedia(query);\n    } else {\n      return this.notSupported(query) as MediaQueryList;\n    }\n  }\n}\n\n@Injectable({ providedIn: 'root' })\nexport class DfMediaObserver implements OnDestroy {\n  private readonly _subscription: Subscription = new Subscription();\n\n  private readonly _queries = new Map<string, MediaQueryListMeta>();\n\n  constructor(private readonly _mediaQuery: DfMediaQuery) {}\n\n  /**\n   * Verifies if at least one of the provided media-queries is matching\n   * the current viewport\n   */\n  matches(queries: string[] | string): boolean {\n    queries = this._flattenQueries(Array.isArray(queries) ? queries : [queries]);\n    return queries.some(q => this._registerQuery(q)!.mediaQueryList.matches);\n  }\n\n  /**\n   * Produces an observable for a set of media-queries that will emit\n   * meta information for any changes of the given queries.\n   * @param value One or more media-queries to be observed.\n   * @returns A stream of matches meta object for the given media-queries.\n   */\n  observe(queries: string | string[]): Observable<MediaBreakpointsState> {\n    queries = this._flattenQueries(Array.isArray(queries) ? queries : [queries]);\n    return combineLatest(queries.map(q => this._registerQuery(q)!.mediaQueryList$)).pipe(\n      map(\n        (events: MediaQueryListEvent[]): MediaBreakpointsState =>\n          events.reduce(\n            (result, event) => {\n              result.matches = result.matches || event.matches;\n              result.breakpoints[event.media] = event.matches;\n              return result;\n            },\n            { matches: false, breakpoints: {} } as MediaBreakpointsState\n          )\n      )\n    );\n  }\n\n  ngOnDestroy() {\n    this._subscription.unsubscribe();\n  }\n\n  private _flattenQueries(queries: string[]): string[] {\n    return queries.map(q => q.split(',')).reduce((flat, a) => flat.concat(a));\n  }\n\n  private _registerQuery(query: string): MediaQueryListMeta | undefined {\n    if (this._queries.has(query)) {\n      return this._queries.get(query);\n    }\n    const queryList: MediaQueryList = this._mediaQuery.matchMedia(query);\n    const queryList$ = new BehaviorSubject<MediaQueryListEvent>({\n      media: query,\n      matches: queryList.matches\n    } as MediaQueryListEvent);\n    this._subscription.add(\n      fromEvent(queryList, 'change').subscribe((event: Event) => {\n        queryList$.next(event as MediaQueryListEvent);\n      })\n    );\n    const meta: MediaQueryListMeta = { mediaQueryList: queryList, mediaQueryList$: queryList$ };\n    this._queries.set(query, meta);\n    return meta;\n  }\n}\n"]}

package/esm2022/lib/angular/modal/modal.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+export class DfModalService {
+    constructor(modalService, rendererFactory) {
+        this.modalService = modalService;
+        this.rendererFactory = rendererFactory;
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    open(content, options) {
+        let modalRef;
+        if (options && options.container) {
+            modalRef = this.modalService.open(content, options);
+        }
+        else {
+            modalRef = this.modalService.open(content, Object.assign({}, { container: 'body' }, options));
+        }
+        // we add the 'df-modal-open' class to the body when the modal is open. We remove it when the modal is closed/dismissed
+        this.renderer.addClass(document.body, 'df-modal-open');
+        modalRef.result.then(() => {
+            this.renderer.removeClass(document.body, 'df-modal-open');
+        }, () => {
+            this.renderer.removeClass(document.body, 'df-modal-open');
+        });
+        return modalRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfModalService, deps: [{ token: i1.NgbModal }, { token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgbModal }, { type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/popover/config/popover.config.mjs

@@ -0,0 +1,16 @@
+import { NgbPopoverConfig } from '@ng-bootstrap/ng-bootstrap';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+export class DfPopoverConfig extends NgbPopoverConfig {
+    constructor(ngbConfig) {
+        super(ngbConfig || { animation: true });
+        this.autoClose = 'outside';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverConfig, deps: [{ token: i1.NgbConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverConfig }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverConfig, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NgbConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tZmFjdG9yeS9zcmMvbGliL2FuZ3VsYXIvcG9wb3Zlci9jb25maWcvcG9wb3Zlci5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFhLGdCQUFnQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBRzNDLE1BQU0sT0FBTyxlQUFnQixTQUFRLGdCQUFnQjtJQUduRCxZQUFZLFNBQXFCO1FBQy9CLEtBQUssQ0FBQyxTQUFTLElBQUksRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUhqQyxjQUFTLEdBQUcsU0FBc0IsQ0FBQztJQUk1QyxDQUFDOzhHQUxVLGVBQWU7a0hBQWYsZUFBZTs7MkZBQWYsZUFBZTtrQkFEM0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nYkNvbmZpZywgTmdiUG9wb3ZlckNvbmZpZyB9IGZyb20gJ0BuZy1ib290c3RyYXAvbmctYm9vdHN0cmFwJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIERmUG9wb3ZlckNvbmZpZyBleHRlbmRzIE5nYlBvcG92ZXJDb25maWcge1xuICBvdmVycmlkZSBhdXRvQ2xvc2UgPSAnb3V0c2lkZScgYXMgJ291dHNpZGUnO1xuXG4gIGNvbnN0cnVjdG9yKG5nYkNvbmZpZz86IE5nYkNvbmZpZykge1xuICAgIHN1cGVyKG5nYkNvbmZpZyB8fCB7IGFuaW1hdGlvbjogdHJ1ZSB9KTtcbiAgfVxufVxuIl19

package/esm2022/lib/angular/popover/popover.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { NgbPopoverModule, NgbPopoverConfig } from '@ng-bootstrap/ng-bootstrap';
+import { DfPopoverConfig } from './config/popover.config';
+import * as i0 from "@angular/core";
+export class DfPopoverModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverModule, exports: [NgbPopoverModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverModule, providers: [{ provide: NgbPopoverConfig, useClass: DfPopoverConfig }], imports: [NgbPopoverModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfPopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [NgbPopoverModule],
+                    providers: [{ provide: NgbPopoverConfig, useClass: DfPopoverConfig }]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tZmFjdG9yeS9zcmMvbGliL2FuZ3VsYXIvcG9wb3Zlci9wb3BvdmVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2hGLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFNMUQsTUFBTSxPQUFPLGVBQWU7OEdBQWYsZUFBZTsrR0FBZixlQUFlLFlBSGhCLGdCQUFnQjsrR0FHZixlQUFlLGFBRmYsQ0FBQyxFQUFFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxRQUFRLEVBQUUsZUFBZSxFQUFFLENBQUMsWUFEM0QsZ0JBQWdCOzsyRkFHZixlQUFlO2tCQUozQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLGdCQUFnQixDQUFDO29CQUMzQixTQUFTLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxRQUFRLEVBQUUsZUFBZSxFQUFFLENBQUM7aUJBQ3RFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE5nYlBvcG92ZXJNb2R1bGUsIE5nYlBvcG92ZXJDb25maWcgfSBmcm9tICdAbmctYm9vdHN0cmFwL25nLWJvb3RzdHJhcCc7XG5pbXBvcnQgeyBEZlBvcG92ZXJDb25maWcgfSBmcm9tICcuL2NvbmZpZy9wb3BvdmVyLmNvbmZpZyc7XG5cbkBOZ01vZHVsZSh7XG4gIGV4cG9ydHM6IFtOZ2JQb3BvdmVyTW9kdWxlXSxcbiAgcHJvdmlkZXJzOiBbeyBwcm92aWRlOiBOZ2JQb3BvdmVyQ29uZmlnLCB1c2VDbGFzczogRGZQb3BvdmVyQ29uZmlnIH1dXG59KVxuZXhwb3J0IGNsYXNzIERmUG9wb3Zlck1vZHVsZSB7fVxuIl19

package/esm2022/lib/angular/progressbar/progressbar.component.mjs

@@ -0,0 +1,158 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DfProgressbarComponent {
+    constructor() {
+        this.infiniteAnimation = false;
+        /**
+         * Current value of the progressBar. If 'maxValue' is not defined, value represents a percentage. Otherwise, progress
+         * bar percentage value will be computed based on the ratio of 'value/maxValue'
+         */
+        this._value = 0;
+        this._maxValue = 100;
+        /**
+         * Text to be displayed on top of the progressbar
+         */
+        this._text = '';
+        this._percentageValue = 0;
+        this.percentageValueChange = new EventEmitter();
+        this.computedText = '';
+        this.displayProgressBar = false;
+        this.FADING_DELAY_MS = 1500; // if triggered by observables, number of milliseconds after progress bar disappears once stopped
+        this.animationOngoing = false;
+    }
+    set value(newValue) {
+        this._value = newValue;
+        this.updatePercentageValue();
+        this.updateText();
+    }
+    get value() {
+        return this._value;
+    }
+    set maxValue(newValue) {
+        this._maxValue = newValue;
+        this.updatePercentageValue();
+        this.updateText();
+    }
+    get maxValue() {
+        return this._maxValue;
+    }
+    set text(newText) {
+        this._text = newText;
+        this.updateText();
+    }
+    get text() {
+        return this._text;
+    }
+    set percentageValue(newValue) {
+        this._percentageValue = newValue;
+        this.percentageValueChange.emit(newValue);
+    }
+    get percentageValue() {
+        return this._percentageValue;
+    }
+    ngOnInit() {
+        const isTriggeredByObservables = this.start$ && this.end$;
+        if (isTriggeredByObservables) {
+            this.startSubscription = this.start$.subscribe((_) => {
+                this.animationOngoing = true;
+                this.stopAutomaticIncrement();
+                this.resetProgressBarValues();
+                this.displayProgressBar = true;
+                this.startAutomaticIncrement();
+            });
+            this.endSubscription = this.end$.subscribe((_) => {
+                if (this.animationOngoing) {
+                    this.animationOngoing = false;
+                    this.stopAutomaticIncrement();
+                    this.value = 100;
+                    setTimeout(() => {
+                        this.displayProgressBar = false;
+                    }, this.FADING_DELAY_MS);
+                }
+            });
+        }
+        else {
+            this.displayProgressBar = true;
+        }
+    }
+    ngOnDestroy() {
+        if (this.startSubscription) {
+            this.startSubscription.unsubscribe();
+        }
+        if (this.endSubscription) {
+            this.endSubscription.unsubscribe();
+        }
+        this.stopAutomaticIncrement();
+    }
+    updateText() {
+        const precentagePlaceholder = '%PERCENTAGE%';
+        if (this.text.includes(precentagePlaceholder)) {
+            const advancementInPercents = `${Math.floor(this.percentageValue)}%`;
+            this.computedText = this.text.replace(precentagePlaceholder, advancementInPercents);
+            return;
+        }
+        this.computedText = this.text;
+    }
+    updatePercentageValue() {
+        if (this.value > this.maxValue) {
+            this.percentageValue = 100;
+            return;
+        }
+        this.percentageValue = Math.floor((this.value / this.maxValue) * 100);
+    }
+    /**
+     * Randomly increase the percentage but making sure that it can never reach 100%
+     */
+    increasePercentage() {
+        const maximumReachableValue = 90;
+        const remainingPercentage = maximumReachableValue - this.value;
+        const averageIncreaseRatio = 0.015;
+        const randomIncreaseRatio = Math.random() * 2 * averageIncreaseRatio;
+        this.value += randomIncreaseRatio * remainingPercentage;
+        this.updatePercentageValue();
+        this.updateText();
+    }
+    /**
+     * Clears the 'setInterval' function so that the automatic increase of the progressbar stops
+     */
+    stopAutomaticIncrement() {
+        clearInterval(this.intervalId);
+    }
+    /**
+     * Periodically calls a function which increments the value of the progressbar
+     */
+    startAutomaticIncrement() {
+        this.intervalId = setInterval(this.increasePercentage.bind(this), 50);
+    }
+    resetProgressBarValues() {
+        this.value = 0;
+        this.maxValue = 100;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressbarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: DfProgressbarComponent, isStandalone: true, selector: "df-progressbar", inputs: { infiniteAnimation: "infiniteAnimation", value: "value", maxValue: "maxValue", text: "text", start$: "start$", end$: "end$", ariaLabelledBy: "ariaLabelledBy", ariaLabel: "ariaLabel" }, outputs: { percentageValueChange: "percentageValueChange" }, ngImport: i0, template: "<ng-container *ngIf=\"displayProgressBar\">\n  <div *ngIf=\"computedText\" class=\"progressbar-text mb-2\">{{ computedText }}</div>\n  <div class=\"progress\">\n    <ng-container *ngIf=\"infiniteAnimation; else withValue\">\n      <div\n        class=\"progress-bar infinite-animation\"\n        role=\"progressbar\"\n        aria-valuetext=\"indeterminate\"\n        [attr.aria-labelledby]=\"ariaLabelledBy || null\"\n        [attr.aria-label]=\"!ariaLabelledBy && ariaLabel ? ariaLabel : null\"\n      ></div>\n    </ng-container>\n    <ng-template #withValue>\n      <div\n        [style.width.%]=\"percentageValue\"\n        class=\"progress-bar\"\n        role=\"progressbar\"\n        [attr.aria-valuenow]=\"value\"\n        aria-valuemin=\"0\"\n        [attr.aria-valuemax]=\"maxValue\"\n        [attr.aria-valuetext]=\"computedText ? computedText : null\"\n        [attr.aria-labelledby]=\"ariaLabelledBy || null\"\n        [attr.aria-label]=\"!ariaLabelledBy && ariaLabel ? ariaLabel : null\"\n      ></div>\n    </ng-template>\n  </div>\n</ng-container>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'df-progressbar', standalone: true, imports: [CommonModule], template: "<ng-container *ngIf=\"displayProgressBar\">\n  <div *ngIf=\"computedText\" class=\"progressbar-text mb-2\">{{ computedText }}</div>\n  <div class=\"progress\">\n    <ng-container *ngIf=\"infiniteAnimation; else withValue\">\n      <div\n        class=\"progress-bar infinite-animation\"\n        role=\"progressbar\"\n        aria-valuetext=\"indeterminate\"\n        [attr.aria-labelledby]=\"ariaLabelledBy || null\"\n        [attr.aria-label]=\"!ariaLabelledBy && ariaLabel ? ariaLabel : null\"\n      ></div>\n    </ng-container>\n    <ng-template #withValue>\n      <div\n        [style.width.%]=\"percentageValue\"\n        class=\"progress-bar\"\n        role=\"progressbar\"\n        [attr.aria-valuenow]=\"value\"\n        aria-valuemin=\"0\"\n        [attr.aria-valuemax]=\"maxValue\"\n        [attr.aria-valuetext]=\"computedText ? computedText : null\"\n        [attr.aria-labelledby]=\"ariaLabelledBy || null\"\n        [attr.aria-label]=\"!ariaLabelledBy && ariaLabel ? ariaLabel : null\"\n      ></div>\n    </ng-template>\n  </div>\n</ng-container>\n" }]
+        }], propDecorators: { infiniteAnimation: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], maxValue: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], start$: [{
+                type: Input
+            }], end$: [{
+                type: Input
+            }], ariaLabelledBy: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], percentageValueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progressbar.component.js","sourceRoot":"","sources":["../../../../../../projects/design-factory/src/lib/angular/progressbar/progressbar.component.ts","../../../../../../projects/design-factory/src/lib/angular/progressbar/progressbar.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnDestroy, OnInit, Output } from '@angular/core';\nimport { Observable, Subscription } from 'rxjs';\nimport { CommonModule } from '@angular/common';\n\n@Component({\n  selector: 'df-progressbar',\n  templateUrl: 'progressbar.component.html',\n  standalone: true,\n  imports: [CommonModule]\n})\nexport class DfProgressbarComponent implements OnInit, OnDestroy {\n  @Input() infiniteAnimation = false;\n  /**\n   * Current value of the progressBar. If 'maxValue' is not defined, value represents a percentage. Otherwise, progress\n   * bar percentage value will be computed based on the ratio of 'value/maxValue'\n   */\n  private _value = 0;\n\n  @Input()\n  set value(newValue: number) {\n    this._value = newValue;\n    this.updatePercentageValue();\n    this.updateText();\n  }\n\n  get value(): number {\n    return this._value;\n  }\n\n  private _maxValue = 100;\n\n  @Input()\n  set maxValue(newValue: number) {\n    this._maxValue = newValue;\n    this.updatePercentageValue();\n    this.updateText();\n  }\n\n  get maxValue(): number {\n    return this._maxValue;\n  }\n\n  /**\n   * Text to be displayed on top of the progressbar\n   */\n  private _text = '';\n\n  @Input()\n  set text(newText: string) {\n    this._text = newText;\n    this.updateText();\n  }\n\n  get text(): string {\n    return this._text;\n  }\n\n  /**\n   * Observable used to trigger the start of the loading.\n   * When emitting, progressbar will start to randomly increment toward 100%.\n   */\n  @Input() start$?: Observable<any>;\n\n  /**\n   * Observable used to trigger the end of the loading.\n   * When emitting, it forces the progressbar to reach 100%.\n   */\n  @Input() end$?: Observable<any>;\n\n  /**\n   * Id of the label used to describe the progress bar.\n   * It is used in priority compared to the ariaLabel.\n   */\n  @Input() ariaLabelledBy?: string;\n\n  /**\n   * Aria label used to describe the progress bar if no ariaLabelledBy is specified.\n   */\n  @Input() ariaLabel?: string;\n\n  private _percentageValue = 0;\n  set percentageValue(newValue: number) {\n    this._percentageValue = newValue;\n    this.percentageValueChange.emit(newValue);\n  }\n\n  get percentageValue(): number {\n    return this._percentageValue;\n  }\n\n  @Output() percentageValueChange = new EventEmitter<number>();\n\n  public computedText = '';\n  public displayProgressBar = false;\n  public FADING_DELAY_MS = 1500; // if triggered by observables, number of milliseconds after progress bar disappears once stopped\n  private startSubscription?: Subscription;\n  private endSubscription?: Subscription;\n  private intervalId: any; // store the result of 'setInterval' function so that we can clear it onDestroy\n  private animationOngoing = false;\n\n  ngOnInit() {\n    const isTriggeredByObservables = this.start$ && this.end$;\n    if (isTriggeredByObservables) {\n      this.startSubscription = this.start$!.subscribe((_) => {\n        this.animationOngoing = true;\n        this.stopAutomaticIncrement();\n        this.resetProgressBarValues();\n        this.displayProgressBar = true;\n        this.startAutomaticIncrement();\n      });\n      this.endSubscription = this.end$!.subscribe((_) => {\n        if (this.animationOngoing) {\n          this.animationOngoing = false;\n          this.stopAutomaticIncrement();\n          this.value = 100;\n          setTimeout(() => {\n            this.displayProgressBar = false;\n          }, this.FADING_DELAY_MS);\n        }\n      });\n    } else {\n      this.displayProgressBar = true;\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.startSubscription) {\n      this.startSubscription.unsubscribe();\n    }\n    if (this.endSubscription) {\n      this.endSubscription.unsubscribe();\n    }\n    this.stopAutomaticIncrement();\n  }\n\n  private updateText() {\n    const precentagePlaceholder = '%PERCENTAGE%';\n    if (this.text.includes(precentagePlaceholder)) {\n      const advancementInPercents = `${Math.floor(this.percentageValue)}%`;\n      this.computedText = this.text.replace(precentagePlaceholder, advancementInPercents);\n      return;\n    }\n    this.computedText = this.text;\n  }\n\n  private updatePercentageValue() {\n    if (this.value > this.maxValue) {\n      this.percentageValue = 100;\n      return;\n    }\n    this.percentageValue = Math.floor((this.value / this.maxValue) * 100);\n  }\n\n  /**\n   * Randomly increase the percentage but making sure that it can never reach 100%\n   */\n  private increasePercentage() {\n    const maximumReachableValue = 90;\n    const remainingPercentage = maximumReachableValue - this.value;\n    const averageIncreaseRatio = 0.015;\n    const randomIncreaseRatio = Math.random() * 2 * averageIncreaseRatio;\n    this.value += randomIncreaseRatio * remainingPercentage;\n    this.updatePercentageValue();\n    this.updateText();\n  }\n\n  /**\n   * Clears the 'setInterval' function so that the automatic increase of the progressbar stops\n   */\n  private stopAutomaticIncrement() {\n    clearInterval(this.intervalId);\n  }\n\n  /**\n   * Periodically calls a function which increments the value of the progressbar\n   */\n  private startAutomaticIncrement() {\n    this.intervalId = setInterval(this.increasePercentage.bind(this), 50);\n  }\n\n  private resetProgressBarValues() {\n    this.value = 0;\n    this.maxValue = 100;\n  }\n}\n","<ng-container *ngIf=\"displayProgressBar\">\n  <div *ngIf=\"computedText\" class=\"progressbar-text mb-2\">{{ computedText }}</div>\n  <div class=\"progress\">\n    <ng-container *ngIf=\"infiniteAnimation; else withValue\">\n      <div\n        class=\"progress-bar infinite-animation\"\n        role=\"progressbar\"\n        aria-valuetext=\"indeterminate\"\n        [attr.aria-labelledby]=\"ariaLabelledBy || null\"\n        [attr.aria-label]=\"!ariaLabelledBy && ariaLabel ? ariaLabel : null\"\n      ></div>\n    </ng-container>\n    <ng-template #withValue>\n      <div\n        [style.width.%]=\"percentageValue\"\n        class=\"progress-bar\"\n        role=\"progressbar\"\n        [attr.aria-valuenow]=\"value\"\n        aria-valuemin=\"0\"\n        [attr.aria-valuemax]=\"maxValue\"\n        [attr.aria-valuetext]=\"computedText ? computedText : null\"\n        [attr.aria-labelledby]=\"ariaLabelledBy || null\"\n        [attr.aria-label]=\"!ariaLabelledBy && ariaLabel ? ariaLabel : null\"\n      ></div>\n    </ng-template>\n  </div>\n</ng-container>\n"]}

package/esm2022/lib/angular/progressbar/progressbar.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { DfProgressbarComponent } from './progressbar.component';
+import { NgbProgressbarModule } from '@ng-bootstrap/ng-bootstrap';
+import * as i0 from "@angular/core";
+export { DfProgressbarComponent } from './progressbar.component';
+export class DfProgressbarModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfProgressbarModule, imports: [DfProgressbarComponent], exports: [DfProgressbarComponent, NgbProgressbarModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressbarModule, imports: [DfProgressbarComponent, NgbProgressbarModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfProgressbarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [DfProgressbarComponent],
+                    exports: [DfProgressbarComponent, NgbProgressbarModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3NiYXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGVzaWduLWZhY3Rvcnkvc3JjL2xpYi9hbmd1bGFyL3Byb2dyZXNzYmFyL3Byb2dyZXNzYmFyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQUVsRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQU1qRSxNQUFNLE9BQU8sbUJBQW1COzhHQUFuQixtQkFBbUI7K0dBQW5CLG1CQUFtQixZQUhwQixzQkFBc0IsYUFDdEIsc0JBQXNCLEVBQUUsb0JBQW9COytHQUUzQyxtQkFBbUIsWUFIcEIsc0JBQXNCLEVBQ0Usb0JBQW9COzsyRkFFM0MsbUJBQW1CO2tCQUovQixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLHNCQUFzQixDQUFDO29CQUNqQyxPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxvQkFBb0IsQ0FBQztpQkFDeEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRGZQcm9ncmVzc2JhckNvbXBvbmVudCB9IGZyb20gJy4vcHJvZ3Jlc3NiYXIuY29tcG9uZW50JztcbmltcG9ydCB7IE5nYlByb2dyZXNzYmFyTW9kdWxlIH0gZnJvbSAnQG5nLWJvb3RzdHJhcC9uZy1ib290c3RyYXAnO1xuXG5leHBvcnQgeyBEZlByb2dyZXNzYmFyQ29tcG9uZW50IH0gZnJvbSAnLi9wcm9ncmVzc2Jhci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbRGZQcm9ncmVzc2JhckNvbXBvbmVudF0sXG4gIGV4cG9ydHM6IFtEZlByb2dyZXNzYmFyQ29tcG9uZW50LCBOZ2JQcm9ncmVzc2Jhck1vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgRGZQcm9ncmVzc2Jhck1vZHVsZSB7XG59XG4iXX0=

package/esm2022/lib/angular/progressindicator/default/default-spinner.component.mjs

@@ -0,0 +1,23 @@
+import { Component, ChangeDetectionStrategy, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DfDefaultSpinnerComponent {
+    constructor() {
+        this.isGlobalSpinner = false;
+        this.contentClass = 'spinner-border text-primary';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfDefaultSpinnerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: DfDefaultSpinnerComponent, isStandalone: true, selector: "df-default-spinner", inputs: { isGlobalSpinner: "isGlobalSpinner", contentClass: "contentClass", ariaLabel: "ariaLabel" }, ngImport: i0, template: "<div [ngClass]=\"contentClass\" [attr.role]=\"isGlobalSpinner ? 'alert' : 'status'\">\n  <span class=\"visually-hidden\">\n    <ng-container *ngIf=\"ariaLabel; else defaultAriaLabel\">{{ ariaLabel }}</ng-container>\n  </span>\n</div>\n\n<ng-template #defaultAriaLabel>\n  <ng-container i18n=\"@@df.progressindicator.default.spinner.ariaLabel\">Loading...</ng-container>\n</ng-template>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfDefaultSpinnerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'df-default-spinner', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [CommonModule], template: "<div [ngClass]=\"contentClass\" [attr.role]=\"isGlobalSpinner ? 'alert' : 'status'\">\n  <span class=\"visually-hidden\">\n    <ng-container *ngIf=\"ariaLabel; else defaultAriaLabel\">{{ ariaLabel }}</ng-container>\n  </span>\n</div>\n\n<ng-template #defaultAriaLabel>\n  <ng-container i18n=\"@@df.progressindicator.default.spinner.ariaLabel\">Loading...</ng-container>\n</ng-template>\n" }]
+        }], propDecorators: { isGlobalSpinner: [{
+                type: Input
+            }], contentClass: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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