@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/measure/measurer/measurer.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { MeasureFormatPipe } from './measure-format.pipe';
+import { MeasurerComponent } from './measurer.component';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated import the components directly or the MEASURER_DIRECTIVES for the set
+ */
+export class IgoMeasurerModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoMeasurerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoMeasurerModule, imports: [MeasureFormatPipe, MeasurerComponent], exports: [MeasureFormatPipe, MeasurerComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoMeasurerModule, imports: [MeasurerComponent] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoMeasurerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [MeasureFormatPipe, MeasurerComponent],
+                    exports: [MeasureFormatPipe, MeasurerComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVhc3VyZXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvbWVhc3VyZS9tZWFzdXJlci9tZWFzdXJlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUMxRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQzs7QUFFekQ7O0dBRUc7QUFLSCxNQUFNLE9BQU8saUJBQWlCO3dHQUFqQixpQkFBaUI7eUdBQWpCLGlCQUFpQixZQUhsQixpQkFBaUIsRUFBRSxpQkFBaUIsYUFDcEMsaUJBQWlCLEVBQUUsaUJBQWlCO3lHQUVuQyxpQkFBaUIsWUFIQyxpQkFBaUI7OzRGQUduQyxpQkFBaUI7a0JBSjdCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsaUJBQWlCLEVBQUUsaUJBQWlCLENBQUM7b0JBQy9DLE9BQU8sRUFBRSxDQUFDLGlCQUFpQixFQUFFLGlCQUFpQixDQUFDO2lCQUNoRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE1lYXN1cmVGb3JtYXRQaXBlIH0gZnJvbSAnLi9tZWFzdXJlLWZvcm1hdC5waXBlJztcbmltcG9ydCB7IE1lYXN1cmVyQ29tcG9uZW50IH0gZnJvbSAnLi9tZWFzdXJlci5jb21wb25lbnQnO1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIGltcG9ydCB0aGUgY29tcG9uZW50cyBkaXJlY3RseSBvciB0aGUgTUVBU1VSRVJfRElSRUNUSVZFUyBmb3IgdGhlIHNldFxuICovXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbTWVhc3VyZUZvcm1hdFBpcGUsIE1lYXN1cmVyQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW01lYXN1cmVGb3JtYXRQaXBlLCBNZWFzdXJlckNvbXBvbmVudF1cbn0pXG5leHBvcnQgY2xhc3MgSWdvTWVhc3VyZXJNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/measure/shared/index.mjs

@@ -0,0 +1,4 @@
+export * from './measure.enum';
+export * from './measure.interfaces';
+export * from './measure.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tZWFzdXJlL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWVhc3VyZS5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vbWVhc3VyZS5pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbWVhc3VyZS51dGlscyc7XG4iXX0=

package/esm2022/lib/measure/shared/measure.enum.mjs

@@ -0,0 +1,37 @@
+export const MEASURE_UNIT_AUTO = 'auto';
+export var MeasureType;
+(function (MeasureType) {
+    MeasureType["Length"] = "length";
+    MeasureType["Area"] = "area";
+})(MeasureType || (MeasureType = {}));
+export var MeasureLengthUnit;
+(function (MeasureLengthUnit) {
+    MeasureLengthUnit["Meters"] = "meters";
+    MeasureLengthUnit["Kilometers"] = "kilometers";
+    MeasureLengthUnit["Miles"] = "miles";
+    MeasureLengthUnit["Feet"] = "feet";
+})(MeasureLengthUnit || (MeasureLengthUnit = {}));
+export const MeasureLengthUnitAbbreviation = {
+    [MeasureLengthUnit.Meters]: 'm',
+    [MeasureLengthUnit.Kilometers]: 'km',
+    [MeasureLengthUnit.Miles]: 'mi',
+    [MeasureLengthUnit.Feet]: 'ft'
+};
+export var MeasureAreaUnit;
+(function (MeasureAreaUnit) {
+    MeasureAreaUnit["SquareMeters"] = "squareMeters";
+    MeasureAreaUnit["SquareKilometers"] = "squareKilometers";
+    MeasureAreaUnit["SquareMiles"] = "squareMiles";
+    MeasureAreaUnit["SquareFeet"] = "squareFeet";
+    MeasureAreaUnit["Hectares"] = "hectares";
+    MeasureAreaUnit["Acres"] = "acres";
+})(MeasureAreaUnit || (MeasureAreaUnit = {}));
+export const MeasureAreaUnitAbbreviation = {
+    [MeasureAreaUnit.SquareMeters]: 'm²',
+    [MeasureAreaUnit.SquareKilometers]: 'km²',
+    [MeasureAreaUnit.SquareMiles]: 'mi²',
+    [MeasureAreaUnit.SquareFeet]: 'ft²',
+    [MeasureAreaUnit.Hectares]: 'ha',
+    [MeasureAreaUnit.Acres]: 'ac'
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/measure/shared/measure.interfaces.mjs

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

package/esm2022/lib/measure/shared/measure.utils.mjs

@@ -0,0 +1,497 @@
+import OlOverlay from 'ol/Overlay';
+import { getCenter as olGetCenter } from 'ol/extent';
+import OlCircle from 'ol/geom/Circle';
+import OlLineString from 'ol/geom/LineString';
+import OlPoint from 'ol/geom/Point';
+import OlPolygon from 'ol/geom/Polygon';
+import { getArea as olGetArea, getLength as olGetLength } from 'ol/sphere';
+import * as olstyle from 'ol/style';
+import { MeasureAreaUnit, MeasureAreaUnitAbbreviation, MeasureLengthUnit, MeasureLengthUnitAbbreviation } from './measure.enum';
+/**
+ * Convert value from meters to kilometers
+ * @param value Value in meters
+ * @returns Value in kilometers
+ */
+export function metersToKilometers(value) {
+    return value * 0.001;
+}
+/**
+ * Convert value from meters to feet
+ * @param value Value in meters
+ * @returns Value in feet
+ */
+export function metersToFeet(value) {
+    return value * 3.2808;
+}
+/**
+ * Convert value from meters to miles
+ * @param value Value in meters
+ * @returns Value in miles
+ */
+export function metersToMiles(value) {
+    return value * 0.000621;
+}
+/**
+ * Convert value from square meters to square kilometers
+ * @param value Value in square meters
+ * @returns Value in square kilometers
+ */
+export function squareMetersToSquareKilometers(value) {
+    return value * 0.000001;
+}
+/**
+ * Convert value from square meters to square miles
+ * @param value Value in square meters
+ * @returns Value in square miles
+ */
+export function squareMetersToSquareMiles(value) {
+    return value * 0.0000003861;
+}
+/**
+ * Convert value from square meters to square feet
+ * @param value Value in square meters
+ * @returns Value in square feet
+ */
+export function squareMetersToSquareFeet(value) {
+    return value * 10.764;
+}
+/**
+ * Convert value from square meters to hectares
+ * @param value Value in square meters
+ * @returns Value in hectares
+ */
+export function squareMetersToHectares(value) {
+    return value * 0.0001;
+}
+/**
+ * Convert value from square meters to acres
+ * @param value Value in square meters
+ * @returns Value in acres
+ */
+export function squareMetersToAcres(value) {
+    return value * 0.00024711;
+}
+/**
+ * Convert value from meters to the specified length unit
+ * @param value Value in meters
+ * @param unit Length unit
+ * @returns Value in unit
+ */
+export function metersToUnit(value, unit) {
+    const conversionMapper = new Map([
+        [MeasureLengthUnit.Meters, (val) => val],
+        [MeasureLengthUnit.Kilometers, metersToKilometers],
+        [MeasureLengthUnit.Miles, metersToMiles],
+        [MeasureLengthUnit.Feet, metersToFeet]
+    ]);
+    const conversion = conversionMapper.get(unit);
+    return conversion ? conversion(value) : undefined;
+}
+/**
+ * Convert value from square meters to the specified area unit
+ * @param value Value in meters
+ * @param unit Area unit
+ * @returns Value in unit
+ */
+export function squareMetersToUnit(value, unit) {
+    const conversionMapper = new Map([
+        [MeasureAreaUnit.SquareMeters, (val) => val],
+        [MeasureAreaUnit.SquareKilometers, squareMetersToSquareKilometers],
+        [MeasureAreaUnit.SquareMiles, squareMetersToSquareMiles],
+        [MeasureAreaUnit.SquareFeet, squareMetersToSquareFeet],
+        [MeasureAreaUnit.Hectares, squareMetersToHectares],
+        [MeasureAreaUnit.Acres, squareMetersToAcres]
+    ]);
+    const conversion = conversionMapper.get(unit);
+    return conversion ? conversion(value) : undefined;
+}
+/**
+ * This method format a measure to a readable format
+ * @param measure Measure
+ * @param options Formatting options
+ * @returns Formatted measure
+ */
+export function formatMeasure(measure, options, languageService) {
+    let decimal = options.decimal;
+    if (decimal === undefined || decimal < 0) {
+        decimal = 1;
+    }
+    const parts = [];
+    if (options.locale !== undefined) {
+        parts.push(measure.toLocaleString(options.locale, {
+            minimumFractionDigits: decimal,
+            maximumFractionDigits: decimal
+        }));
+    }
+    else {
+        parts.push(measure.toFixed(decimal).toString());
+    }
+    if (options.unit !== undefined && options.unitAbbr === true) {
+        if (languageService) {
+            parts.push(MeasureLengthUnitAbbreviation[options.unit]
+                ? languageService.translate.instant('igo.geo.measure.' + MeasureLengthUnitAbbreviation[options.unit])
+                : languageService.translate.instant('igo.geo.measure.' + MeasureAreaUnitAbbreviation[options.unit]));
+        }
+        else {
+            parts.push(MeasureLengthUnitAbbreviation[options.unit] ||
+                MeasureAreaUnitAbbreviation[options.unit]);
+        }
+    }
+    return parts.filter((p) => p !== undefined).join(' ');
+}
+/**
+ * Compute best length measure unit for a given measure in meters
+ * @param value Value in meters
+ * @returns Measure unit
+ */
+export function computeBestLengthUnit(value) {
+    let unit = MeasureLengthUnit.Meters;
+    let converted = value;
+    const possibleUnits = [MeasureLengthUnit.Kilometers];
+    while (converted > 1000 && possibleUnits.length > 0) {
+        unit = possibleUnits.pop();
+        converted = metersToUnit(value, unit);
+    }
+    return unit;
+}
+/**
+ * Compute best length measure unit for a given measure in square meters
+ * @param value Value in meters
+ * @returns Measure unit
+ */
+export function computeBestAreaUnit(value) {
+    let unit = MeasureAreaUnit.SquareMeters;
+    let converted = value;
+    const possibleUnits = [MeasureAreaUnit.SquareKilometers];
+    while (converted > 1000000 && possibleUnits.length > 0) {
+        unit = possibleUnits.pop();
+        converted = squareMetersToUnit(value, unit);
+    }
+    return unit;
+}
+/**
+ * Create a default style for a measure interaction
+ * @returns OL style
+ */
+export function createMeasureInteractionStyle() {
+    return new olstyle.Style({
+        stroke: new olstyle.Stroke({
+            color: '#ffcc33',
+            lineDash: [10, 10],
+            width: 2
+        }),
+        fill: new olstyle.Fill({
+            color: 'rgba(255, 255, 255, 0.2)'
+        }),
+        image: new olstyle.Circle({
+            radius: 5,
+            stroke: new olstyle.Stroke({
+                color: '#ffcc33'
+            }),
+            fill: new olstyle.Fill({
+                color: 'rgba(255, 255, 255, 0.2)'
+            })
+        })
+    });
+}
+/**
+ * Create a default style for a measure layer
+ * @returns OL style
+ */
+export function createMeasureLayerStyle() {
+    return new olstyle.Style({
+        stroke: new olstyle.Stroke({
+            color: '#ffcc33',
+            width: 2
+        }),
+        fill: new olstyle.Fill({
+            color: 'rgba(255, 255, 255, 0.2)'
+        })
+    });
+}
+/**
+ * Compute the length in meters of an OL geometry with a given projection
+ * @param olGeometry Ol geometry
+ * @param projection olGeometry's projection
+ * @returns Length in meters
+ */
+export function measureOlGeometryLength(olGeometry, projection) {
+    if (olGeometry instanceof OlPoint) {
+        return undefined;
+    }
+    if (olGeometry.getFlatCoordinates().length === 0) {
+        return undefined;
+    }
+    return olGetLength(olGeometry, { projection });
+}
+/**
+ * Compute the area in square meters of an OL geometry with a given projection
+ * @param olGeometry Ol geometry
+ * @param projection olGeometry's projection
+ * @returns Area in square meters
+ */
+export function measureOlGeometryArea(olGeometry, projection) {
+    if (olGeometry instanceof OlPoint || olGeometry instanceof OlLineString) {
+        return undefined;
+    }
+    if (olGeometry.getFlatCoordinates().length === 0) {
+        return undefined;
+    }
+    return olGetArea(olGeometry, { projection });
+}
+/**
+ * Compute the area (square meters), length (meters) and last length (meters)
+ * of an OL geometry with a given projection.
+ * @param olGeometry Ol geometry
+ * @param projection olGeometry's projection
+ * @returns Computed measure
+ */
+export function measureOlGeometry(olGeometry, projection) {
+    const length = measureOlGeometryLength(olGeometry, projection);
+    const area = measureOlGeometryArea(olGeometry, projection);
+    const lengths = [];
+    const coordinates = olGeometry.getFlatCoordinates();
+    const coordinatesLength = coordinates.length;
+    for (let i = 0; i <= coordinatesLength - 4; i += 2) {
+        const olSegment = new OlLineString([
+            [coordinates[i], coordinates[i + 1]],
+            [coordinates[i + 2], coordinates[i + 3]]
+        ]);
+        lengths.push(measureOlGeometryLength(olSegment, projection));
+    }
+    return {
+        area,
+        length,
+        lengths
+    };
+}
+/**
+ * Update an OL geometry midpoints and return an array of those points
+ * @param olGeometry OL Geometry
+ * @returns OL points
+ */
+export function updateOlGeometryMidpoints(olGeometry) {
+    let olMidpoints;
+    if (olGeometry instanceof OlPoint) {
+        const olMidpointPoint = new OlPoint(olGeometry.getFlatCoordinates());
+        olMidpoints = new Array(1);
+        olMidpoints[0] = olMidpointPoint;
+    }
+    else {
+        olMidpoints = getOlGeometryMidpoints(olGeometry);
+        // TODO: handle multi geometries
+        const coordinates = olGeometry.getFlatCoordinates();
+        const midpointsLength = olMidpoints.length;
+        for (let i = 0; i < midpointsLength; i++) {
+            const j = i * 2;
+            const olSegment = new OlLineString([
+                [coordinates[j], coordinates[j + 1]],
+                [coordinates[j + 2], coordinates[j + 3]]
+            ]);
+            const midpointCoordinate = olSegment.getCoordinateAt(0.5);
+            const olMidpoint = olMidpoints[i];
+            if (olMidpoint !== undefined) {
+                olMidpoint.setCoordinates(midpointCoordinate);
+            }
+            else {
+                olMidpoints[i] = new OlPoint(midpointCoordinate);
+            }
+        }
+    }
+    return olMidpoints;
+}
+/**
+ * Clear an OL geometry midpoints and return an array of those points
+ * @param olGeometry OL Geometry
+ */
+export function clearOlGeometryMidpoints(olGeometry) {
+    const olMidpoints = olGeometry.get('_midpoints') || [];
+    const midpointsLength = olMidpoints.length;
+    for (let i = 0; i < midpointsLength; i++) {
+        const olMidpoint = olMidpoints[i];
+        if (olMidpoint !== undefined) {
+            if (olMidpoint !== undefined) {
+                clearOlMidpointTooltip(olMidpoint);
+            }
+        }
+    }
+    olGeometry.set('_midpoints', undefined, true);
+    return olMidpoints;
+}
+/**
+ * Return an array of  OL geometry midpoints, if any
+ * @param olGeometry OL Geometry
+ * @returns OL points
+ */
+function getOlGeometryMidpoints(olGeometry) {
+    let expectedNumber;
+    if (olGeometry instanceof OlCircle) {
+        expectedNumber = 0;
+    }
+    else {
+        expectedNumber = Math.max(olGeometry.getFlatCoordinates().length / 2 - 1, 0);
+    }
+    // TODO: This works but it's quite messy. If time permits,
+    // clean this. Maybe a Tooltip class could handle that
+    let olMidpoints = olGeometry.get('_midpoints');
+    if (olMidpoints === undefined) {
+        if (olGeometry instanceof OlPoint) {
+            olMidpoints = new Array(1);
+        }
+        else {
+            olMidpoints = new Array(expectedNumber);
+        }
+        olGeometry.set('_midpoints', olMidpoints, true);
+        return olMidpoints;
+    }
+    if (expectedNumber === 0) {
+        return olMidpoints;
+    }
+    if (expectedNumber === olMidpoints.length) {
+        return olMidpoints;
+    }
+    if (expectedNumber > olMidpoints.length) {
+        olMidpoints.push(...new Array(expectedNumber - olMidpoints.length));
+        return olMidpoints;
+    }
+    for (let i = expectedNumber; i < olMidpoints.length; i++) {
+        const olMidpoint = olMidpoints[expectedNumber];
+        if (olMidpoint !== undefined) {
+            clearOlMidpointTooltip(olMidpoint);
+        }
+    }
+    olMidpoints.splice(expectedNumber);
+    return olMidpoints;
+}
+/**
+ * Remove an OL midpoint's tooltip from the map
+ * @param olMidpoint OL Point
+ */
+function clearOlMidpointTooltip(olMidpoint) {
+    const olTooltip = olMidpoint.get('_tooltip');
+    if (olTooltip !== undefined) {
+        const olMap = olTooltip.getMap();
+        if (olMap !== undefined) {
+            olMap.removeOverlay(olTooltip);
+        }
+    }
+}
+/**
+ * Add an OL overlay at each midpoint and return an array of those overlays
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function updateOlTooltipsAtMidpoints(olGeometry) {
+    const olMidpoints = updateOlGeometryMidpoints(olGeometry);
+    let typeGeom = '';
+    if (olGeometry instanceof OlLineString) {
+        typeGeom = 'line-';
+    }
+    else if (olGeometry instanceof OlPolygon) {
+        typeGeom = 'polygone-';
+    }
+    const olTooltips = olMidpoints.map((olMidpoint) => {
+        let olTooltip = olMidpoint.get('_tooltip');
+        if (olTooltip === undefined) {
+            olTooltip = createOlTooltipAtPoint(olMidpoint, false, typeGeom);
+        }
+        else {
+            olTooltip.setPosition(olMidpoint.getFlatCoordinates());
+        }
+        return olTooltip;
+    });
+    return olTooltips;
+}
+/**
+ * Return an array of OL overlay at midspoints, if any
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function getOlTooltipsAtMidpoints(olGeometry) {
+    const olMidpoints = getOlGeometryMidpoints(olGeometry);
+    return olMidpoints.map((olMidpoint) => {
+        return olMidpoint ? olMidpoint.get('_tooltip') : undefined;
+    });
+}
+/**
+ * Update an OL geometry center and return it
+ * @param olGeometry OL Geometry
+ * @returns OL point
+ */
+export function updateOlGeometryCenter(olGeometry) {
+    let olCenter = olGeometry.get('_center');
+    const centerCoordinate = olGetCenter(olGeometry.getExtent());
+    if (olCenter !== undefined) {
+        olCenter.setCoordinates(centerCoordinate);
+    }
+    else {
+        olCenter = new OlPoint(centerCoordinate);
+        olGeometry.set('_center', olCenter);
+    }
+    return olCenter;
+}
+/**
+ * Add an OL overlay at the center of a geometry and return that overlay
+ * @param olGeometry OL Geometry
+ * @returns OL overlay
+ */
+export function updateOlTooltipAtCenter(olGeometry) {
+    const olCenter = updateOlGeometryCenter(olGeometry);
+    let olTooltip = olCenter.get('_tooltip');
+    if (olTooltip === undefined) {
+        olTooltip = createOlTooltipAtPoint(olCenter, true);
+    }
+    else {
+        olTooltip.setPosition(olCenter.getFlatCoordinates());
+    }
+    return olTooltip;
+}
+/**
+ * Return an array of OL overlay at midspoints, if any
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function getOlTooltipAtCenter(olGeometry) {
+    const olCenter = olGeometry.get('_center');
+    return olCenter ? olCenter.get('_tooltip') : undefined;
+}
+/**
+ * Get all the tooltips of an OL geometry
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function getTooltipsOfOlGeometry(olGeometry) {
+    const olTooltips = [].concat(getOlTooltipsAtMidpoints(olGeometry) || []);
+    const olCenterTooltip = getOlTooltipAtCenter(olGeometry);
+    if (olCenterTooltip !== undefined) {
+        olTooltips.push(olCenterTooltip);
+    }
+    return olTooltips;
+}
+/**
+ * Create an OL overlay at a point and bind the overlay to the point
+ * @param olPoint OL Point
+ * @returns OL overlay
+ */
+export function createOlTooltipAtPoint(olPoint, center = false, srcGeomType = '') {
+    const olTooltip = new OlOverlay({
+        element: document.createElement('div'),
+        offset: [-30, -10],
+        className: (center
+            ? [
+                'igo-map-tooltip',
+                'igo-map-tooltip-measure',
+                'igo-map-tooltip-measure-area'
+            ]
+            : [
+                'igo-map-tooltip',
+                'igo-map-tooltip-measure',
+                `igo-map-tooltip-measure-${srcGeomType}segments`
+            ]).join(' '),
+        stopEvent: false
+    });
+    olTooltip.setPosition(olPoint.getFlatCoordinates());
+    olPoint.set('_tooltip', olTooltip);
+    return olTooltip;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measure.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/measure/shared/measure.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { LanguageService } from '@igo2/core/language';\n\nimport OlOverlay from 'ol/Overlay';\nimport { getCenter as olGetCenter } from 'ol/extent';\nimport OlCircle from 'ol/geom/Circle';\nimport OlLineString from 'ol/geom/LineString';\nimport OlPoint from 'ol/geom/Point';\nimport OlPolygon from 'ol/geom/Polygon';\nimport { getArea as olGetArea, getLength as olGetLength } from 'ol/sphere';\nimport * as olstyle from 'ol/style';\n\nimport {\n  MeasureAreaUnit,\n  MeasureAreaUnitAbbreviation,\n  MeasureLengthUnit,\n  MeasureLengthUnitAbbreviation\n} from './measure.enum';\nimport { Measure } from './measure.interfaces';\n\n/**\n * Convert value from meters to kilometers\n * @param value Value in meters\n * @returns Value in kilometers\n */\nexport function metersToKilometers(value: number): number {\n  return value * 0.001;\n}\n\n/**\n * Convert value from meters to feet\n * @param value Value in meters\n * @returns Value in feet\n */\nexport function metersToFeet(value: number): number {\n  return value * 3.2808;\n}\n\n/**\n * Convert value from meters to miles\n * @param value Value in meters\n * @returns Value in miles\n */\nexport function metersToMiles(value: number): number {\n  return value * 0.000621;\n}\n\n/**\n * Convert value from square meters to square kilometers\n * @param value Value in square meters\n * @returns Value in square kilometers\n */\nexport function squareMetersToSquareKilometers(value: number): number {\n  return value * 0.000001;\n}\n\n/**\n * Convert value from square meters to square miles\n * @param value Value in square meters\n * @returns Value in square miles\n */\nexport function squareMetersToSquareMiles(value: number): number {\n  return value * 0.0000003861;\n}\n\n/**\n * Convert value from square meters to square feet\n * @param value Value in square meters\n * @returns Value in square feet\n */\nexport function squareMetersToSquareFeet(value: number): number {\n  return value * 10.764;\n}\n\n/**\n * Convert value from square meters to hectares\n * @param value Value in square meters\n * @returns Value in hectares\n */\nexport function squareMetersToHectares(value: number): number {\n  return value * 0.0001;\n}\n\n/**\n * Convert value from square meters to acres\n * @param value Value in square meters\n * @returns Value in acres\n */\nexport function squareMetersToAcres(value: number): number {\n  return value * 0.00024711;\n}\n\n/**\n * Convert value from meters to the specified length unit\n * @param value Value in meters\n * @param unit Length unit\n * @returns Value in unit\n */\nexport function metersToUnit(\n  value: number,\n  unit: MeasureLengthUnit\n): number | undefined {\n  const conversionMapper = new Map([\n    [MeasureLengthUnit.Meters, (val: number) => val],\n    [MeasureLengthUnit.Kilometers, metersToKilometers],\n    [MeasureLengthUnit.Miles, metersToMiles],\n    [MeasureLengthUnit.Feet, metersToFeet]\n  ]);\n  const conversion = conversionMapper.get(unit);\n\n  return conversion ? conversion(value) : undefined;\n}\n\n/**\n * Convert value from square meters to the specified area unit\n * @param value Value in meters\n * @param unit Area unit\n * @returns Value in unit\n */\nexport function squareMetersToUnit(\n  value: number,\n  unit: MeasureAreaUnit\n): number | undefined {\n  const conversionMapper = new Map([\n    [MeasureAreaUnit.SquareMeters, (val: number) => val],\n    [MeasureAreaUnit.SquareKilometers, squareMetersToSquareKilometers],\n    [MeasureAreaUnit.SquareMiles, squareMetersToSquareMiles],\n    [MeasureAreaUnit.SquareFeet, squareMetersToSquareFeet],\n    [MeasureAreaUnit.Hectares, squareMetersToHectares],\n    [MeasureAreaUnit.Acres, squareMetersToAcres]\n  ]);\n  const conversion = conversionMapper.get(unit);\n\n  return conversion ? conversion(value) : undefined;\n}\n\n/**\n * This method format a measure to a readable format\n * @param measure Measure\n * @param options Formatting options\n * @returns Formatted measure\n */\nexport function formatMeasure(\n  measure: number,\n  options?: {\n    decimal?: number;\n    unit?: MeasureAreaUnit | MeasureLengthUnit;\n    unitAbbr?: boolean;\n    locale?: string;\n  },\n  languageService?: LanguageService\n) {\n  let decimal = options.decimal;\n  if (decimal === undefined || decimal < 0) {\n    decimal = 1;\n  }\n\n  const parts = [];\n  if (options.locale !== undefined) {\n    parts.push(\n      measure.toLocaleString(options.locale, {\n        minimumFractionDigits: decimal,\n        maximumFractionDigits: decimal\n      })\n    );\n  } else {\n    parts.push(measure.toFixed(decimal).toString());\n  }\n\n  if (options.unit !== undefined && options.unitAbbr === true) {\n    if (languageService) {\n      parts.push(\n        MeasureLengthUnitAbbreviation[options.unit]\n          ? languageService.translate.instant(\n              'igo.geo.measure.' + MeasureLengthUnitAbbreviation[options.unit]\n            )\n          : languageService.translate.instant(\n              'igo.geo.measure.' + MeasureAreaUnitAbbreviation[options.unit]\n            )\n      );\n    } else {\n      parts.push(\n        MeasureLengthUnitAbbreviation[options.unit] ||\n          MeasureAreaUnitAbbreviation[options.unit]\n      );\n    }\n  }\n\n  return parts.filter((p) => p !== undefined).join(' ');\n}\n\n/**\n * Compute best length measure unit for a given measure in meters\n * @param value Value in meters\n * @returns Measure unit\n */\nexport function computeBestLengthUnit(value: number): MeasureLengthUnit {\n  let unit = MeasureLengthUnit.Meters;\n  let converted = value;\n  const possibleUnits = [MeasureLengthUnit.Kilometers];\n  while (converted > 1000 && possibleUnits.length > 0) {\n    unit = possibleUnits.pop();\n    converted = metersToUnit(value, unit);\n  }\n  return unit;\n}\n\n/**\n * Compute best length measure unit for a given measure in square meters\n * @param value Value in meters\n * @returns Measure unit\n */\nexport function computeBestAreaUnit(value: number): MeasureAreaUnit {\n  let unit = MeasureAreaUnit.SquareMeters;\n  let converted = value;\n  const possibleUnits = [MeasureAreaUnit.SquareKilometers];\n  while (converted > 1000000 && possibleUnits.length > 0) {\n    unit = possibleUnits.pop();\n    converted = squareMetersToUnit(value, unit);\n  }\n  return unit;\n}\n\n/**\n * Create a default style for a measure interaction\n * @returns OL style\n */\nexport function createMeasureInteractionStyle(): olstyle.Style {\n  return new olstyle.Style({\n    stroke: new olstyle.Stroke({\n      color: '#ffcc33',\n      lineDash: [10, 10],\n      width: 2\n    }),\n    fill: new olstyle.Fill({\n      color: 'rgba(255, 255, 255, 0.2)'\n    }),\n    image: new olstyle.Circle({\n      radius: 5,\n      stroke: new olstyle.Stroke({\n        color: '#ffcc33'\n      }),\n      fill: new olstyle.Fill({\n        color: 'rgba(255, 255, 255, 0.2)'\n      })\n    })\n  });\n}\n\n/**\n * Create a default style for a measure layer\n * @returns OL style\n */\nexport function createMeasureLayerStyle(): olstyle.Style {\n  return new olstyle.Style({\n    stroke: new olstyle.Stroke({\n      color: '#ffcc33',\n      width: 2\n    }),\n    fill: new olstyle.Fill({\n      color: 'rgba(255, 255, 255, 0.2)'\n    })\n  });\n}\n\n/**\n * Compute the length in meters of an OL geometry with a given projection\n * @param olGeometry Ol geometry\n * @param projection olGeometry's projection\n * @returns Length in meters\n */\nexport function measureOlGeometryLength(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle,\n  projection: string\n): number | undefined {\n  if (olGeometry instanceof OlPoint) {\n    return undefined;\n  }\n  if (olGeometry.getFlatCoordinates().length === 0) {\n    return undefined;\n  }\n  return olGetLength(olGeometry, { projection });\n}\n\n/**\n * Compute the area in square meters of an OL geometry with a given projection\n * @param olGeometry Ol geometry\n * @param projection olGeometry's projection\n * @returns Area in square meters\n */\nexport function measureOlGeometryArea(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle,\n  projection: string\n): number | undefined {\n  if (olGeometry instanceof OlPoint || olGeometry instanceof OlLineString) {\n    return undefined;\n  }\n  if (olGeometry.getFlatCoordinates().length === 0) {\n    return undefined;\n  }\n  return olGetArea(olGeometry, { projection });\n}\n\n/**\n * Compute the area (square meters), length (meters) and last length (meters)\n * of an OL geometry with a given projection.\n * @param olGeometry Ol geometry\n * @param projection olGeometry's projection\n * @returns Computed measure\n */\nexport function measureOlGeometry(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle,\n  projection: string\n): Measure {\n  const length = measureOlGeometryLength(olGeometry, projection);\n  const area = measureOlGeometryArea(olGeometry, projection);\n\n  const lengths = [];\n  const coordinates = olGeometry.getFlatCoordinates();\n  const coordinatesLength = coordinates.length;\n  for (let i = 0; i <= coordinatesLength - 4; i += 2) {\n    const olSegment = new OlLineString([\n      [coordinates[i], coordinates[i + 1]],\n      [coordinates[i + 2], coordinates[i + 3]]\n    ]);\n\n    lengths.push(measureOlGeometryLength(olSegment, projection));\n  }\n\n  return {\n    area,\n    length,\n    lengths\n  };\n}\n\n/**\n * Update an OL geometry midpoints and return an array of those points\n * @param olGeometry OL Geometry\n * @returns OL points\n */\nexport function updateOlGeometryMidpoints(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlPoint[] {\n  let olMidpoints;\n  if (olGeometry instanceof OlPoint) {\n    const olMidpointPoint = new OlPoint(olGeometry.getFlatCoordinates());\n    olMidpoints = new Array(1);\n    olMidpoints[0] = olMidpointPoint;\n  } else {\n    olMidpoints = getOlGeometryMidpoints(olGeometry);\n    // TODO: handle multi geometries\n    const coordinates = olGeometry.getFlatCoordinates();\n    const midpointsLength = olMidpoints.length;\n    for (let i = 0; i < midpointsLength; i++) {\n      const j = i * 2;\n      const olSegment = new OlLineString([\n        [coordinates[j], coordinates[j + 1]],\n        [coordinates[j + 2], coordinates[j + 3]]\n      ]);\n\n      const midpointCoordinate = olSegment.getCoordinateAt(0.5);\n      const olMidpoint = olMidpoints[i];\n      if (olMidpoint !== undefined) {\n        olMidpoint.setCoordinates(midpointCoordinate);\n      } else {\n        olMidpoints[i] = new OlPoint(midpointCoordinate);\n      }\n    }\n  }\n  return olMidpoints;\n}\n\n/**\n * Clear an OL geometry midpoints and return an array of those points\n * @param olGeometry OL Geometry\n */\nexport function clearOlGeometryMidpoints(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n) {\n  const olMidpoints = olGeometry.get('_midpoints') || [];\n  const midpointsLength = olMidpoints.length;\n  for (let i = 0; i < midpointsLength; i++) {\n    const olMidpoint = olMidpoints[i];\n    if (olMidpoint !== undefined) {\n      if (olMidpoint !== undefined) {\n        clearOlMidpointTooltip(olMidpoint);\n      }\n    }\n  }\n\n  olGeometry.set('_midpoints', undefined, true);\n\n  return olMidpoints;\n}\n\n/**\n * Return an array of  OL geometry midpoints, if any\n * @param olGeometry OL Geometry\n * @returns OL points\n */\nfunction getOlGeometryMidpoints(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlPoint[] {\n  let expectedNumber;\n  if (olGeometry instanceof OlCircle) {\n    expectedNumber = 0;\n  } else {\n    expectedNumber = Math.max(\n      olGeometry.getFlatCoordinates().length / 2 - 1,\n      0\n    );\n  }\n  // TODO: This works but it's quite messy. If time permits,\n  // clean this. Maybe a Tooltip class could handle that\n  let olMidpoints = olGeometry.get('_midpoints');\n\n  if (olMidpoints === undefined) {\n    if (olGeometry instanceof OlPoint) {\n      olMidpoints = new Array(1);\n    } else {\n      olMidpoints = new Array(expectedNumber);\n    }\n    olGeometry.set('_midpoints', olMidpoints, true);\n    return olMidpoints;\n  }\n\n  if (expectedNumber === 0) {\n    return olMidpoints;\n  }\n\n  if (expectedNumber === olMidpoints.length) {\n    return olMidpoints;\n  }\n\n  if (expectedNumber > olMidpoints.length) {\n    olMidpoints.push(...new Array(expectedNumber - olMidpoints.length));\n    return olMidpoints;\n  }\n\n  for (let i = expectedNumber; i < olMidpoints.length; i++) {\n    const olMidpoint = olMidpoints[expectedNumber];\n    if (olMidpoint !== undefined) {\n      clearOlMidpointTooltip(olMidpoint);\n    }\n  }\n  olMidpoints.splice(expectedNumber);\n\n  return olMidpoints;\n}\n\n/**\n * Remove an OL midpoint's tooltip from the map\n * @param olMidpoint OL Point\n */\nfunction clearOlMidpointTooltip(olMidpoint: OlPoint) {\n  const olTooltip = olMidpoint.get('_tooltip');\n  if (olTooltip !== undefined) {\n    const olMap = olTooltip.getMap();\n    if (olMap !== undefined) {\n      olMap.removeOverlay(olTooltip);\n    }\n  }\n}\n\n/**\n * Add an OL overlay at each midpoint and return an array of those overlays\n * @param olGeometry OL Geometry\n * @returns OL overlays\n */\nexport function updateOlTooltipsAtMidpoints(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlOverlay[] {\n  const olMidpoints = updateOlGeometryMidpoints(olGeometry);\n  let typeGeom = '';\n  if (olGeometry instanceof OlLineString) {\n    typeGeom = 'line-';\n  } else if (olGeometry instanceof OlPolygon) {\n    typeGeom = 'polygone-';\n  }\n  const olTooltips = olMidpoints.map((olMidpoint: OlPoint) => {\n    let olTooltip = olMidpoint.get('_tooltip');\n    if (olTooltip === undefined) {\n      olTooltip = createOlTooltipAtPoint(olMidpoint, false, typeGeom);\n    } else {\n      olTooltip.setPosition(olMidpoint.getFlatCoordinates());\n    }\n    return olTooltip;\n  });\n  return olTooltips;\n}\n\n/**\n * Return an array of OL overlay at midspoints, if any\n * @param olGeometry OL Geometry\n * @returns OL overlays\n */\nexport function getOlTooltipsAtMidpoints(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlOverlay[] {\n  const olMidpoints = getOlGeometryMidpoints(olGeometry);\n  return olMidpoints.map((olMidpoint: OlPoint) => {\n    return olMidpoint ? olMidpoint.get('_tooltip') : undefined;\n  });\n}\n\n/**\n * Update an OL geometry center and return it\n * @param olGeometry OL Geometry\n * @returns OL point\n */\nexport function updateOlGeometryCenter(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlPoint {\n  let olCenter = olGeometry.get('_center');\n  const centerCoordinate = olGetCenter(olGeometry.getExtent());\n  if (olCenter !== undefined) {\n    olCenter.setCoordinates(centerCoordinate);\n  } else {\n    olCenter = new OlPoint(centerCoordinate);\n    olGeometry.set('_center', olCenter);\n  }\n\n  return olCenter;\n}\n\n/**\n * Add an OL overlay at the center of a geometry and return that overlay\n * @param olGeometry OL Geometry\n * @returns OL overlay\n */\nexport function updateOlTooltipAtCenter(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlOverlay {\n  const olCenter = updateOlGeometryCenter(olGeometry);\n  let olTooltip = olCenter.get('_tooltip');\n  if (olTooltip === undefined) {\n    olTooltip = createOlTooltipAtPoint(olCenter, true);\n  } else {\n    olTooltip.setPosition(olCenter.getFlatCoordinates());\n  }\n  return olTooltip;\n}\n\n/**\n * Return an array of OL overlay at midspoints, if any\n * @param olGeometry OL Geometry\n * @returns OL overlays\n */\nexport function getOlTooltipAtCenter(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlOverlay {\n  const olCenter = olGeometry.get('_center');\n  return olCenter ? olCenter.get('_tooltip') : undefined;\n}\n\n/**\n * Get all the tooltips of an OL geometry\n * @param olGeometry OL Geometry\n * @returns OL overlays\n */\nexport function getTooltipsOfOlGeometry(\n  olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle\n): OlOverlay[] {\n  const olTooltips = [].concat(getOlTooltipsAtMidpoints(olGeometry) || []);\n  const olCenterTooltip = getOlTooltipAtCenter(olGeometry);\n  if (olCenterTooltip !== undefined) {\n    olTooltips.push(olCenterTooltip);\n  }\n  return olTooltips;\n}\n\n/**\n * Create an OL overlay at a point and bind the overlay to the point\n * @param olPoint OL Point\n * @returns OL overlay\n */\nexport function createOlTooltipAtPoint(\n  olPoint: OlPoint,\n  center = false,\n  srcGeomType = ''\n): OlOverlay {\n  const olTooltip = new OlOverlay({\n    element: document.createElement('div'),\n    offset: [-30, -10],\n    className: (center\n      ? [\n          'igo-map-tooltip',\n          'igo-map-tooltip-measure',\n          'igo-map-tooltip-measure-area'\n        ]\n      : [\n          'igo-map-tooltip',\n          'igo-map-tooltip-measure',\n          `igo-map-tooltip-measure-${srcGeomType}segments`\n        ]\n    ).join(' '),\n    stopEvent: false\n  });\n  olTooltip.setPosition(olPoint.getFlatCoordinates());\n  olPoint.set('_tooltip', olTooltip);\n\n  return olTooltip;\n}\n"]}

package/esm2022/lib/metadata/index.mjs

@@ -0,0 +1,4 @@
+export * from './shared';
+export * from './metadata.module';
+export * from './metadata-button';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tZXRhZGF0YS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NoYXJlZCc7XG5leHBvcnQgKiBmcm9tICcuL21ldGFkYXRhLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL21ldGFkYXRhLWJ1dHRvbic7XG4iXX0=

package/esm2022/lib/metadata/metadata-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './metadata-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tZXRhZGF0YS9tZXRhZGF0YS1idXR0b24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWV0YWRhdGEtYnV0dG9uLmNvbXBvbmVudCc7XG4iXX0=