@igo2/geo 1.15.4 → 16.0.0-rc.0

package/esm2022/lib/measure/measurer/measurer-item.component.mjs

@@ -0,0 +1,162 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { MeasureType, MeasureAreaUnit, MeasureLengthUnit } from '../shared/measure.enum';
+import { computeBestAreaUnit, computeBestLengthUnit } from '../shared/measure.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/material/select";
+import * as i5 from "@angular/material/core";
+import * as i6 from "@ngx-translate/core";
+import * as i7 from "./measure-format.pipe";
+function MeasurerItemComponent_mat_option_8_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 5);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const measureUnit_r1 = ctx.$implicit;
+    i0.ɵɵproperty("value", measureUnit_r1);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 2, "igo.geo.measure." + measureUnit_r1), " ");
+} }
+/**
+ * Measurer item
+ */
+export class MeasurerItemComponent {
+    /**
+     * Measure observable
+     * @internal
+     */
+    measure$ = new BehaviorSubject(undefined);
+    /**
+     * Subscription to the measure observable when the auto mode is on
+     * @internal
+     */
+    measure$$;
+    /**
+     * Measure type
+     */
+    measureType;
+    /**
+     * Measure unit
+     */
+    measureUnit;
+    /**
+     * Measure
+     */
+    set measure(value) {
+        this.measure$.next(value);
+    }
+    get measure() {
+        return this.measure$.value;
+    }
+    /**
+     * Whther measure units should be automatically determined
+     */
+    set auto(value) {
+        this.toggleAutoUnit(value);
+    }
+    get auto() {
+        return this._auto;
+    }
+    _auto = false;
+    /**
+     * Placeholder
+     */
+    placeholder;
+    /**
+     * Event emitted when the measure unit changes
+     */
+    measureUnitChange = new EventEmitter();
+    /**
+     * Available measure units for the measure type given
+     * @internal
+     */
+    get measureUnits() {
+        if (this.measureType === MeasureType.Area) {
+            return Object.values(MeasureAreaUnit);
+        }
+        return Object.values(MeasureLengthUnit);
+    }
+    constructor() { }
+    /**
+     * Toggle the auto unit off
+     * @internal
+     */
+    ngOnDestroy() {
+        this.toggleAutoUnit(false);
+    }
+    /**
+     * Set the measure unit
+     * @internal
+     */
+    onMeasureUnitChange(unit) {
+        this.measureUnit = unit;
+        this.measureUnitChange.emit(unit);
+    }
+    toggleAutoUnit(toggle) {
+        if (this.measure$$ !== undefined) {
+            this.measure$$.unsubscribe();
+        }
+        if (toggle === true) {
+            this.measure$$ = this.measure$.subscribe((measure) => {
+                this.computeBestMeasureUnit(measure);
+            });
+        }
+        this._auto = toggle;
+    }
+    computeBestMeasureUnit(measure) {
+        let measureUnit = this.measureUnit;
+        if (this.measureType === MeasureType.Area) {
+            measureUnit = computeBestAreaUnit(measure);
+        }
+        else if (this.measureType === MeasureType.Length) {
+            measureUnit = computeBestLengthUnit(measure);
+        }
+        if (measureUnit !== this.measureUnit) {
+            this.onMeasureUnitChange(measureUnit);
+        }
+    }
+    static ɵfac = function MeasurerItemComponent_Factory(t) { return new (t || MeasurerItemComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MeasurerItemComponent, selectors: [["igo-measurer-item"]], inputs: { measureType: "measureType", measureUnit: "measureUnit", measure: "measure", auto: "auto", placeholder: "placeholder" }, outputs: { measureUnitChange: "measureUnitChange" }, decls: 9, vars: 12, consts: [["floatLabel", "always", 1, "measure-field"], ["matInput", "", 3, "disabled", "readonly", "value"], [1, "unit-field"], [3, "value", "disabled", "selectionChange"], [3, "value", 4, "ngFor", "ngForOf"], [3, "value"]], template: function MeasurerItemComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "mat-form-field", 0)(1, "mat-label");
+            i0.ɵɵtext(2);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(3, "input", 1);
+            i0.ɵɵpipe(4, "measureFormat");
+            i0.ɵɵpipe(5, "async");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(6, "mat-form-field", 2)(7, "mat-select", 3);
+            i0.ɵɵlistener("selectionChange", function MeasurerItemComponent_Template_mat_select_selectionChange_7_listener($event) { return ctx.onMeasureUnitChange($event.value); });
+            i0.ɵɵtemplate(8, MeasurerItemComponent_mat_option_8_Template, 3, 4, "mat-option", 4);
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵtextInterpolate(ctx.placeholder);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("disabled", true)("readonly", true)("value", i0.ɵɵpipeBind2(4, 7, i0.ɵɵpipeBind1(5, 10, ctx.measure$) || 0, ctx.measureUnit));
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("value", ctx.measureUnit)("disabled", ctx.auto);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngForOf", ctx.measureUnits);
+        } }, dependencies: [i1.NgForOf, i2.MatFormField, i2.MatLabel, i3.MatInput, i4.MatSelect, i5.MatOption, i1.AsyncPipe, i6.TranslatePipe, i7.MeasureFormatPipe], styles: ["[_nghost-%COMP%]{display:flex;width:100%;padding:5px 10px}[_nghost-%COMP%]   .measure-field[_ngcontent-%COMP%]{pointer-events:none}[_nghost-%COMP%]   .unit-field[_ngcontent-%COMP%]{margin-left:12px}[_nghost-%COMP%]   .unit-field[_ngcontent-%COMP%]     .mat-mdc-form-field-infix{width:-moz-fit-content;width:fit-content}[_nghost-%COMP%]   .unit-field[_ngcontent-%COMP%]     .mat-mdc-select-min-line{padding-right:8px}[_nghost-%COMP%]     mat-form-field .mat-mdc-form-field-subscript-wrapper{display:none}"], changeDetection: 0 });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MeasurerItemComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-measurer-item', changeDetection: ChangeDetectionStrategy.OnPush, template: "<mat-form-field class=\"measure-field\" floatLabel=\"always\">\r\n  <mat-label>{{ placeholder }}</mat-label>\r\n  <input\r\n    matInput\r\n    [disabled]=\"true\"\r\n    [readonly]=\"true\"\r\n    [value]=\"(measure$ | async) || 0 | measureFormat: measureUnit\"\r\n  />\r\n</mat-form-field>\r\n<mat-form-field class=\"unit-field\">\r\n  <mat-select\r\n    [value]=\"measureUnit\"\r\n    [disabled]=\"auto\"\r\n    (selectionChange)=\"onMeasureUnitChange($event.value)\"\r\n  >\r\n    <mat-option *ngFor=\"let measureUnit of measureUnits\" [value]=\"measureUnit\">\r\n      {{ 'igo.geo.measure.' + measureUnit | translate }}\r\n    </mat-option>\r\n  </mat-select>\r\n</mat-form-field>\r\n", styles: [":host{display:flex;width:100%;padding:5px 10px}:host .measure-field{pointer-events:none}:host .unit-field{margin-left:12px}:host .unit-field ::ng-deep .mat-mdc-form-field-infix{width:-moz-fit-content;width:fit-content}:host .unit-field ::ng-deep .mat-mdc-select-min-line{padding-right:8px}:host ::ng-deep mat-form-field .mat-mdc-form-field-subscript-wrapper{display:none}\n"] }]
+    }], function () { return []; }, { measureType: [{
+            type: Input
+        }], measureUnit: [{
+            type: Input
+        }], measure: [{
+            type: Input
+        }], auto: [{
+            type: Input
+        }], placeholder: [{
+            type: Input
+        }], measureUnitChange: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measurer-item.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/measure/measurer/measurer-item.component.ts","../../../../../../packages/geo/src/lib/measure/measurer/measurer-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  Output,\r\n  EventEmitter,\r\n  OnDestroy,\r\n  ChangeDetectionStrategy\r\n} from '@angular/core';\r\n\r\nimport { BehaviorSubject, Subscription } from 'rxjs';\r\n\r\nimport {\r\n  MeasureType,\r\n  MeasureAreaUnit,\r\n  MeasureLengthUnit\r\n} from '../shared/measure.enum';\r\nimport {\r\n  computeBestAreaUnit,\r\n  computeBestLengthUnit\r\n} from '../shared/measure.utils';\r\n\r\n/**\r\n * Measurer item\r\n */\r\n@Component({\r\n  selector: 'igo-measurer-item',\r\n  templateUrl: './measurer-item.component.html',\r\n  styleUrls: ['./measurer-item.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class MeasurerItemComponent implements OnDestroy {\r\n  /**\r\n   * Measure observable\r\n   * @internal\r\n   */\r\n  public measure$: BehaviorSubject<number> = new BehaviorSubject(undefined);\r\n\r\n  /**\r\n   * Subscription to the measure observable when the auto mode is on\r\n   * @internal\r\n   */\r\n  public measure$$: Subscription;\r\n\r\n  /**\r\n   * Measure type\r\n   */\r\n  @Input() measureType: MeasureType;\r\n\r\n  /**\r\n   * Measure unit\r\n   */\r\n  @Input() measureUnit: MeasureAreaUnit | MeasureLengthUnit;\r\n\r\n  /**\r\n   * Measure\r\n   */\r\n  @Input()\r\n  set measure(value: number) {\r\n    this.measure$.next(value);\r\n  }\r\n  get measure(): number {\r\n    return this.measure$.value;\r\n  }\r\n\r\n  /**\r\n   * Whther measure units should be automatically determined\r\n   */\r\n  @Input()\r\n  set auto(value: boolean) {\r\n    this.toggleAutoUnit(value);\r\n  }\r\n  get auto(): boolean {\r\n    return this._auto;\r\n  }\r\n  private _auto: boolean = false;\r\n\r\n  /**\r\n   * Placeholder\r\n   */\r\n  @Input() placeholder: string;\r\n\r\n  /**\r\n   * Event emitted when the measure unit changes\r\n   */\r\n  @Output() measureUnitChange = new EventEmitter<\r\n    MeasureAreaUnit | MeasureLengthUnit\r\n  >();\r\n\r\n  /**\r\n   * Available measure units for the measure type given\r\n   * @internal\r\n   */\r\n  get measureUnits(): string[] {\r\n    if (this.measureType === MeasureType.Area) {\r\n      return Object.values(MeasureAreaUnit);\r\n    }\r\n    return Object.values(MeasureLengthUnit);\r\n  }\r\n\r\n  constructor() {}\r\n\r\n  /**\r\n   * Toggle the auto unit off\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    this.toggleAutoUnit(false);\r\n  }\r\n\r\n  /**\r\n   * Set the measure unit\r\n   * @internal\r\n   */\r\n  onMeasureUnitChange(unit: MeasureAreaUnit | MeasureLengthUnit) {\r\n    this.measureUnit = unit;\r\n    this.measureUnitChange.emit(unit);\r\n  }\r\n\r\n  private toggleAutoUnit(toggle: boolean) {\r\n    if (this.measure$$ !== undefined) {\r\n      this.measure$$.unsubscribe();\r\n    }\r\n    if (toggle === true) {\r\n      this.measure$$ = this.measure$.subscribe((measure: number) => {\r\n        this.computeBestMeasureUnit(measure);\r\n      });\r\n    }\r\n    this._auto = toggle;\r\n  }\r\n\r\n  private computeBestMeasureUnit(measure: number) {\r\n    let measureUnit = this.measureUnit;\r\n    if (this.measureType === MeasureType.Area) {\r\n      measureUnit = computeBestAreaUnit(measure);\r\n    } else if (this.measureType === MeasureType.Length) {\r\n      measureUnit = computeBestLengthUnit(measure);\r\n    }\r\n    if (measureUnit !== this.measureUnit) {\r\n      this.onMeasureUnitChange(measureUnit);\r\n    }\r\n  }\r\n}\r\n","<mat-form-field class=\"measure-field\" floatLabel=\"always\">\r\n  <mat-label>{{ placeholder }}</mat-label>\r\n  <input\r\n    matInput\r\n    [disabled]=\"true\"\r\n    [readonly]=\"true\"\r\n    [value]=\"(measure$ | async) || 0 | measureFormat: measureUnit\"\r\n  />\r\n</mat-form-field>\r\n<mat-form-field class=\"unit-field\">\r\n  <mat-select\r\n    [value]=\"measureUnit\"\r\n    [disabled]=\"auto\"\r\n    (selectionChange)=\"onMeasureUnitChange($event.value)\"\r\n  >\r\n    <mat-option *ngFor=\"let measureUnit of measureUnits\" [value]=\"measureUnit\">\r\n      {{ 'igo.geo.measure.' + measureUnit | translate }}\r\n    </mat-option>\r\n  </mat-select>\r\n</mat-form-field>\r\n"]}