ngx-sfc-components 0.0.1

package/esm2020/lib/components/carousel/service/lazy/carousel-lazy-load.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { tap, merge } from 'rxjs';
+import { CarouselEventType, CarouselProperty } from '../../carousel.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../carousel/carousel.service";
+export class CarouselLazyLoadService {
+    constructor(carouselService) {
+        this.carouselService = carouselService;
+        this.initDataStreams();
+    }
+    ngOnDestroy() {
+        this.lazyLoadSubscription.unsubscribe();
+    }
+    initDataStreams() {
+        const initializedCarousel$ = this.carouselService.initializedState.pipe(tap(() => {
+            const isLazyLoad = this.carouselService.settings && !this.carouselService.settings.lazyLoad;
+            this.carouselService.slidesModel.forEach(item => item.load = isLazyLoad ? true : false);
+        }));
+        const changeSettings$ = this.carouselService.changeState;
+        const resizedCarousel$ = this.carouselService.resizedState;
+        this.lazyLoadSubscription = merge(initializedCarousel$, changeSettings$, resizedCarousel$).pipe(tap(data => this.defineLazyLoadSlides(data))).subscribe();
+    }
+    defineLazyLoadSlides(data) {
+        if (!this.carouselService.settings || !this.carouselService.settings.lazyLoad)
+            return;
+        if ((data.property && data.property.name === CarouselProperty.Position) || data === CarouselEventType.Initialized || data === CarouselEventType.Resized) {
+            const settings = this.carouselService.settings, clones = this.carouselService.clones().length;
+            let n = (settings.center && Math.ceil((settings.items || 0) / 2) || settings.items) || 0, i = ((settings.center && n * -1) || 0), position = (data.property && data.property.value !== undefined ? data.property.value : this.carouselService.current()) + i;
+            if ((settings.lazyLoadEager || 0) > 0) {
+                n += settings.lazyLoadEager || 0;
+                if (settings.loop) {
+                    position -= settings.lazyLoadEager || 0;
+                    n++;
+                }
+            }
+            while (i++ < n) {
+                this.load(clones / 2 + this.carouselService.relative(position));
+                if (clones) {
+                    this.carouselService.clones(this.carouselService.relative(position)).forEach(value => this.load(value));
+                }
+                position++;
+            }
+        }
+    }
+    load(position) {
+        if (this.carouselService.slidesModel[position].load)
+            return;
+        this.carouselService.slidesModel[position].load = true;
+    }
+}
+CarouselLazyLoadService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselLazyLoadService, deps: [{ token: i1.CarouselService }], target: i0.ɵɵFactoryTarget.Injectable });
+CarouselLazyLoadService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselLazyLoadService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselLazyLoadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CarouselService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/carousel/service/navigation/carousel-navigation.service.mjs

