@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/filter/ogc-filter-time/index.mjs

@@ -0,0 +1,3 @@
+export * from './ogc-filter-time.component';
+export * from './ogc-filter-time-slider.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9maWx0ZXIvb2djLWZpbHRlci10aW1lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb2djLWZpbHRlci10aW1lLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL29nYy1maWx0ZXItdGltZS1zbGlkZXIuY29tcG9uZW50JztcbiJdfQ==

package/esm2022/lib/filter/ogc-filter-time/ogc-filter-time-slider.component.mjs

@@ -0,0 +1,201 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatSlider, MatSliderModule } from '@angular/material/slider';
+import { default as moment } from 'moment';
+import { OGCFilterTimeService } from '../shared/ogc-filter-time.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../shared/ogc-filter-time.service";
+import * as i2 from "@angular/material/slider";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+export class OgcFilterTimeSliderComponent {
+    ogcFilterTimeService;
+    currentFilter;
+    begin;
+    max;
+    datasource;
+    changeProperty = new EventEmitter();
+    slider;
+    interval;
+    sliderValue = 1;
+    calculatedStep = 0;
+    _defaultDisplayFormat = 'DD/MM/YYYY HH:mm A';
+    _defaultSliderInterval = 2000;
+    playIcon = 'play_circle';
+    resetIcon = 'replay';
+    get sliderInterval() {
+        return this.currentFilter.sliderInterval === undefined
+            ? this._defaultSliderInterval
+            : this.currentFilter.sliderInterval;
+    }
+    get displayFormat() {
+        if (this.currentFilter.sliderOptions?.displayFormat) {
+            return this.currentFilter.sliderOptions.displayFormat;
+        }
+        if (this.currentFilter.displayFormat) {
+            return this.currentFilter.displayFormat;
+        }
+        return this._defaultDisplayFormat;
+    }
+    get beginMillisecond() {
+        return this.ogcFilterTimeService.dateToNumber(this.begin);
+    }
+    get maxMillisecond() {
+        return this.ogcFilterTimeService.dateToNumber(this.max);
+    }
+    get stepMillisecond() {
+        return this.ogcFilterTimeService.stepMillisecond(this.datasource, this.currentFilter);
+    }
+    constructor(ogcFilterTimeService) {
+        this.ogcFilterTimeService = ogcFilterTimeService;
+        this.sliderDisplayWith = this.sliderDisplayWith.bind(this);
+    }
+    ngOnInit() {
+        this.calculateStep();
+        this.handleSliderInput({ value: 1 });
+    }
+    sliderDisplayWith(value) {
+        let dateTmp = new Date(this.beginMillisecond + (value - 1) * this.stepMillisecond);
+        if (this.ogcFilterTimeService.stepIsYearDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))) {
+            const toAdd = moment
+                .duration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))
+                .years();
+            dateTmp = moment(this.beginMillisecond)
+                .add((value - 1) * toAdd, 'year')
+                .toDate();
+        }
+        else if (this.ogcFilterTimeService.stepIsMonthDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))) {
+            const toAdd = moment
+                .duration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))
+                .months();
+            dateTmp = moment(this.beginMillisecond)
+                .add((value - 1) * toAdd, 'month')
+                .toDate();
+        }
+        return moment(dateTmp).format(this.displayFormat);
+    }
+    playFilter() {
+        if (this.interval) {
+            this.stopFilter();
+        }
+        else {
+            this.playIcon = 'pause_circle';
+            this.interval = setInterval(() => {
+                if (this.slider.step < this.calculatedStep) {
+                    const _increment = '_increment';
+                    const _emitInputEvent = '_emitInputEvent';
+                    this.slider[_increment](1);
+                    this.slider[_emitInputEvent]();
+                }
+                else {
+                    this.stopFilter();
+                }
+            }, this.sliderInterval, this);
+        }
+    }
+    stopFilter() {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+        this.interval = undefined;
+        this.playIcon = 'play_circle';
+    }
+    resetFilter() {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+        this.interval = undefined;
+        this.playIcon = 'play_circle';
+        this.slider.step = 1;
+        const _emitInputEvent = '_emitInputEvent';
+        this.slider[_emitInputEvent]();
+    }
+    handleSliderInput(matSliderChange) {
+        if (matSliderChange) {
+            if (this.ogcFilterTimeService.stepIsYearDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))) {
+                const toAdd = moment
+                    .duration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))
+                    .years();
+                const dateBeginTmp = moment(this.beginMillisecond)
+                    .add((matSliderChange.value - 1) * toAdd, 'year')
+                    .toDate();
+                const dateEndTmp = moment(dateBeginTmp).add(toAdd, 'year').toDate();
+                this.changeProperty.next({
+                    value: moment(dateBeginTmp).toDate().toISOString(),
+                    pos: 1,
+                    refreshFilter: false
+                });
+                this.changeProperty.next({
+                    value: moment(dateEndTmp).toDate().toISOString(),
+                    pos: 2,
+                    refreshFilter: true
+                });
+            }
+            else if (this.ogcFilterTimeService.stepIsMonthDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))) {
+                const toAdd = moment
+                    .duration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))
+                    .months();
+                const dateBeginTmp = moment(this.beginMillisecond)
+                    .add((matSliderChange.value - 1) * toAdd, 'month')
+                    .toDate();
+                const dateEndTmp = moment(dateBeginTmp).add(toAdd, 'month').toDate();
+                this.changeProperty.next({
+                    value: moment(dateBeginTmp).startOf('month').toDate().toISOString(),
+                    pos: 1,
+                    refreshFilter: false
+                });
+                this.changeProperty.next({
+                    value: moment(dateEndTmp).toDate().toISOString(),
+                    pos: 2,
+                    refreshFilter: true
+                });
+            }
+            else if (this.ogcFilterTimeService.stepIsDayDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter)) ||
+                this.ogcFilterTimeService.stepIsHourDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter)) ||
+                this.ogcFilterTimeService.stepIsMinuteDuration(this.ogcFilterTimeService.step(this.datasource, this.currentFilter))) {
+                const dateTmp = new Date(this.beginMillisecond +
+                    this.stepMillisecond * (matSliderChange.value - 1));
+                this.changeProperty.next({
+                    value: dateTmp.toISOString(),
+                    pos: 1,
+                    refreshFilter: false
+                });
+                this.changeProperty.next({
+                    value: new Date(this.ogcFilterTimeService.addStep(dateTmp.toISOString(), this.stepMillisecond)).toISOString(),
+                    pos: 2,
+                    refreshFilter: true
+                });
+            }
+        }
+    }
+    calculateStep() {
+        for (let i = 1; this.maxMillisecond -
+            (this.beginMillisecond + i * this.stepMillisecond) >=
+            -1; i++) {
+            this.calculatedStep = i;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OgcFilterTimeSliderComponent, deps: [{ token: i1.OGCFilterTimeService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: OgcFilterTimeSliderComponent, isStandalone: true, selector: "igo-ogc-filter-time-slider", inputs: { currentFilter: "currentFilter", begin: "begin", max: "max", datasource: "datasource" }, outputs: { changeProperty: "changeProperty" }, providers: [OGCFilterTimeService], viewQueries: [{ propertyName: "slider", first: true, predicate: MatSlider, descendants: true }], ngImport: i0, template: "<div class=\"slider-container\">\n  <mat-slider\n    id=\"time-slider\"\n    [step]=\"1\"\n    [min]=\"1\"\n    [max]=\"calculatedStep\"\n    [(ngModel)]=\"sliderValue\"\n    [displayWith]=\"sliderDisplayWith\"\n    thumbLabel\n    #ngSlider\n    ><input\n      matSliderThumb\n      (input)=\"\n        handleSliderInput({\n          source: ngSliderThumb,\n          parent: ngSlider,\n          value: ngSliderThumb.value\n        })\n      \"\n      #ngSliderThumb=\"matSliderThumb\"\n    />\n  </mat-slider>\n  <button mat-icon-button color=\"primary\" (click)=\"playFilter()\">\n    <mat-icon>{{ playIcon }}</mat-icon>\n  </button>\n  <button mat-icon-button color=\"primary\" (click)=\"resetFilter()\">\n    <mat-icon>{{ resetIcon }}</mat-icon>\n  </button>\n</div>\n", styles: [":host ::ng-deep input{text-align:center!important;margin:auto 5px!important}:host .datetime-container{text-align:center}:host .slider-container{text-align:center}:host .datetime-input{display:inline-block;margin:5px 25px}:host .date-input{width:120px;margin-right:25px}:host .time-input{display:inherit;margin-right:25px}:host .hour-input,:host .minute-input{width:40px}:host .minute-input{margin-left:10px}\n"], dependencies: [{ kind: "ngmodule", type: MatSliderModule }, { kind: "component", type: i2.MatSlider, selector: "mat-slider", inputs: ["disabled", "discrete", "showTickMarks", "min", "color", "disableRipple", "max", "step", "displayWith"], exportAs: ["matSlider"] }, { kind: "directive", type: i2.MatSliderThumb, selector: "input[matSliderThumb]", inputs: ["value"], outputs: ["valueChange", "dragStart", "dragEnd"], exportAs: ["matSliderThumb"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OgcFilterTimeSliderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-ogc-filter-time-slider', standalone: true, imports: [MatSliderModule, FormsModule, MatButtonModule, MatIconModule], providers: [OGCFilterTimeService], template: "<div class=\"slider-container\">\n  <mat-slider\n    id=\"time-slider\"\n    [step]=\"1\"\n    [min]=\"1\"\n    [max]=\"calculatedStep\"\n    [(ngModel)]=\"sliderValue\"\n    [displayWith]=\"sliderDisplayWith\"\n    thumbLabel\n    #ngSlider\n    ><input\n      matSliderThumb\n      (input)=\"\n        handleSliderInput({\n          source: ngSliderThumb,\n          parent: ngSlider,\n          value: ngSliderThumb.value\n        })\n      \"\n      #ngSliderThumb=\"matSliderThumb\"\n    />\n  </mat-slider>\n  <button mat-icon-button color=\"primary\" (click)=\"playFilter()\">\n    <mat-icon>{{ playIcon }}</mat-icon>\n  </button>\n  <button mat-icon-button color=\"primary\" (click)=\"resetFilter()\">\n    <mat-icon>{{ resetIcon }}</mat-icon>\n  </button>\n</div>\n", styles: [":host ::ng-deep input{text-align:center!important;margin:auto 5px!important}:host .datetime-container{text-align:center}:host .slider-container{text-align:center}:host .datetime-input{display:inline-block;margin:5px 25px}:host .date-input{width:120px;margin-right:25px}:host .time-input{display:inherit;margin-right:25px}:host .hour-input,:host .minute-input{width:40px}:host .minute-input{margin-left:10px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.OGCFilterTimeService }], propDecorators: { currentFilter: [{
+                type: Input
+            }], begin: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], datasource: [{
+                type: Input
+            }], changeProperty: [{
+                type: Output
+            }], slider: [{
+                type: ViewChild,
+                args: [MatSlider]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ogc-filter-time-slider.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/filter/ogc-filter-time/ogc-filter-time-slider.component.ts","../../../../../../packages/geo/src/lib/filter/ogc-filter-time/ogc-filter-time-slider.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  Input,\n  OnInit,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatSlider, MatSliderModule } from '@angular/material/slider';\n\nimport { default as moment } from 'moment';\n\nimport { OGCFilterTimeService } from '../shared/ogc-filter-time.service';\n\n@Component({\n  selector: 'igo-ogc-filter-time-slider',\n  templateUrl: './ogc-filter-time-slider.component.html',\n  styleUrls: ['./ogc-filter-time-slider.component.scss'],\n  standalone: true,\n  imports: [MatSliderModule, FormsModule, MatButtonModule, MatIconModule],\n  providers: [OGCFilterTimeService]\n})\nexport class OgcFilterTimeSliderComponent implements OnInit {\n  @Input() currentFilter: any;\n  @Input() begin: any;\n  @Input() max: any;\n  @Input() datasource: any;\n  @Output() changeProperty: EventEmitter<{\n    value: any;\n    pos: number;\n    refreshFilter: boolean;\n  }> = new EventEmitter<any>();\n  @ViewChild(MatSlider) slider: MatSlider;\n\n  interval;\n  sliderValue = 1;\n  calculatedStep = 0;\n  readonly _defaultDisplayFormat: string = 'DD/MM/YYYY HH:mm A';\n  readonly _defaultSliderInterval: number = 2000;\n  public playIcon = 'play_circle';\n  public resetIcon = 'replay';\n\n  get sliderInterval(): number {\n    return this.currentFilter.sliderInterval === undefined\n      ? this._defaultSliderInterval\n      : this.currentFilter.sliderInterval;\n  }\n\n  get displayFormat(): string {\n    if (this.currentFilter.sliderOptions?.displayFormat) {\n      return this.currentFilter.sliderOptions.displayFormat;\n    }\n    if (this.currentFilter.displayFormat) {\n      return this.currentFilter.displayFormat;\n    }\n    return this._defaultDisplayFormat;\n  }\n\n  get beginMillisecond(): number {\n    return this.ogcFilterTimeService.dateToNumber(this.begin);\n  }\n\n  get maxMillisecond(): number {\n    return this.ogcFilterTimeService.dateToNumber(this.max);\n  }\n\n  get stepMillisecond(): number {\n    return this.ogcFilterTimeService.stepMillisecond(\n      this.datasource,\n      this.currentFilter\n    );\n  }\n\n  constructor(public ogcFilterTimeService: OGCFilterTimeService) {\n    this.sliderDisplayWith = this.sliderDisplayWith.bind(this);\n  }\n\n  ngOnInit() {\n    this.calculateStep();\n    this.handleSliderInput({ value: 1 });\n  }\n\n  sliderDisplayWith(value) {\n    let dateTmp = new Date(\n      this.beginMillisecond + (value - 1) * this.stepMillisecond\n    );\n\n    if (\n      this.ogcFilterTimeService.stepIsYearDuration(\n        this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n      )\n    ) {\n      const toAdd = moment\n        .duration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        )\n        .years();\n      dateTmp = moment(this.beginMillisecond)\n        .add((value - 1) * toAdd, 'year')\n        .toDate();\n    } else if (\n      this.ogcFilterTimeService.stepIsMonthDuration(\n        this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n      )\n    ) {\n      const toAdd = moment\n        .duration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        )\n        .months();\n      dateTmp = moment(this.beginMillisecond)\n        .add((value - 1) * toAdd, 'month')\n        .toDate();\n    }\n\n    return moment(dateTmp).format(this.displayFormat);\n  }\n\n  playFilter() {\n    if (this.interval) {\n      this.stopFilter();\n    } else {\n      this.playIcon = 'pause_circle';\n      this.interval = setInterval(\n        () => {\n          if (this.slider.step < this.calculatedStep) {\n            const _increment = '_increment';\n            const _emitInputEvent = '_emitInputEvent';\n            this.slider[_increment](1);\n            this.slider[_emitInputEvent]();\n          } else {\n            this.stopFilter();\n          }\n        },\n        this.sliderInterval,\n        this\n      );\n    }\n  }\n\n  stopFilter() {\n    if (this.interval) {\n      clearInterval(this.interval);\n    }\n    this.interval = undefined;\n    this.playIcon = 'play_circle';\n  }\n\n  resetFilter() {\n    if (this.interval) {\n      clearInterval(this.interval);\n    }\n    this.interval = undefined;\n    this.playIcon = 'play_circle';\n    this.slider.step = 1;\n    const _emitInputEvent = '_emitInputEvent';\n    this.slider[_emitInputEvent]();\n  }\n\n  handleSliderInput(matSliderChange) {\n    if (matSliderChange) {\n      if (\n        this.ogcFilterTimeService.stepIsYearDuration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        )\n      ) {\n        const toAdd = moment\n          .duration(\n            this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n          )\n          .years();\n        const dateBeginTmp = moment(this.beginMillisecond)\n          .add((matSliderChange.value - 1) * toAdd, 'year')\n          .toDate();\n        const dateEndTmp = moment(dateBeginTmp).add(toAdd, 'year').toDate();\n        this.changeProperty.next({\n          value: moment(dateBeginTmp).toDate().toISOString(),\n          pos: 1,\n          refreshFilter: false\n        });\n        this.changeProperty.next({\n          value: moment(dateEndTmp).toDate().toISOString(),\n          pos: 2,\n          refreshFilter: true\n        });\n      } else if (\n        this.ogcFilterTimeService.stepIsMonthDuration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        )\n      ) {\n        const toAdd = moment\n          .duration(\n            this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n          )\n          .months();\n        const dateBeginTmp = moment(this.beginMillisecond)\n          .add((matSliderChange.value - 1) * toAdd, 'month')\n          .toDate();\n        const dateEndTmp = moment(dateBeginTmp).add(toAdd, 'month').toDate();\n        this.changeProperty.next({\n          value: moment(dateBeginTmp).startOf('month').toDate().toISOString(),\n          pos: 1,\n          refreshFilter: false\n        });\n        this.changeProperty.next({\n          value: moment(dateEndTmp).toDate().toISOString(),\n          pos: 2,\n          refreshFilter: true\n        });\n      } else if (\n        this.ogcFilterTimeService.stepIsDayDuration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        ) ||\n        this.ogcFilterTimeService.stepIsHourDuration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        ) ||\n        this.ogcFilterTimeService.stepIsMinuteDuration(\n          this.ogcFilterTimeService.step(this.datasource, this.currentFilter)\n        )\n      ) {\n        const dateTmp = new Date(\n          this.beginMillisecond +\n            this.stepMillisecond * (matSliderChange.value - 1)\n        );\n        this.changeProperty.next({\n          value: dateTmp.toISOString(),\n          pos: 1,\n          refreshFilter: false\n        });\n        this.changeProperty.next({\n          value: new Date(\n            this.ogcFilterTimeService.addStep(\n              dateTmp.toISOString(),\n              this.stepMillisecond\n            )\n          ).toISOString(),\n          pos: 2,\n          refreshFilter: true\n        });\n      }\n    }\n  }\n\n  calculateStep() {\n    for (\n      let i = 1;\n      this.maxMillisecond -\n        (this.beginMillisecond + i * this.stepMillisecond) >=\n      -1;\n      i++\n    ) {\n      this.calculatedStep = i;\n    }\n  }\n}\n","<div class=\"slider-container\">\n  <mat-slider\n    id=\"time-slider\"\n    [step]=\"1\"\n    [min]=\"1\"\n    [max]=\"calculatedStep\"\n    [(ngModel)]=\"sliderValue\"\n    [displayWith]=\"sliderDisplayWith\"\n    thumbLabel\n    #ngSlider\n    ><input\n      matSliderThumb\n      (input)=\"\n        handleSliderInput({\n          source: ngSliderThumb,\n          parent: ngSlider,\n          value: ngSliderThumb.value\n        })\n      \"\n      #ngSliderThumb=\"matSliderThumb\"\n    />\n  </mat-slider>\n  <button mat-icon-button color=\"primary\" (click)=\"playFilter()\">\n    <mat-icon>{{ playIcon }}</mat-icon>\n  </button>\n  <button mat-icon-button color=\"primary\" (click)=\"resetFilter()\">\n    <mat-icon>{{ resetIcon }}</mat-icon>\n  </button>\n</div>\n"]}