@@ -0,0 +1,211 @@
+import { Injectable } from '@angular/core';
+import { CommonConstants } from 'ngx-sfc-common';
+import { tap, filter, merge } from 'rxjs';
+import { CarouselProperty } from '../../carousel.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../carousel/carousel.service";
+export class CarouselNavigationService {
+    constructor(carouselService) {
+        this.carouselService = carouselService;
+        this.pages = [];
+        this.navigationModel = {
+            disabled: false,
+            previous: {
+                disabled: false,
+                label: CommonConstants.EMPTY_STRING
+            },
+            next: {
+                disabled: false,
+                label: CommonConstants.EMPTY_STRING
+            }
+        };
+        this.navigationDotsModel = {
+            disabled: false,
+            dots: []
+        };
+        this.initDataStreams();
+    }
+    ngOnDestroy() {
+        this.navSubscription.unsubscribe();
+    }
+    next(speed) {
+        this.carouselService.to(this.getPosition(true), speed);
+    }
+    ;
+    previous(speed) {
+        this.carouselService.to(this.getPosition(false), speed);
+    }
+    ;
+    to(position, speed, standard) {
+        let length;
+        if (!standard && this.pages.length) {
+            length = this.pages.length;
+            this.carouselService.to(this.pages[((position % length) + length) % length].start, speed);
+        }
+        else {
+            this.carouselService.to(position, speed);
+        }
+    }
+    ;
+    moveByDot(dotId) {
+        const index = this.navigationDotsModel.dots.findIndex(dot => dotId === dot.id);
+        this.to(index, this.carouselService.settings.dotsSpeed || 0);
+    }
+    toSlideById(id) {
+        const position = this.carouselService.slidesModel.findIndex(slide => slide.id === id && slide.isCloned === false);
+        if (position === -1 || position === this.carouselService.current())
+            return;
+        this.carouselService.to(this.carouselService.relative(position), false);
+    }
+    initDataStreams() {
+        const initializedCarousel$ = this.carouselService.initializedState.pipe(tap(() => {
+            this.initialize();
+            this.updateNavPages();
+            this.draw();
+            this.update();
+            this.carouselService.sendChanges();
+        }));
+        const changedSettings$ = this.carouselService.changedState.pipe(filter(data => data.property.name === CarouselProperty.Position), tap(() => this.update()));
+        const refreshedCarousel$ = this.carouselService.refreshedState.pipe(tap(() => {
+            this.updateNavPages();
+            this.draw();
+            this.update();
+            this.carouselService.sendChanges();
+        }));
+        this.navSubscription = merge(initializedCarousel$, changedSettings$, refreshedCarousel$).subscribe();
+    }
+    initialize() {
+        this.navigationModel.disabled = true;
+        if (this.carouselService.settings.navText) {
+            this.navigationModel.previous.label = this.carouselService.settings.navText[0];
+            this.navigationModel.next.label = this.carouselService.settings.navText[1];
+        }
+        this.navigationDotsModel.disabled = true;
+        this.carouselService.navigationModel = this.navigationModel;
+        this.carouselService.navigationDotsModel = this.navigationDotsModel;
+    }
+    updateNavPages() {
+        let i, j, k;
+        const lower = this.carouselService.clones().length / 2, upper = lower + this.carouselService.items().length, maximum = this.carouselService.maximum(true), pages = [], settings = this.carouselService.settings;
+        let size = settings.center || settings.autoWidth || settings.navigationDotsModel
+            ? 1 : settings.dotsEach || settings.items;
+        size = +size;
+        if (settings.slideBy !== 'page') {
+            settings.slideBy = Math.min(+settings.slideBy, settings.items || 0);
+        }
+        if (settings.dots || settings.slideBy === 'page') {
+            for (i = lower, j = 0, k = 0; i < upper; i++) {
+                if (j >= size || j === 0) {
+                    pages.push({
+                        start: Math.min(maximum, i - lower),
+                        end: i - lower + size - 1
+                    });
+                    if (Math.min(maximum, i - lower) === maximum) {
+                        break;
+                    }
+                    j = 0, ++k;
+                }
+                j += this.carouselService.mergers(this.carouselService.relative(i));
+            }
+        }
+        this.pages = pages;
+    }
+    draw() {
+        let difference;
+        const settings = this.carouselService.settings, items = this.carouselService.items(), disabled = items.length <= (settings.items || 0);
+        this.navigationModel.disabled = !settings.nav || disabled;
+        this.navigationDotsModel.disabled = !settings.dots || disabled;
+        if (settings.dots) {
+            difference = this.pages.length - this.navigationDotsModel.dots.length;
+            if (settings.navigationDotsModel && difference !== 0) {
+                this.navigationDotsModel.dots = [];
+                items.forEach(item => {
+                    this.navigationDotsModel.dots.push({
+                        active: false,
+                        id: `dot-${item.id}`
+                    });
+                });
+            }
+            else if (difference > 0) {
+                const startI = this.navigationDotsModel.dots.length > 0 ? this.navigationDotsModel.dots.length : 0;
+                for (let i = 0; i < difference; i++) {
+                    this.navigationDotsModel.dots.push({
+                        active: false,
+                        id: `dot-${i + startI}`
+                    });
+                }
+            }
+            else if (difference < 0) {
+                this.navigationDotsModel.dots.splice(difference, Math.abs(difference));
+            }
+        }
+        this.carouselService.navigationModel = this.navigationModel;
+        this.carouselService.navigationDotsModel = this.navigationDotsModel;
+    }
+    ;
+    update() {
+        this.updateNavButtons();
+        this.updateDots();
+    }
+    updateNavButtons() {
+        const settings = this.carouselService.settings, loop = settings.loop || settings.rewind || false, index = this.carouselService.relative(this.carouselService.current() || 0);
+        if (settings.nav) {
+            this.navigationModel.previous.disabled = !loop && index <= this.carouselService.minimum(true);
+            this.navigationModel.next.disabled = !loop && index >= this.carouselService.maximum(true);
+        }
+        this.carouselService.navigationModel = this.navigationModel;
+    }
+    updateDots() {
+        let curActiveDotI;
+        if (!this.carouselService.settings.dots)
+            return;
+        this.navigationDotsModel.dots.forEach(item => {
+            if (item.active === true) {
+                item.active = false;
+            }
+        });
+        curActiveDotI = this.getCurrent();
+        if (this.navigationDotsModel.dots.length) {
+            this.navigationDotsModel.dots[curActiveDotI].active = true;
+        }
+        this.carouselService.navigationDotsModel = this.navigationDotsModel;
+    }
+    getCurrent() {
+        const current = this.carouselService.relative(this.carouselService.current() || 0);
+        let finalCurrent;
+        const pages = this.pages.filter((page, index) => {
+            return page.start <= current && page.end >= current;
+        }).pop();
+        finalCurrent = this.pages.findIndex(page => {
+            return page.start === pages.start && page.end === pages.end;
+        });
+        return finalCurrent;
+    }
+    ;
+    getPosition(successor) {
+        let position, length;
+        const settings = this.carouselService.settings;
+        if (settings.slideBy === 'page') {
+            position = this.getCurrent();
+            length = this.pages.length;
+            successor ? ++position : --position;
+            position = this.pages[((position % length) + length) % length].start;
+        }
+        else {
+            position = this.carouselService.relative(this.carouselService.current() || 0);
+            length = this.carouselService.items().length;
+            successor ? position += +settings.slideBy : position -= +settings.slideBy;
+        }
+        return position;
+    }
+    ;
+}
+CarouselNavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselNavigationService, deps: [{ token: i1.CarouselService }], target: i0.ɵɵFactoryTarget.Injectable });
+CarouselNavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselNavigationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CarouselService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel-navigation.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-sfc-components/src/lib/components/carousel/service/navigation/carousel-navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { CommonConstants } from 'ngx-sfc-common';\r\nimport { tap, filter, merge, Observable, Subscription } from 'rxjs';\r\nimport { CarouselProperty } from '../../carousel.enum';\r\nimport { CarouselSlideDirective } from '../../directive/carousel-slide.directive';\r\nimport { CarouselNavigationDotsModel, CarouselNavigationModel } from '../../models/navigation.model';\r\nimport { CarouselOptionsModel } from '../../models/options.model';\r\nimport { CarouselService } from '../carousel/carousel.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CarouselNavigationService implements OnDestroy {\r\n\r\n  private navSubscription!: Subscription;\r\n\r\n  private pages: any[] = [];\r\n\r\n  private navigationModel: CarouselNavigationModel = {\r\n    disabled: false,\r\n    previous: {\r\n      disabled: false,\r\n      label: CommonConstants.EMPTY_STRING\r\n    },\r\n    next: {\r\n      disabled: false,\r\n      label: CommonConstants.EMPTY_STRING\r\n    }\r\n  };\r\n\r\n  private navigationDotsModel: CarouselNavigationDotsModel = {\r\n    disabled: false,\r\n    dots: []\r\n  };\r\n\r\n  constructor(private carouselService: CarouselService) {\r\n    this.initDataStreams();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.navSubscription.unsubscribe();\r\n  }\r\n\r\n  next(speed: number | boolean) {\r\n    this.carouselService.to(this.getPosition(true), speed);\r\n  };\r\n\r\n  previous(speed: number | boolean) {\r\n    this.carouselService.to(this.getPosition(false), speed);\r\n  };\r\n\r\n  to(position: number, speed: number | boolean, standard?: boolean) {\r\n    let length: number;\r\n    if (!standard && this.pages.length) {\r\n      length = this.pages.length;\r\n      this.carouselService.to(this.pages[((position % length) + length) % length].start, speed);\r\n    } else {\r\n      this.carouselService.to(position, speed);\r\n    }\r\n  };\r\n\r\n  moveByDot(dotId: string) {\r\n    const index: number = this.navigationDotsModel.dots.findIndex(dot => dotId === dot.id);\r\n    this.to(index, this.carouselService.settings.dotsSpeed || 0);\r\n  }\r\n\r\n  toSlideById(id: string) {\r\n    const position = this.carouselService.slidesModel.findIndex(slide => slide.id === id && slide.isCloned === false);\r\n\r\n    if (position === -1 || position === this.carouselService.current())\r\n      return;\r\n\r\n    this.carouselService.to(this.carouselService.relative(position), false);\r\n  }\r\n\r\n  private initDataStreams() {\r\n    const initializedCarousel$: Observable<string> = this.carouselService.initializedState.pipe(\r\n      tap(() => {\r\n        this.initialize();\r\n        this.updateNavPages();\r\n        this.draw();\r\n        this.update();\r\n        this.carouselService.sendChanges();\r\n      })\r\n    );\r\n\r\n    const changedSettings$: Observable<any> = this.carouselService.changedState.pipe(\r\n      filter(data => data.property.name === CarouselProperty.Position),\r\n      tap(() => this.update())\r\n    );\r\n\r\n    const refreshedCarousel$: Observable<string> = this.carouselService.refreshedState.pipe(\r\n      tap(() => {\r\n        this.updateNavPages();\r\n        this.draw();\r\n        this.update();\r\n        this.carouselService.sendChanges();\r\n      })\r\n    );\r\n\r\n    this.navSubscription = merge(initializedCarousel$, changedSettings$, refreshedCarousel$).subscribe();\r\n  }\r\n\r\n  private initialize() {\r\n    this.navigationModel.disabled = true;\r\n    if (this.carouselService.settings.navText) {\r\n      this.navigationModel.previous.label = this.carouselService.settings.navText[0];\r\n      this.navigationModel.next.label = this.carouselService.settings.navText[1];\r\n    }\r\n\r\n    this.navigationDotsModel.disabled = true;\r\n\r\n    this.carouselService.navigationModel = this.navigationModel;\r\n    this.carouselService.navigationDotsModel = this.navigationDotsModel;\r\n  }\r\n\r\n  private updateNavPages() {\r\n    let i: number, j: number, k: number;\r\n    const lower: number = this.carouselService.clones().length / 2,\r\n      upper: number = lower + this.carouselService.items().length,\r\n      maximum: number = this.carouselService.maximum(true),\r\n      pages: any[] = [],\r\n      settings: CarouselOptionsModel = this.carouselService.settings;\r\n    let size = settings.center || settings.autoWidth || settings.navigationDotsModel\r\n      ? 1 : settings.dotsEach || settings.items;\r\n    size = +(size as number);\r\n    if (settings.slideBy !== 'page') {\r\n      settings.slideBy = Math.min(+(settings.slideBy as number), settings.items || 0);\r\n    }\r\n\r\n    if (settings.dots || settings.slideBy === 'page') {\r\n\r\n      for (i = lower, j = 0, k = 0; i < upper; i++) {\r\n        if (j >= size || j === 0) {\r\n          pages.push({\r\n            start: Math.min(maximum, i - lower),\r\n            end: i - lower + size - 1\r\n          });\r\n          if (Math.min(maximum, i - lower) === maximum) {\r\n            break;\r\n          }\r\n          j = 0, ++k;\r\n        }\r\n        j += this.carouselService.mergers(this.carouselService.relative(i)) as number;\r\n      }\r\n    }\r\n    this.pages = pages;\r\n  }\r\n\r\n  private draw() {\r\n    let difference: number;\r\n    const settings: CarouselOptionsModel = this.carouselService.settings,\r\n      items: CarouselSlideDirective[] = this.carouselService.items(),\r\n      disabled = items.length <= (settings.items || 0);\r\n\r\n    this.navigationModel.disabled = !settings.nav || disabled;\r\n    this.navigationDotsModel.disabled = !settings.dots || disabled;\r\n\r\n    if (settings.dots) {\r\n      difference = this.pages.length - this.navigationDotsModel.dots.length;\r\n\r\n      if (settings.navigationDotsModel && difference !== 0) {\r\n        this.navigationDotsModel.dots = [];\r\n        items.forEach(item => {\r\n          this.navigationDotsModel.dots.push({\r\n            active: false,\r\n            id: `dot-${item.id}`\r\n          });\r\n        });\r\n      } else if (difference > 0) {\r\n        const startI: number = this.navigationDotsModel.dots.length > 0 ? this.navigationDotsModel.dots.length : 0;\r\n        for (let i = 0; i < difference; i++) {\r\n          this.navigationDotsModel.dots.push({\r\n            active: false,\r\n            id: `dot-${i + startI}`\r\n          });\r\n        }\r\n      } else if (difference < 0) {\r\n        this.navigationDotsModel.dots.splice(difference, Math.abs(difference))\r\n      }\r\n    }\r\n\r\n    this.carouselService.navigationModel = this.navigationModel;\r\n    this.carouselService.navigationDotsModel = this.navigationDotsModel;\r\n  };\r\n\r\n  private update() {\r\n    this.updateNavButtons();\r\n    this.updateDots();\r\n  }\r\n\r\n  private updateNavButtons() {\r\n    const settings: CarouselOptionsModel = this.carouselService.settings,\r\n      loop: boolean = settings.loop || settings.rewind || false,\r\n      index: number = this.carouselService.relative(this.carouselService.current() || 0);\r\n\r\n    if (settings.nav) {\r\n      this.navigationModel.previous.disabled = !loop && index <= this.carouselService.minimum(true);\r\n      this.navigationModel.next.disabled = !loop && index >= this.carouselService.maximum(true);\r\n    }\r\n\r\n    this.carouselService.navigationModel = this.navigationModel;\r\n  }\r\n\r\n  private updateDots() {\r\n    let curActiveDotI: number;\r\n\r\n    if (!this.carouselService.settings.dots)\r\n      return;\r\n\r\n    this.navigationDotsModel.dots.forEach(item => {\r\n      if (item.active === true) {\r\n        item.active = false;\r\n      }\r\n    })\r\n\r\n    curActiveDotI = this.getCurrent();\r\n    if (this.navigationDotsModel.dots.length) {\r\n      this.navigationDotsModel.dots[curActiveDotI].active = true;\r\n    }\r\n    this.carouselService.navigationDotsModel = this.navigationDotsModel;\r\n  }\r\n\r\n  private getCurrent(): any {\r\n    const current: number = this.carouselService.relative(this.carouselService.current() || 0);\r\n    let finalCurrent: number;\r\n    const pages: any = this.pages.filter((page, index) => {\r\n      return page.start <= current && page.end >= current;\r\n    }).pop();\r\n\r\n    finalCurrent = this.pages.findIndex(page => {\r\n      return page.start === pages.start && page.end === pages.end;\r\n    });\r\n\r\n    return finalCurrent;\r\n  };\r\n\r\n  private getPosition(successor: number | boolean): number {\r\n    let position: number, length: number;\r\n    const settings: CarouselOptionsModel = this.carouselService.settings;\r\n\r\n    if (settings.slideBy === 'page') {\r\n      position = this.getCurrent();\r\n      length = this.pages.length;\r\n      successor ? ++position : --position;\r\n      position = this.pages[((position % length) + length) % length].start;\r\n    } else {\r\n      position = this.carouselService.relative(this.carouselService.current() || 0);\r\n      length = this.carouselService.items().length;\r\n      successor ? position += +(settings.slideBy as number) : position -= +(settings.slideBy as number);\r\n    }\r\n\r\n    return position;\r\n  };\r\n}\r\n"]}

package/esm2020/lib/components/chart/chart-option.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnQtb3B0aW9uLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXNmYy1jb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9jaGFydC9jaGFydC1vcHRpb24ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ2hhcnRPcHRpb25Nb2RlbCB7XHJcbiAgICBsZWdlbmQ/OiBib29sZWFuO1xyXG4gICAgZ3JpZExpbmVzPzogYm9vbGVhbjtcclxuICAgIHhBeGU/OmJvb2xlYW47XHJcbiAgICB5QXhlPzpib29sZWFuO1xyXG4gICAgdG9vbHRpcD86IGJvb2xlYW47XHJcbiAgICB0aWNrcz86IGJvb2xlYW47XHJcbiAgICBkZWZhdWx0Q29sb3JzPzogYm9vbGVhbjtcclxufSJdfQ==

package/esm2020/lib/components/chart/chart.component.mjs

@@ -0,0 +1,124 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { Chart } from 'chart.js';
+import { isDefined, mergeDeep, Theme } from 'ngx-sfc-common';
+import { distinctUntilChanged } from 'rxjs';
+import { CHART_DEFAULTS } from './chart.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "./service/theme/chart-theme.service";
+import * as i2 from "./service/settings/chart-settings.service";
+export class ChartComponent {
+    constructor(zone, themeService, settingsService) {
+        this.zone = zone;
+        this.themeService = themeService;
+        this.settingsService = settingsService;
+        // Chart configuration
+        this.type = 'line';
+        this.plugins = [];
+        this._theme = Theme.Default;
+        this._themeSubscription = this.themeService.colors$
+            .pipe(distinctUntilChanged())
+            .subscribe((model) => this.updateColors(model));
+    }
+    get theme() {
+        return this._theme;
+    }
+    set theme(value) {
+        if (this._theme != value) {
+            this._theme = value;
+            this.themeService.setColors({ options: this.themeOptions });
+        }
+    }
+    get themeOptions() {
+        return this.theme === Theme.Dark ? CHART_DEFAULTS.THEME.DARK : CHART_DEFAULTS.THEME.DEFAULT;
+    }
+    ngOnInit() {
+        this.chartOptions = {
+            ...this.settingsService.getDefaultChartOptions(this.type),
+            ...this.chartOptions
+        };
+    }
+    ngAfterViewInit() {
+        const ctx = this.canvas.nativeElement.getContext('2d');
+        if (this.chart) {
+            this.chart.destroy();
+        }
+        this.zone.runOutsideAngular(() => this.chart = new Chart(ctx, this.getChartConfiguration()));
+    }
+    ngOnDestroy() {
+        if (this.chart) {
+            this.chart.destroy();
+            this.chart = void 0;
+        }
+        this._themeSubscription?.unsubscribe();
+    }
+    update() {
+        this.zone.runOutsideAngular(() => this.chart?.update());
+    }
+    getChartConfiguration() {
+        return {
+            type: this.type,
+            data: this.getChartData(),
+            options: this.getChartOptions(),
+            plugins: this.plugins
+        };
+    }
+    getChartData() {
+        const chartData = this.data ? this.data : {
+            labels: this.labels || [],
+            datasets: this.datasets || []
+        };
+        if (this.chartOptions.defaultColors)
+            this.settingsService.setDatasetStyles(this.type, chartData.datasets);
+        return chartData;
+    }
+    getChartOptions() {
+        const chartOptions = this.overrideDefaultOptionsByModel();
+        return mergeDeep(chartOptions, this.options);
+    }
+    overrideDefaultOptionsByModel() {
+        const defaultChartOptions = this.settingsService.getDefaultOptions(this.type);
+        defaultChartOptions.scales.x.grid.display = this.chartOptions.gridLines;
+        defaultChartOptions.scales.x.display = this.chartOptions.xAxe;
+        defaultChartOptions.scales.y.grid.display = this.chartOptions.gridLines;
+        defaultChartOptions.scales.y.display = this.chartOptions.yAxe;
+        defaultChartOptions.scales.x.ticks.display = this.chartOptions.ticks;
+        defaultChartOptions.scales.y.ticks.display = this.chartOptions.ticks;
+        defaultChartOptions.plugins.tooltip.enabled = this.chartOptions.tooltip;
+        defaultChartOptions.plugins.legend.display = this.chartOptions.legend;
+        return mergeDeep(defaultChartOptions, this.themeOptions);
+    }
+    updateColors(model) {
+        if (this.chart) {
+            mergeDeep(this.chart.config.options, model.options);
+            if (isDefined(model.dataSetColors))
+                this.settingsService.setDatasetStyles(this.type, this.chart.config.data.datasets, model.dataSetColors);
+            this.update();
+        }
+    }
+}
+ChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: ChartComponent, deps: [{ token: i0.NgZone }, { token: i1.ChartThemeService }, { token: i2.ChartSettingsService }], target: i0.ɵɵFactoryTarget.Component });
+ChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: ChartComponent, selector: "sfc-chart", inputs: { type: "type", data: "data", options: "options", plugins: "plugins", labels: "labels", datasets: "datasets", chartOptions: "chartOptions", theme: "theme" }, viewQueries: [{ propertyName: "canvas", first: true, predicate: ["chart"], descendants: true }], ngImport: i0, template: "<canvas #chart></canvas>", styles: [":host{height:inherit;width:inherit}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: ChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sfc-chart', styles: [':host { height: inherit; width: inherit;}'], template: "<canvas #chart></canvas>" }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.ChartThemeService }, { type: i2.ChartSettingsService }]; }, propDecorators: { type: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], plugins: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], datasets: [{
+                type: Input
+            }], chartOptions: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], canvas: [{
+                type: ViewChild,
+                args: ['chart']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-sfc-components/src/lib/components/chart/chart.component.ts","../../../../../../projects/ngx-sfc-components/src/lib/components/chart/chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, Input, NgZone, OnDestroy, OnInit, ViewChild } from '@angular/core';\r\nimport { Chart, ChartConfiguration, ChartOptions, ChartType, DefaultDataPoint } from 'chart.js';\r\nimport { isDefined, mergeDeep, Theme } from 'ngx-sfc-common';\r\nimport { distinctUntilChanged, Subscription } from 'rxjs';\r\nimport { ChartOptionModel } from './chart-option.model';\r\nimport { CHART_DEFAULTS } from './chart.constants';\r\nimport { ChartSettingsService } from './service/settings/chart-settings.service';\r\nimport { ChartThemeModel } from './service/theme/chart-theme.model';\r\nimport { ChartThemeService } from './service/theme/chart-theme.service';\r\n\r\n@Component({\r\n  selector: 'sfc-chart',\r\n  templateUrl: './chart.component.html',\r\n  styles: [':host { height: inherit; width: inherit;}']\r\n})\r\nexport class ChartComponent<TType extends ChartType = ChartType,\r\n  TData = DefaultDataPoint<TType>,\r\n  TLabel = unknown> implements OnInit, AfterViewInit, OnDestroy {\r\n\r\n  // Chart configuration\r\n\r\n  @Input()\r\n  type: ChartConfiguration<TType, TData, TLabel>['type'] = 'line' as TType;\r\n\r\n  @Input()\r\n  data!: ChartConfiguration<TType, TData, TLabel>['data'];\r\n\r\n  @Input()\r\n  options!: ChartConfiguration<TType, TData, TLabel>['options'];\r\n\r\n  @Input()\r\n  plugins?: ChartConfiguration<TType, TData, TLabel>['plugins'] = [];\r\n\r\n  // End Chart configuration\r\n\r\n  // Chart data configuration\r\n\r\n  @Input()\r\n  labels?: ChartConfiguration<TType, TData, TLabel>['data']['labels'];\r\n\r\n  @Input()\r\n  datasets?: ChartConfiguration<TType, TData, TLabel>['data']['datasets'];\r\n\r\n  // End Chart data configuration\r\n\r\n  @Input()\r\n  chartOptions!: ChartOptionModel;\r\n\r\n  @Input()\r\n  public get theme() {\r\n    return this._theme;\r\n  }\r\n  public set theme(value) {\r\n    if (this._theme != value) {\r\n      this._theme = value;\r\n      this.themeService.setColors({ options: this.themeOptions });\r\n    }\r\n  }\r\n  private _theme: Theme = Theme.Default;\r\n\r\n  @ViewChild('chart')\r\n  private canvas!: ElementRef;\r\n\r\n  private chart?: Chart<TType, TData, TLabel>;\r\n\r\n  private _themeSubscription?: Subscription;\r\n\r\n  private get themeOptions(): ChartOptions {\r\n    return this.theme === Theme.Dark ? CHART_DEFAULTS.THEME.DARK : CHART_DEFAULTS.THEME.DEFAULT;\r\n  }\r\n\r\n  public constructor(private zone: NgZone, private themeService: ChartThemeService, private settingsService: ChartSettingsService) {\r\n    this._themeSubscription = this.themeService.colors$\r\n      .pipe(distinctUntilChanged())\r\n      .subscribe((model) => this.updateColors(model));\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.chartOptions = {\r\n      ...this.settingsService.getDefaultChartOptions(this.type),\r\n      ...this.chartOptions\r\n    };\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    const ctx = this.canvas.nativeElement.getContext('2d');\r\n\r\n    if (this.chart) {\r\n      this.chart.destroy();\r\n    }\r\n\r\n    this.zone.runOutsideAngular(() => this.chart = new Chart(ctx, this.getChartConfiguration()))\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    if (this.chart) {\r\n      this.chart.destroy();\r\n      this.chart = void 0;\r\n    }\r\n\r\n    this._themeSubscription?.unsubscribe();\r\n  }\r\n\r\n  public update() {\r\n    this.zone.runOutsideAngular(() => this.chart?.update());\r\n  }\r\n\r\n  private getChartConfiguration(): ChartConfiguration<TType, TData, TLabel> {\r\n    return {\r\n      type: this.type,\r\n      data: this.getChartData(),\r\n      options: this.getChartOptions(),\r\n      plugins: this.plugins\r\n    };\r\n  }\r\n\r\n  private getChartData(): ChartConfiguration<TType, TData, TLabel>['data'] {\r\n    const chartData = this.data ? this.data : {\r\n      labels: this.labels || [],\r\n      datasets: this.datasets || []\r\n    };\r\n\r\n    if (this.chartOptions.defaultColors)\r\n      this.settingsService.setDatasetStyles(this.type, chartData.datasets as any);\r\n\r\n    return chartData;\r\n  }\r\n\r\n  private getChartOptions(): ChartConfiguration<TType, TData, TLabel>['options'] {\r\n    const chartOptions = this.overrideDefaultOptionsByModel();\r\n    return mergeDeep(chartOptions, this.options);\r\n  }\r\n\r\n  private overrideDefaultOptionsByModel(): void {\r\n    const defaultChartOptions = this.settingsService.getDefaultOptions(this.type);\r\n\r\n    defaultChartOptions.scales.x.grid.display = this.chartOptions.gridLines;\r\n    defaultChartOptions.scales.x.display = this.chartOptions.xAxe;\r\n    defaultChartOptions.scales.y.grid.display = this.chartOptions.gridLines;\r\n    defaultChartOptions.scales.y.display = this.chartOptions.yAxe;\r\n    defaultChartOptions.scales.x.ticks.display = this.chartOptions.ticks;\r\n    defaultChartOptions.scales.y.ticks.display = this.chartOptions.ticks;\r\n    defaultChartOptions.plugins.tooltip.enabled = this.chartOptions.tooltip;\r\n    defaultChartOptions.plugins.legend.display = this.chartOptions.legend;\r\n\r\n    return mergeDeep(defaultChartOptions, this.themeOptions);\r\n  }\r\n\r\n  private updateColors(model: ChartThemeModel): void {\r\n    if (this.chart) {\r\n\r\n      mergeDeep(this.chart.config.options, model.options);\r\n\r\n      if (isDefined(model.dataSetColors))\r\n        this.settingsService.setDatasetStyles(this.type, this.chart.config.data.datasets as any, model.dataSetColors);\r\n\r\n      this.update();\r\n    }\r\n  }\r\n}\r\n","<canvas #chart></canvas>"]}

package/esm2020/lib/components/chart/chart.constants.mjs

@@ -0,0 +1,95 @@
+import { UIConstants, replaceRgbOpacity } from "ngx-sfc-common";
+const DEFAULT_BACKGROUND_COLORS = [
+    `rgb(93%, 33%, 40%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgba(99%, 43%, 32%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(100%, 81%, 33%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(63%, 83%, 41%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(28%, 81%, 68%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(31%, 76%, 91%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(36%, 61%, 93%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(67%, 57%, 93%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(93%, 53%, 75%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,
+    `rgb(80%, 82%, 85%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`
+];
+const DEFAULT_BORDER_COLORS = ['#DA4453', '#E9573F', '#FCBB42', '#8CC152', '#37BC9B', '#3BAFDA', '#4A89DC', '#967ADC', '#D770AD', '#AAB2BD'];
+const DEFAULT_MODE_COLORS = { GRID: 'rgba(0,0,0,0.1)', TICKS: '#666' };
+const DARK_MODE_COLORS = { GRID: '#656D78', TICKS: '#E6E9ED' };
+export const CHART_DEFAULTS = {
+    OPTIONS: _getOptions(),
+    OPTIONS_NOT_LINES: _getOptions(false),
+    OPTIONS_RADIAL: _getOptions(false, true),
+    COLORS: _getColors(),
+    HALF_TRANSPARENT_COLORS: _getColors(0.5),
+    THEME: {
+        DEFAULT: _getThemeOptions(false),
+        DARK: _getThemeOptions(true)
+    }
+};
+function _getOptions(showAxes = true, showRadialAxes = false) {
+    return {
+        responsive: true,
+        maintainAspectRatio: false,
+        scales: {
+            x: {
+                display: showAxes,
+                grid: { display: true },
+                ticks: { display: true }
+            },
+            y: {
+                display: showAxes,
+                grid: { display: true },
+                ticks: { display: true }
+            },
+            r: {
+                display: showRadialAxes,
+            }
+        },
+        plugins: {
+            tooltip: { enabled: true },
+            legend: { display: true }
+        }
+    };
+}
+function _getColors(opacity = 1) {
+    const backgrounds = DEFAULT_BACKGROUND_COLORS.map(b => replaceRgbOpacity(b, opacity));
+    return backgrounds.map((background, index) => {
+        const border = DEFAULT_BORDER_COLORS[index];
+        return {
+            backgroundColor: background,
+            hoverBackgroundColor: background,
+            borderColor: border,
+            pointBackgroundColor: background,
+            pointBorderColor: border
+        };
+    });
+}
+function _getThemeOptions(dark) {
+    const grid = dark ? DARK_MODE_COLORS.GRID : DEFAULT_MODE_COLORS.GRID, ticks = dark ? DARK_MODE_COLORS.TICKS : DEFAULT_MODE_COLORS.TICKS;
+    return {
+        scales: {
+            x: {
+                grid: { color: grid },
+                ticks: { color: ticks }
+            },
+            y: {
+                grid: { color: grid },
+                ticks: { color: ticks }
+            },
+            r: {
+                angleLines: { color: grid },
+                grid: { color: grid },
+                ticks: { color: ticks, backdropColor: 'transparent' },
+                pointLabels: { color: ticks }
+            }
+        },
+        plugins: {
+            legend: {
+                labels: { color: ticks }
+            },
+            title: {
+                color: ticks
+            }
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.constants.js","sourceRoot":"","sources":["../../../../../../projects/ngx-sfc-components/src/lib/components/chart/chart.constants.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChartConfiguration } from \"chart.js\";\r\nimport { UIConstants, replaceRgbOpacity } from \"ngx-sfc-common\";\r\nimport { ChartThemeDataSetColors } from \"./service/theme/chart-theme.model\";\r\n\r\nconst DEFAULT_BACKGROUND_COLORS = [\r\n    `rgb(93%, 33%, 40%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgba(99%, 43%, 32%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(100%, 81%, 33%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(63%, 83%, 41%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(28%, 81%, 68%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(31%, 76%, 91%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(36%, 61%, 93%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(67%, 57%, 93%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(93%, 53%, 75%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`,\r\n    `rgb(80%, 82%, 85%, ${UIConstants.RGB_OPACITY_PLACEHOLDER})`\r\n];\r\n\r\nconst DEFAULT_BORDER_COLORS = ['#DA4453', '#E9573F', '#FCBB42', '#8CC152', '#37BC9B', '#3BAFDA', '#4A89DC', '#967ADC', '#D770AD', '#AAB2BD'];\r\n\r\nconst DEFAULT_MODE_COLORS = { GRID: 'rgba(0,0,0,0.1)', TICKS: '#666' };\r\n\r\nconst DARK_MODE_COLORS = { GRID: '#656D78', TICKS: '#E6E9ED' };\r\n\r\nexport const CHART_DEFAULTS = {\r\n    OPTIONS: _getOptions(),\r\n    OPTIONS_NOT_LINES: _getOptions(false),\r\n    OPTIONS_RADIAL: _getOptions(false, true),\r\n    COLORS: _getColors(),\r\n    HALF_TRANSPARENT_COLORS: _getColors(0.5),\r\n    THEME: {\r\n        DEFAULT: _getThemeOptions(false),\r\n        DARK: _getThemeOptions(true)\r\n    }\r\n}\r\n\r\nfunction _getOptions(showAxes: boolean = true, showRadialAxes: boolean = false): ChartConfiguration['options'] {\r\n    return {\r\n        responsive: true,\r\n        maintainAspectRatio: false,\r\n        scales: {\r\n            x: {\r\n                display: showAxes,\r\n                grid: { display: true },\r\n                ticks: { display: true }\r\n            },\r\n            y: {\r\n                display: showAxes,\r\n                grid: { display: true },\r\n                ticks: { display: true }\r\n            },\r\n            r: {\r\n                display: showRadialAxes,\r\n            }\r\n        },\r\n        plugins: {\r\n            tooltip: { enabled: true },\r\n            legend: { display: true }\r\n        }\r\n    };\r\n}\r\n\r\nfunction _getColors(opacity: number = 1): ChartThemeDataSetColors[] {\r\n    const backgrounds = DEFAULT_BACKGROUND_COLORS.map(b => replaceRgbOpacity(b, opacity));\r\n\r\n    return backgrounds.map((background: string, index: number) => {\r\n        const border = DEFAULT_BORDER_COLORS[index];\r\n        return {\r\n            backgroundColor: background,\r\n            hoverBackgroundColor: background,\r\n            borderColor: border,\r\n            pointBackgroundColor: background,\r\n            pointBorderColor: border\r\n        }\r\n    });\r\n}\r\n\r\nfunction _getThemeOptions(dark: boolean) {\r\n    const grid = dark ? DARK_MODE_COLORS.GRID : DEFAULT_MODE_COLORS.GRID,\r\n        ticks = dark ? DARK_MODE_COLORS.TICKS : DEFAULT_MODE_COLORS.TICKS;\r\n    return {\r\n        scales: {\r\n            x: {\r\n                grid: { color: grid },\r\n                ticks: { color: ticks }\r\n\r\n            },\r\n            y: {\r\n                grid: { color: grid },\r\n                ticks: { color: ticks }\r\n            },\r\n            r: {\r\n                angleLines: { color: grid },\r\n                grid: { color: grid },\r\n                ticks: { color: ticks, backdropColor: 'transparent' },\r\n                pointLabels: { color: ticks }\r\n            }\r\n        },\r\n        plugins: {\r\n            legend: {\r\n                labels: { color: ticks }\r\n            },\r\n            title: {\r\n                color: ticks\r\n            }\r\n        }\r\n    }\r\n}"]}