@igo2/geo 1.15.4 → 16.0.0-rc.1

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

@@ -0,0 +1,456 @@
+import * as olproj from 'ol/proj';
+import { MAC } from 'ol/has';
+import { NumberUtils } from '@igo2/utils';
+/**
+ * This method extracts a coordinate tuple from a string.
+ * @param str Any string
+ * @param mapProjection string Map Projection
+ * @param opts.forceNA boolean Force North America Zone
+ * @returns object:
+ *             lonLat: Coordinate,
+ *             message: Message of error,
+ *             radius: radius of the confience of coordinate,
+ *             conf: confidence of the coordinate}
+ */
+export function stringToLonLat(str, mapProjection, opts = {}) {
+    let lonLat;
+    let coordStr;
+    let negativeLon;
+    let degreesLon;
+    let minutesLon;
+    let secondsLon;
+    let directionLon;
+    let decimalLon;
+    let negativeLat;
+    let degreesLat;
+    let minutesLat;
+    let secondsLat;
+    let directionLat;
+    let decimalLat;
+    let zone;
+    let radius;
+    let conf;
+    let lon;
+    let lat;
+    const projectionPattern = '(\\s*;\\s*[\\d]{4,6})';
+    const toProjection = '4326';
+    let projectionStr;
+    const projectionRegex = new RegExp(projectionPattern, 'g');
+    const lonlatCoord = '([-+])?([\\d]{1,3})([,.](\\d+))?';
+    const lonLatPattern = `${lonlatCoord}[\\s,]+${lonlatCoord}`;
+    const lonLatRegex = new RegExp(`^${lonLatPattern}$`, 'g');
+    const dmsCoord = '([0-9]{1,2})[:|°]?\\s*([0-9]{1,2})?[:|\'|′|’]?\\s*([0-9]{1,2}(?:.[0-9]+){0,1})?\\s*["|″|”]?\\s*';
+    const dmsCoordPattern = `${dmsCoord}([N|S|E|W|O]),?\\s*${dmsCoord}([N|S|E|W|O])`;
+    const dmsRegex = new RegExp(`^${dmsCoordPattern}$`, 'gi');
+    const patternUtm = '(UTM)-?(\\d{1,2})[\\s,]*(\\d+[.,]?\\d+)[\\s,]+(\\d+[.,]?\\d+)';
+    const utmRegex = new RegExp(`^${patternUtm}`, 'gi');
+    const patternMtm = '(MTM)-?(\\d{1,2})[\\s,]*(\\d+[.,]?\\d+)[\\s,]+(\\d+[.,]?\\d+)';
+    const mtmRegex = new RegExp(`^${patternMtm}`, 'gi');
+    const ddCoord = '([-+])?(\\d{1,3})[,.](\\d+)';
+    const patternDd = `${ddCoord}\\s*[,]?\\s*${ddCoord}`;
+    const ddRegex = new RegExp(`^${patternDd}`, 'g');
+    const dmdCoord = '([-+])?(\\d{1,3})[\\s,.]{1}(\\d{1,2})[\\s,.]{1}(\\d{1,2})[.,]?(\\d{1,5})?';
+    const patternDmd = `${dmdCoord}\\s*[,.]?\\s*${dmdCoord}`;
+    const dmdRegex = new RegExp(`^${patternDmd}`, 'g');
+    /* eslint-disable max-len */
+    const patternBELL = 'LAT\\s*[\\s:]*\\s*([-+])?(\\d{1,2})[\\s.,]?(\\d+)?[\\s.,]?\\s*(\\d{1,2}([.,]\\d+)?)?\\s*(N|S|E|W)?\\s*LONG\\s*[\\s:]*\\s*([-+])?(\\d{1,3})[\\s.,]?(\\d+)?[\\s.,]?\\s*(\\d{1,2}([.,]\\d+)?)?\\s*(N|S|E|W)?\\s*UNC\\s*[\\s:]?\\s*(\\d+)\\s*CONF\\s*[\\s:]?\\s*(\\d{1,3})';
+    const bellRegex = new RegExp(`^${patternBELL}?`, 'gi');
+    const mmCoord = '([-+]?\\d+)[,.]?(\\d+)?';
+    const mmPattern = `${mmCoord}[\\s,]+${mmCoord}`;
+    const mmRegex = new RegExp(`^${mmPattern}$`, 'g');
+    let isXYCoords = false;
+    str = str.toLocaleUpperCase().trim();
+    // Extract projection
+    if (projectionRegex.test(str)) {
+        [coordStr, projectionStr] = str.split(';').map((s) => s.trim());
+    }
+    else {
+        coordStr = str;
+    }
+    if (lonLatRegex.test(coordStr)) {
+        [, negativeLon, lon, , decimalLon, negativeLat, lat, , decimalLat] =
+            coordStr.match(lonLatPattern);
+        lon = parseFloat((negativeLon ? negativeLon : '') + lon + '.' + decimalLon);
+        lat = parseFloat((negativeLat ? negativeLat : '') + lat + '.' + decimalLat);
+    }
+    else if (dmsRegex.test(coordStr)) {
+        [
+            ,
+            degreesLon,
+            minutesLon,
+            secondsLon,
+            directionLon,
+            degreesLat,
+            minutesLat,
+            secondsLat,
+            directionLat
+        ] = coordStr.match(dmsCoordPattern);
+        if (directionLon === 'S' || directionLon === 'N') {
+            degreesLon = [degreesLat, (degreesLat = degreesLon)][0];
+            minutesLon = [minutesLat, (minutesLat = minutesLon)][0];
+            secondsLon = [secondsLat, (secondsLat = secondsLon)][0];
+            directionLon = [directionLat, (directionLat = directionLon)][0];
+        }
+        lon = convertDMSToDD(parseFloat(degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        lat = convertDMSToDD(parseFloat(degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+    }
+    else if (utmRegex.test(coordStr)) {
+        isXYCoords = true;
+        [, , zone, lon, lat] = coordStr.match(patternUtm);
+        const epsgUtm = Number(zone) < 10 ? `EPSG:3260${zone}` : `EPSG:326${zone}`;
+        [lon, lat] = olproj.transform([parseFloat(lon), parseFloat(lat)], epsgUtm, 'EPSG:4326');
+    }
+    else if (mtmRegex.test(coordStr)) {
+        isXYCoords = true;
+        [, , zone, lon, lat] = coordStr.match(patternMtm);
+        const epsgMtm = Number(zone) < 10 ? `EPSG:3218${zone}` : `EPSG:321${80 + Number(zone)}`;
+        [lon, lat] = olproj.transform([parseFloat(lon), parseFloat(lat)], epsgMtm, 'EPSG:4326');
+    }
+    else if (dmdRegex.test(coordStr)) {
+        [
+            ,
+            negativeLon,
+            degreesLon,
+            minutesLon,
+            secondsLon,
+            decimalLon,
+            negativeLat,
+            degreesLat,
+            minutesLat,
+            secondsLat,
+            decimalLat
+        ] = coordStr.match(patternDmd);
+        lon = convertDMSToDD(parseFloat((negativeLon ? negativeLon : '') + degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        lat = convertDMSToDD(parseFloat((negativeLat ? negativeLat : '') + degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+    }
+    else if (ddRegex.test(coordStr)) {
+        [
+            ,
+            negativeLon,
+            degreesLon,
+            decimalLon,
+            negativeLat,
+            degreesLat,
+            decimalLat
+        ] = coordStr.match(patternDd);
+        lon = convertDMSToDD(parseFloat((negativeLon ? negativeLon : '') + degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        lat = convertDMSToDD(parseFloat((negativeLat ? negativeLat : '') + degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+    }
+    else if (bellRegex.test(coordStr)) {
+        [
+            ,
+            negativeLat,
+            degreesLat,
+            minutesLat,
+            secondsLat,
+            ,
+            directionLat,
+            negativeLon,
+            degreesLon,
+            minutesLon,
+            secondsLon,
+            ,
+            directionLon,
+            radius,
+            conf
+        ] = coordStr.match(patternBELL);
+        // Set default value for North America
+        if (!directionLon) {
+            directionLon = 'W';
+        }
+        // Check if real minutes or decimals
+        if (minutesLon && minutesLon.length > 2) {
+            lon = parseFloat((negativeLon ? negativeLon : '') + degreesLon + '.' + minutesLon);
+        }
+        else {
+            lon = convertDMSToDD(parseFloat(degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        }
+        if (minutesLat && minutesLat.length > 2) {
+            lat = parseFloat((negativeLat ? negativeLat : '') + degreesLat + '.' + minutesLat);
+        }
+        else {
+            lat = convertDMSToDD(parseFloat(degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+        }
+    }
+    else if (mmRegex.test(coordStr)) {
+        isXYCoords = true;
+        [, lon, decimalLon, lat, decimalLat] = coordStr.match(mmPattern);
+        if (decimalLon) {
+            lon = parseFloat(lon + '.' + decimalLon);
+        }
+        if (decimalLat) {
+            lat = parseFloat(lat + '.' + decimalLat);
+        }
+    }
+    else {
+        return {
+            lonLat: undefined,
+            message: '',
+            radius: undefined,
+            conf: undefined
+        };
+    }
+    if (opts.forceNA && !isXYCoords) {
+        // Set a negative coordinate for North America zone
+        if (lon > 0 && lat > 0) {
+            if (lon > lat) {
+                lon = -lon;
+            }
+            else {
+                lat = -lat;
+            }
+        }
+        // Reverse coordinate to respect lonLat convention
+        if (lon > lat) {
+            lon = [lat, (lat = lon)][0];
+        }
+    }
+    lonLat = [Number(lon), Number(lat)];
+    // Reproject the coordinate if projection parameter have been set and coord is not 4326
+    if ((projectionStr !== undefined && projectionStr !== toProjection) ||
+        lonLat[0] > 180 ||
+        lonLat[0] < -180 ||
+        lonLat[1] > 90 ||
+        lonLat[1] < -90) {
+        const source = projectionStr ? 'EPSG:' + projectionStr : mapProjection;
+        const dest = 'EPSG:' + toProjection;
+        try {
+            lonLat = olproj.transform(lonLat, source, dest);
+        }
+        catch (e) {
+            return {
+                lonLat: undefined,
+                message: 'Projection ' + source + ' not supported',
+                radius: undefined,
+                conf: undefined
+            };
+        }
+    }
+    if (Math.abs(lonLat[0]) <= 180 && Math.abs(lonLat[1]) <= 90) {
+        return {
+            lonLat,
+            message: '',
+            radius: radius ? parseInt(radius, 10) : undefined,
+            conf: conf ? parseInt(conf, 10) : undefined
+        };
+    }
+    else {
+        return {
+            lonLat: undefined,
+            message: 'Coordinate out of Longitude/Latitude bounds',
+            radius: undefined,
+            conf: undefined
+        };
+    }
+}
+/**
+ * Convert degrees minutes seconds to dd
+ * @param degrees Degrees
+ * @param minutes Minutes
+ * @param seconds Seconds
+ * @param direction Direction
+ */
+function convertDMSToDD(degrees, minutes, seconds, direction) {
+    minutes = minutes || 0;
+    seconds = seconds || 0;
+    const neg = degrees < 0;
+    let dd = Math.abs(degrees) + minutes / 60 + seconds / 3600;
+    if (neg || direction === 'S' || direction === 'W') {
+        dd = -dd;
+    } // Don't do anything for N or E
+    return dd;
+}
+/**
+ * Convert dd to degrees minutes seconds
+ * @param lonLatDD longitude and latitude in dd
+ * @param decimal number of decimals for seconds
+ * @returns longitude and latitude in dms
+ */
+export function convertDDToDMS(lonLatDD, decimal = 3) {
+    const lonLatDMS = [];
+    lonLatDD.forEach((dd) => {
+        const degrees = dd < 0 ? Math.ceil(dd) : Math.floor(dd);
+        const int = dd < 0 ? (degrees - dd) * 60 : (dd - degrees) * 60;
+        const minutes = Math.floor(int);
+        const seconds = ((int - minutes) * 60).toFixed(decimal);
+        lonLatDMS.push(`${degrees}° ${minutes}' ${seconds}"`);
+    });
+    return lonLatDMS;
+}
+/**
+ * Return true of two view states are equal.
+ * @param state1 View state
+ * @param state2 View state
+ * @returns True if the view states are equal
+ */
+export function viewStatesAreEqual(state1, state2) {
+    if (state1 === undefined || state2 === undefined) {
+        return false;
+    }
+    const tolerance = 1 / 10000;
+    return (state1.zoom === state2.zoom &&
+        Math.trunc(state1.center[0] / tolerance) ===
+            Math.trunc(state2.center[0] / tolerance) &&
+        Math.trunc(state1.center[1] / tolerance) ===
+            Math.trunc(state2.center[1] / tolerance));
+}
+/**
+ * Format the scale to a human readable text
+ * @param Scale of the map
+ * @returns Human readable scale text
+ */
+export function formatScale(scale) {
+    scale = Math.round(scale);
+    if (scale < 10000) {
+        return scale + '';
+    }
+    scale = Math.round(scale / 1000);
+    if (scale < 1000) {
+        return scale + 'K';
+    }
+    scale = Math.round(scale / 1000);
+    return scale + 'M';
+}
+/**
+ * Return the resolution from a scale denom
+ * @param scale Scale denom
+ * @param dpi DPI
+ * @returns Resolution
+ */
+export function getResolutionFromScale(scale, dpi = 96) {
+    const inchesPerMeter = 39.3701;
+    return scale / (inchesPerMeter * dpi);
+}
+/**
+ * Return the resolution from a scale denom
+ * @param Scale denom
+ * @returns Resolution
+ */
+export function getScaleFromResolution(resolution, unit = 'm', dpi = 96) {
+    const inchesPerMeter = 39.3701;
+    return resolution * olproj.METERS_PER_UNIT[unit] * inchesPerMeter * dpi;
+}
+/**
+ * Returns true if the CTRL key is pushed during an Ol MapBrowserPointerEvent
+ * @param event OL MapBrowserPointerEvent
+ * @returns Whether the CTRL key is pushed
+ */
+export function ctrlKeyDown(event) {
+    const originalEvent = event.originalEvent;
+    return (!originalEvent.altKey &&
+        (MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&
+        !originalEvent.shiftKey);
+}
+export function roundCoordTo(coord, decimal = 3) {
+    return [
+        NumberUtils.roundToNDecimal(coord[0], decimal),
+        NumberUtils.roundToNDecimal(coord[1], decimal)
+    ];
+}
+export function roundCoordToString(coord, decimal = 3) {
+    return roundCoordTo(coord, decimal).map((r) => r.toString());
+}
+/**
+ * Returns an array of converted coordinates.
+ * Conversion is done for every configured projections
+ * and for the current UTM zone and MTM zone.
+ * @param lonLat [number, number] array of the coordinate to transform.
+ * @param projections  Projection[] Array of destination projection.
+ * @param reverseCoords To reverse coords from latLon to lonLat (search option)
+ * @returns Returns an array of converted coordinates.
+ */
+export function lonLatConversion(lonLat, projections) {
+    const rawCoord3857 = olproj.transform(lonLat, 'EPSG:4326', 'EPSG:3857');
+    const convertedLonLat = [
+        {
+            code: 'EPSG:3857',
+            alias: 'Web Mercator',
+            coord: rawCoord3857,
+            igo2CoordFormat: `${roundCoordTo(rawCoord3857).join(', ')} ; 3857`
+        }
+    ];
+    // detect the current utm zone.
+    const utmZone = utmZoneFromLonLat(lonLat);
+    const epsgUtm = utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;
+    const utmName = `UTM-${utmZone}`;
+    const rawCoordUtm = olproj.transform(lonLat, 'EPSG:4326', epsgUtm);
+    convertedLonLat.push({
+        code: epsgUtm,
+        alias: 'UTM',
+        coord: rawCoordUtm,
+        igo2CoordFormat: `${utmName} ${roundCoordTo(rawCoordUtm).join(', ')}`
+    });
+    // detect the current mtm zone.
+    const mtmZone = mtmZoneFromLonLat(lonLat);
+    if (mtmZone) {
+        const epsgMtm = mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;
+        const mtmName = `MTM-${mtmZone}`;
+        const rawCoordMtm = olproj.transform(lonLat, 'EPSG:4326', epsgMtm);
+        convertedLonLat.push({
+            code: epsgMtm,
+            alias: 'MTM',
+            coord: rawCoordMtm,
+            igo2CoordFormat: `${mtmName} ${roundCoordTo(rawCoordMtm).join(', ')}`
+        });
+    }
+    projections.forEach((projection) => {
+        const rawCoord = olproj.transform(lonLat, 'EPSG:4326', projection.code);
+        const numericEpsgCode = projection.code.split(':')[1];
+        convertedLonLat.push({
+            code: projection.code,
+            alias: projection.alias || projection.code,
+            coord: rawCoord,
+            igo2CoordFormat: `${roundCoordTo(rawCoord).join(', ')} ; ${numericEpsgCode}`
+        });
+    });
+    return convertedLonLat;
+}
+/**
+ * Detect the current utm zone of the lon/lat coordinate.
+ * @param lonLat [number, number] array of the coordinate to detect the UTM zone.
+ * @returns number The UTM zone.
+ */
+export function utmZoneFromLonLat(lonLat) {
+    return Math.ceil((lonLat[0] + 180) / 6);
+}
+/**
+ * Detect the current mtm zone of the lon/lat coordinate.
+ * @param lonLat [number, number] array of the coordinate to detect the MTM zone.
+ * @returns number The MTM zone. Undefined if outside of the mtm application zone.
+ */
+export function mtmZoneFromLonLat(lonLat) {
+    const long = lonLat[0];
+    let mtmZone;
+    if (long < -51 && long > -54) {
+        mtmZone = 1;
+    }
+    if (long < -54 && long > -57) {
+        mtmZone = 2;
+    }
+    if (long < -57 && long > -60) {
+        mtmZone = 3;
+    }
+    if (long < -60 && long > -63) {
+        mtmZone = 4;
+    }
+    if (long < -63 && long > -66) {
+        mtmZone = 5;
+    }
+    if (long < -66 && long > -69) {
+        mtmZone = 6;
+    }
+    if (long < -69 && long > -72) {
+        mtmZone = 7;
+    }
+    if (long < -72 && long > -75) {
+        mtmZone = 8;
+    }
+    if (long < -75 && long > -78) {
+        mtmZone = 9;
+    }
+    if (long < -78 && long > -81) {
+        mtmZone = 10;
+    }
+    return mtmZone;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/map.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as olproj from 'ol/proj';\nimport MapBrowserPointerEvent from 'ol/MapBrowserEvent';\nimport { MAC } from 'ol/has';\n\nimport { NumberUtils } from '@igo2/utils';\n\nimport { MapViewState } from './map.interface';\nimport { Projection } from './projection.interfaces';\n\n/**\n * This method extracts a coordinate tuple from a string.\n * @param str Any string\n * @param mapProjection string Map Projection\n * @param opts.forceNA boolean Force North America Zone\n * @returns object:\n *             lonLat: Coordinate,\n *             message: Message of error,\n *             radius: radius of the confience of coordinate,\n *             conf: confidence of the coordinate}\n */\nexport function stringToLonLat(\n  str: string,\n  mapProjection: string,\n  opts: { forceNA?: boolean } = {}\n): {\n  lonLat: [number, number] | undefined;\n  message: string;\n  radius: number | undefined;\n  conf: number | undefined;\n} {\n  let lonLat: [number, number];\n  let coordStr: string;\n  let negativeLon: string;\n  let degreesLon: string;\n  let minutesLon: string;\n  let secondsLon: string;\n  let directionLon: string;\n  let decimalLon: string;\n  let negativeLat: string;\n  let degreesLat: string;\n  let minutesLat: string;\n  let secondsLat: string;\n  let directionLat: string;\n  let decimalLat: string;\n  let zone: string;\n  let radius: string;\n  let conf: string;\n  let lon: any;\n  let lat: any;\n\n  const projectionPattern = '(\\\\s*;\\\\s*[\\\\d]{4,6})';\n  const toProjection = '4326';\n  let projectionStr: string;\n  const projectionRegex = new RegExp(projectionPattern, 'g');\n\n  const lonlatCoord = '([-+])?([\\\\d]{1,3})([,.](\\\\d+))?';\n  const lonLatPattern = `${lonlatCoord}[\\\\s,]+${lonlatCoord}`;\n  const lonLatRegex = new RegExp(`^${lonLatPattern}$`, 'g');\n\n  const dmsCoord =\n    '([0-9]{1,2})[:|°]?\\\\s*([0-9]{1,2})?[:|\\'|′|’]?\\\\s*([0-9]{1,2}(?:.[0-9]+){0,1})?\\\\s*[\"|″|”]?\\\\s*';\n  const dmsCoordPattern = `${dmsCoord}([N|S|E|W|O]),?\\\\s*${dmsCoord}([N|S|E|W|O])`;\n  const dmsRegex = new RegExp(`^${dmsCoordPattern}$`, 'gi');\n\n  const patternUtm =\n    '(UTM)-?(\\\\d{1,2})[\\\\s,]*(\\\\d+[.,]?\\\\d+)[\\\\s,]+(\\\\d+[.,]?\\\\d+)';\n  const utmRegex = new RegExp(`^${patternUtm}`, 'gi');\n\n  const patternMtm =\n    '(MTM)-?(\\\\d{1,2})[\\\\s,]*(\\\\d+[.,]?\\\\d+)[\\\\s,]+(\\\\d+[.,]?\\\\d+)';\n  const mtmRegex = new RegExp(`^${patternMtm}`, 'gi');\n\n  const ddCoord = '([-+])?(\\\\d{1,3})[,.](\\\\d+)';\n  const patternDd = `${ddCoord}\\\\s*[,]?\\\\s*${ddCoord}`;\n  const ddRegex = new RegExp(`^${patternDd}`, 'g');\n\n  const dmdCoord =\n    '([-+])?(\\\\d{1,3})[\\\\s,.]{1}(\\\\d{1,2})[\\\\s,.]{1}(\\\\d{1,2})[.,]?(\\\\d{1,5})?';\n  const patternDmd = `${dmdCoord}\\\\s*[,.]?\\\\s*${dmdCoord}`;\n  const dmdRegex = new RegExp(`^${patternDmd}`, 'g');\n\n  /* eslint-disable max-len */\n  const patternBELL =\n    'LAT\\\\s*[\\\\s:]*\\\\s*([-+])?(\\\\d{1,2})[\\\\s.,]?(\\\\d+)?[\\\\s.,]?\\\\s*(\\\\d{1,2}([.,]\\\\d+)?)?\\\\s*(N|S|E|W)?\\\\s*LONG\\\\s*[\\\\s:]*\\\\s*([-+])?(\\\\d{1,3})[\\\\s.,]?(\\\\d+)?[\\\\s.,]?\\\\s*(\\\\d{1,2}([.,]\\\\d+)?)?\\\\s*(N|S|E|W)?\\\\s*UNC\\\\s*[\\\\s:]?\\\\s*(\\\\d+)\\\\s*CONF\\\\s*[\\\\s:]?\\\\s*(\\\\d{1,3})';\n  const bellRegex = new RegExp(`^${patternBELL}?`, 'gi');\n\n  const mmCoord = '([-+]?\\\\d+)[,.]?(\\\\d+)?';\n  const mmPattern = `${mmCoord}[\\\\s,]+${mmCoord}`;\n  const mmRegex = new RegExp(`^${mmPattern}$`, 'g');\n\n  let isXYCoords = false;\n\n  str = str.toLocaleUpperCase().trim();\n\n  // Extract projection\n  if (projectionRegex.test(str)) {\n    [coordStr, projectionStr] = str.split(';').map((s) => s.trim());\n  } else {\n    coordStr = str;\n  }\n  if (lonLatRegex.test(coordStr)) {\n    [, negativeLon, lon, , decimalLon, negativeLat, lat, , decimalLat] =\n      coordStr.match(lonLatPattern);\n\n    lon = parseFloat((negativeLon ? negativeLon : '') + lon + '.' + decimalLon);\n    lat = parseFloat((negativeLat ? negativeLat : '') + lat + '.' + decimalLat);\n  } else if (dmsRegex.test(coordStr)) {\n    [\n      ,\n      degreesLon,\n      minutesLon,\n      secondsLon,\n      directionLon,\n      degreesLat,\n      minutesLat,\n      secondsLat,\n      directionLat\n    ] = coordStr.match(dmsCoordPattern);\n\n    if (directionLon === 'S' || directionLon === 'N') {\n      degreesLon = [degreesLat, (degreesLat = degreesLon)][0];\n      minutesLon = [minutesLat, (minutesLat = minutesLon)][0];\n      secondsLon = [secondsLat, (secondsLat = secondsLon)][0];\n      directionLon = [directionLat, (directionLat = directionLon)][0];\n    }\n\n    lon = convertDMSToDD(\n      parseFloat(degreesLon),\n      parseFloat(minutesLon),\n      parseFloat(secondsLon),\n      directionLon\n    );\n    lat = convertDMSToDD(\n      parseFloat(degreesLat),\n      parseFloat(minutesLat),\n      parseFloat(secondsLat),\n      directionLat\n    );\n  } else if (utmRegex.test(coordStr)) {\n    isXYCoords = true;\n    [, , zone, lon, lat] = coordStr.match(patternUtm);\n    const epsgUtm = Number(zone) < 10 ? `EPSG:3260${zone}` : `EPSG:326${zone}`;\n    [lon, lat] = olproj.transform(\n      [parseFloat(lon), parseFloat(lat)],\n      epsgUtm,\n      'EPSG:4326'\n    );\n  } else if (mtmRegex.test(coordStr)) {\n    isXYCoords = true;\n    [, , zone, lon, lat] = coordStr.match(patternMtm);\n    const epsgMtm =\n      Number(zone) < 10 ? `EPSG:3218${zone}` : `EPSG:321${80 + Number(zone)}`;\n    [lon, lat] = olproj.transform(\n      [parseFloat(lon), parseFloat(lat)],\n      epsgMtm,\n      'EPSG:4326'\n    );\n  } else if (dmdRegex.test(coordStr)) {\n    [\n      ,\n      negativeLon,\n      degreesLon,\n      minutesLon,\n      secondsLon,\n      decimalLon,\n      negativeLat,\n      degreesLat,\n      minutesLat,\n      secondsLat,\n      decimalLat\n    ] = coordStr.match(patternDmd);\n\n    lon = convertDMSToDD(\n      parseFloat((negativeLon ? negativeLon : '') + degreesLon),\n      parseFloat(minutesLon),\n      parseFloat(secondsLon),\n      directionLon\n    );\n    lat = convertDMSToDD(\n      parseFloat((negativeLat ? negativeLat : '') + degreesLat),\n      parseFloat(minutesLat),\n      parseFloat(secondsLat),\n      directionLat\n    );\n  } else if (ddRegex.test(coordStr)) {\n    [\n      ,\n      negativeLon,\n      degreesLon,\n      decimalLon,\n      negativeLat,\n      degreesLat,\n      decimalLat\n    ] = coordStr.match(patternDd);\n\n    lon = convertDMSToDD(\n      parseFloat((negativeLon ? negativeLon : '') + degreesLon),\n      parseFloat(minutesLon),\n      parseFloat(secondsLon),\n      directionLon\n    );\n    lat = convertDMSToDD(\n      parseFloat((negativeLat ? negativeLat : '') + degreesLat),\n      parseFloat(minutesLat),\n      parseFloat(secondsLat),\n      directionLat\n    );\n  } else if (bellRegex.test(coordStr)) {\n    [\n      ,\n      negativeLat,\n      degreesLat,\n      minutesLat,\n      secondsLat,\n      ,\n      directionLat,\n      negativeLon,\n      degreesLon,\n      minutesLon,\n      secondsLon,\n      ,\n      directionLon,\n      radius,\n      conf\n    ] = coordStr.match(patternBELL);\n\n    // Set default value for North America\n    if (!directionLon) {\n      directionLon = 'W';\n    }\n\n    // Check if real minutes or decimals\n    if (minutesLon && minutesLon.length > 2) {\n      lon = parseFloat(\n        (negativeLon ? negativeLon : '') + degreesLon + '.' + minutesLon\n      );\n    } else {\n      lon = convertDMSToDD(\n        parseFloat(degreesLon),\n        parseFloat(minutesLon),\n        parseFloat(secondsLon),\n        directionLon\n      );\n    }\n\n    if (minutesLat && minutesLat.length > 2) {\n      lat = parseFloat(\n        (negativeLat ? negativeLat : '') + degreesLat + '.' + minutesLat\n      );\n    } else {\n      lat = convertDMSToDD(\n        parseFloat(degreesLat),\n        parseFloat(minutesLat),\n        parseFloat(secondsLat),\n        directionLat\n      );\n    }\n  } else if (mmRegex.test(coordStr)) {\n    isXYCoords = true;\n    [, lon, decimalLon, lat, decimalLat] = coordStr.match(mmPattern);\n\n    if (decimalLon) {\n      lon = parseFloat(lon + '.' + decimalLon);\n    }\n\n    if (decimalLat) {\n      lat = parseFloat(lat + '.' + decimalLat);\n    }\n  } else {\n    return {\n      lonLat: undefined,\n      message: '',\n      radius: undefined,\n      conf: undefined\n    };\n  }\n\n  if (opts.forceNA && !isXYCoords) {\n    // Set a negative coordinate for North America zone\n    if (lon > 0 && lat > 0) {\n      if (lon > lat) {\n        lon = -lon;\n      } else {\n        lat = -lat;\n      }\n    }\n\n    // Reverse coordinate to respect lonLat convention\n    if (lon > lat) {\n      lon = [lat, (lat = lon)][0];\n    }\n  }\n\n  lonLat = [Number(lon), Number(lat)] as [number, number];\n\n  // Reproject the coordinate if projection parameter have been set and coord is not 4326\n  if (\n    (projectionStr !== undefined && projectionStr !== toProjection) ||\n    lonLat[0] > 180 ||\n    lonLat[0] < -180 ||\n    lonLat[1] > 90 ||\n    lonLat[1] < -90\n  ) {\n    const source = projectionStr ? 'EPSG:' + projectionStr : mapProjection;\n    const dest = 'EPSG:' + toProjection;\n\n    try {\n      lonLat = olproj.transform(lonLat, source, dest) as [number, number];\n    } catch (e) {\n      return {\n        lonLat: undefined,\n        message: 'Projection ' + source + ' not supported',\n        radius: undefined,\n        conf: undefined\n      };\n    }\n  }\n  if (Math.abs(lonLat[0]) <= 180 && Math.abs(lonLat[1]) <= 90) {\n    return {\n      lonLat,\n      message: '',\n      radius: radius ? parseInt(radius, 10) : undefined,\n      conf: conf ? parseInt(conf, 10) : undefined\n    };\n  } else {\n    return {\n      lonLat: undefined,\n      message: 'Coordinate out of Longitude/Latitude bounds',\n      radius: undefined,\n      conf: undefined\n    };\n  }\n}\n\n/**\n * Convert degrees minutes seconds to dd\n * @param degrees Degrees\n * @param minutes Minutes\n * @param seconds Seconds\n * @param direction Direction\n */\nfunction convertDMSToDD(\n  degrees: number,\n  minutes: number,\n  seconds: number,\n  direction: string\n) {\n  minutes = minutes || 0;\n  seconds = seconds || 0;\n\n  const neg = degrees < 0;\n  let dd = Math.abs(degrees) + minutes / 60 + seconds / 3600;\n\n  if (neg || direction === 'S' || direction === 'W') {\n    dd = -dd;\n  } // Don't do anything for N or E\n  return dd;\n}\n\n/**\n * Convert dd to degrees minutes seconds\n * @param lonLatDD longitude and latitude in dd\n * @param decimal number of decimals for seconds\n * @returns longitude and latitude in dms\n */\nexport function convertDDToDMS(\n  lonLatDD: [number, number],\n  decimal: number = 3\n): string[] {\n  const lonLatDMS = [];\n\n  lonLatDD.forEach((dd) => {\n    const degrees = dd < 0 ? Math.ceil(dd) : Math.floor(dd);\n    const int = dd < 0 ? (degrees - dd) * 60 : (dd - degrees) * 60;\n    const minutes = Math.floor(int);\n    const seconds = ((int - minutes) * 60).toFixed(decimal);\n\n    lonLatDMS.push(`${degrees}° ${minutes}' ${seconds}\"`);\n  });\n  return lonLatDMS;\n}\n\n/**\n * Return true of two view states are equal.\n * @param state1 View state\n * @param state2 View state\n * @returns True if the view states are equal\n */\nexport function viewStatesAreEqual(\n  state1: MapViewState,\n  state2: MapViewState\n): boolean {\n  if (state1 === undefined || state2 === undefined) {\n    return false;\n  }\n\n  const tolerance = 1 / 10000;\n  return (\n    state1.zoom === state2.zoom &&\n    Math.trunc(state1.center[0] / tolerance) ===\n      Math.trunc(state2.center[0] / tolerance) &&\n    Math.trunc(state1.center[1] / tolerance) ===\n      Math.trunc(state2.center[1] / tolerance)\n  );\n}\n\n/**\n * Format the scale to a human readable text\n * @param Scale of the map\n * @returns Human readable scale text\n */\nexport function formatScale(scale) {\n  scale = Math.round(scale);\n  if (scale < 10000) {\n    return scale + '';\n  }\n\n  scale = Math.round(scale / 1000);\n  if (scale < 1000) {\n    return scale + 'K';\n  }\n\n  scale = Math.round(scale / 1000);\n  return scale + 'M';\n}\n\n/**\n * Return the resolution from a scale denom\n * @param scale Scale denom\n * @param dpi DPI\n * @returns Resolution\n */\nexport function getResolutionFromScale(\n  scale: number,\n  dpi: number = 96\n): number {\n  const inchesPerMeter = 39.3701;\n  return scale / (inchesPerMeter * dpi);\n}\n\n/**\n * Return the resolution from a scale denom\n * @param Scale denom\n * @returns Resolution\n */\nexport function getScaleFromResolution(\n  resolution: number,\n  unit: string = 'm',\n  dpi: number = 96\n): number {\n  const inchesPerMeter = 39.3701;\n  return resolution * olproj.METERS_PER_UNIT[unit] * inchesPerMeter * dpi;\n}\n\n/**\n * Returns true if the CTRL key is pushed during an Ol MapBrowserPointerEvent\n * @param event OL MapBrowserPointerEvent\n * @returns Whether the CTRL key is pushed\n */\nexport function ctrlKeyDown(event: MapBrowserPointerEvent<any>): boolean {\n  const originalEvent = event.originalEvent;\n  return (\n    !originalEvent.altKey &&\n    (MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&\n    !originalEvent.shiftKey\n  );\n}\n\nexport function roundCoordTo(\n  coord: [number, number],\n  decimal: number = 3\n): [number, number] {\n  return [\n    NumberUtils.roundToNDecimal(coord[0], decimal),\n    NumberUtils.roundToNDecimal(coord[1], decimal)\n  ] as [number, number];\n}\n\nexport function roundCoordToString(\n  coord: [number, number],\n  decimal: number = 3\n): [string, string] {\n  return roundCoordTo(coord, decimal).map((r) => r.toString()) as [\n    string,\n    string\n  ];\n}\n\n/**\n * Returns an array of converted coordinates.\n * Conversion is done for every configured projections\n * and for the current UTM zone and MTM zone.\n * @param lonLat [number, number] array of the coordinate to transform.\n * @param projections  Projection[] Array of destination projection.\n * @param reverseCoords To reverse coords from latLon to lonLat (search option)\n * @returns Returns an array of converted coordinates.\n */\nexport function lonLatConversion(\n  lonLat: [number, number],\n  projections: Projection[]\n): {\n  code: string;\n  alias: string;\n  coord: [number, number];\n  igo2CoordFormat: string;\n}[] {\n  const rawCoord3857 = olproj.transform(lonLat, 'EPSG:4326', 'EPSG:3857') as [\n    number,\n    number\n  ];\n  const convertedLonLat = [\n    {\n      code: 'EPSG:3857',\n      alias: 'Web Mercator',\n      coord: rawCoord3857,\n      igo2CoordFormat: `${roundCoordTo(rawCoord3857).join(', ')} ; 3857`\n    }\n  ];\n\n  // detect the current utm zone.\n  const utmZone = utmZoneFromLonLat(lonLat);\n  const epsgUtm = utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;\n  const utmName = `UTM-${utmZone}`;\n  const rawCoordUtm = olproj.transform(lonLat, 'EPSG:4326', epsgUtm) as [\n    number,\n    number\n  ];\n  convertedLonLat.push({\n    code: epsgUtm,\n    alias: 'UTM',\n    coord: rawCoordUtm,\n    igo2CoordFormat: `${utmName} ${roundCoordTo(rawCoordUtm).join(', ')}`\n  });\n\n  // detect the current mtm zone.\n  const mtmZone = mtmZoneFromLonLat(lonLat);\n  if (mtmZone) {\n    const epsgMtm =\n      mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;\n    const mtmName = `MTM-${mtmZone}`;\n    const rawCoordMtm = olproj.transform(lonLat, 'EPSG:4326', epsgMtm) as [\n      number,\n      number\n    ];\n    convertedLonLat.push({\n      code: epsgMtm,\n      alias: 'MTM',\n      coord: rawCoordMtm,\n      igo2CoordFormat: `${mtmName} ${roundCoordTo(rawCoordMtm).join(', ')}`\n    });\n  }\n\n  projections.forEach((projection) => {\n    const rawCoord = olproj.transform(lonLat, 'EPSG:4326', projection.code) as [\n      number,\n      number\n    ];\n    const numericEpsgCode = projection.code.split(':')[1];\n    convertedLonLat.push({\n      code: projection.code,\n      alias: projection.alias || projection.code,\n      coord: rawCoord,\n      igo2CoordFormat: `${roundCoordTo(rawCoord).join(\n        ', '\n      )} ; ${numericEpsgCode}`\n    });\n  });\n\n  return convertedLonLat;\n}\n\n/**\n * Detect the current utm zone of the lon/lat coordinate.\n * @param lonLat [number, number] array of the coordinate to detect the UTM zone.\n * @returns number The UTM zone.\n */\nexport function utmZoneFromLonLat(lonLat: [number, number]) {\n  return Math.ceil((lonLat[0] + 180) / 6);\n}\n\n/**\n * Detect the current mtm zone of the lon/lat coordinate.\n * @param lonLat [number, number] array of the coordinate to detect the MTM zone.\n * @returns number The MTM zone. Undefined if outside of the mtm application zone.\n */\nexport function mtmZoneFromLonLat(lonLat: [number, number]) {\n  const long = lonLat[0];\n  let mtmZone;\n  if (long < -51 && long > -54) {\n    mtmZone = 1;\n  }\n  if (long < -54 && long > -57) {\n    mtmZone = 2;\n  }\n  if (long < -57 && long > -60) {\n    mtmZone = 3;\n  }\n  if (long < -60 && long > -63) {\n    mtmZone = 4;\n  }\n  if (long < -63 && long > -66) {\n    mtmZone = 5;\n  }\n  if (long < -66 && long > -69) {\n    mtmZone = 6;\n  }\n  if (long < -69 && long > -72) {\n    mtmZone = 7;\n  }\n  if (long < -72 && long > -75) {\n    mtmZone = 8;\n  }\n  if (long < -75 && long > -78) {\n    mtmZone = 9;\n  }\n  if (long < -78 && long > -81) {\n    mtmZone = 10;\n  }\n  return mtmZone;\n}\n"]}

package/esm2022/lib/map/shared/mapOffline.directive.mjs

@@ -0,0 +1,107 @@
+import { Directive } from '@angular/core';
+import { NetworkService, MessageService } from '@igo2/core';
+import { MapBrowserComponent } from '../map-browser/map-browser.component';
+import { combineLatest } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../map-browser/map-browser.component";
+import * as i2 from "@igo2/core";
+export class MapOfflineDirective {
+    networkService;
+    messageService;
+    component;
+    get map() {
+        return this.component.map;
+    }
+    previousMessageId;
+    constructor(component, networkService, messageService) {
+        this.networkService = networkService;
+        this.messageService = messageService;
+        this.component = component;
+    }
+    ngAfterViewInit() {
+        const initialOnline = window.navigator.onLine;
+        this.map.forcedOffline$.subscribe((forcedOffline) => {
+            const online = window.navigator.onLine;
+            // prevent first online message if no state change.
+            if (initialOnline && initialOnline === online && !forcedOffline) {
+                return;
+            }
+            if (this.previousMessageId) {
+                this.messageService.remove(this.previousMessageId);
+            }
+            if (!forcedOffline && online) {
+                const messageObj = this.messageService.info('igo.geo.network.online.message', 'igo.geo.network.online.title');
+                this.previousMessageId = messageObj.toastId;
+            }
+            else if (forcedOffline) {
+                const messageObj = this.messageService.info('igo.geo.network.offline.message', 'igo.geo.network.offline.title');
+                this.previousMessageId = messageObj.toastId;
+            }
+        });
+        combineLatest([
+            this.networkService.currentState(),
+            this.map.forcedOffline$,
+            this.map.layers$
+        ]).subscribe((bunch) => {
+            const online = bunch[0].connection;
+            const forcedOffline = bunch[1];
+            const layers = bunch[2];
+            this.handleLayersOnlineState(online, forcedOffline, layers);
+        });
+    }
+    handleNonOfflinableLayerResolution(online, forcedOffline, layer) {
+        if (!online || forcedOffline) {
+            layer.maxResolution = 0;
+        }
+        else if (online || !forcedOffline) {
+            layer.maxResolution = layer.options.maxResolution || Infinity;
+        }
+    }
+    handleLayersOnlineState(online, forcedOffline, layers) {
+        layers.forEach((layer) => {
+            let offlinableByUrlSourceOptions;
+            if (layer.isIgoInternalLayer) {
+                return;
+            }
+            // detect if layer/source are offlinable by url/pathOffline properties
+            if (layer.options.sourceOptions?.pathOffline) {
+                offlinableByUrlSourceOptions = layer.options.sourceOptions;
+            }
+            if (offlinableByUrlSourceOptions) {
+                const type = offlinableByUrlSourceOptions.type;
+                if (type === 'mvt') {
+                    layer.ol.getSource().refresh();
+                }
+                if (!online || forcedOffline) {
+                    if (['vector', 'cluster'].includes(type)) {
+                        return;
+                    }
+                    layer.ol.getSource().setUrl(offlinableByUrlSourceOptions.pathOffline);
+                }
+                else if (!online || !forcedOffline) {
+                    if (['vector', 'cluster'].includes(type)) {
+                        return;
+                    }
+                    layer.ol.getSource().setUrl(offlinableByUrlSourceOptions.url);
+                }
+                else {
+                    this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);
+                }
+            }
+            else {
+                // FOR ALL NON OFFLINABLE SOURCE (i.e. EXCEPT PREVIOUS);
+                this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);
+                return;
+            }
+        });
+    }
+    static ɵfac = function MapOfflineDirective_Factory(t) { return new (t || MapOfflineDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.NetworkService), i0.ɵɵdirectiveInject(i2.MessageService)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MapOfflineDirective, selectors: [["", "igoMapOffline", ""]] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapOfflineDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoMapOffline]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.NetworkService }, { type: i2.MessageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mapOffline.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/mapOffline.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAiB,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,cAAc,EAAmB,cAAc,EAAE,MAAM,YAAY,CAAC;AAG7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAE3E,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;;;;AAWrC,MAAM,OAAO,mBAAmB;IAWpB;IACA;IAXF,SAAS,CAAsB;IAEvC,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;IAC5B,CAAC;IAEO,iBAAiB,CAAC;IAE1B,YACE,SAA8B,EACtB,cAA8B,EAC9B,cAA8B;QAD9B,mBAAc,GAAd,cAAc,CAAgB;QAC9B,mBAAc,GAAd,cAAc,CAAgB;QAEtC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,eAAe;QACb,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC;QAC9C,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,aAAsB,EAAE,EAAE;YAC3D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC;YACvC,mDAAmD;YACnD,IAAI,aAAa,IAAI,aAAa,KAAK,MAAM,IAAI,CAAC,aAAa,EAAE;gBAC/D,OAAO;aACR;YACD,IAAI,IAAI,CAAC,iBAAiB,EAAE;gBAC1B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;aACpD;YACD,IAAI,CAAC,aAAa,IAAI,MAAM,EAAE;gBAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CACzC,gCAAgC,EAChC,8BAA8B,CAC/B,CAAC;gBACF,IAAI,CAAC,iBAAiB,GAAG,UAAU,CAAC,OAAO,CAAC;aAC7C;iBAAM,IAAI,aAAa,EAAE;gBACxB,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CACzC,iCAAiC,EACjC,+BAA+B,CAChC,CAAC;gBACF,IAAI,CAAC,iBAAiB,GAAG,UAAU,CAAC,OAAO,CAAC;aAC7C;QACH,CAAC,CAAC,CAAC;QAEH,aAAa,CAAC;YACZ,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE;YAClC,IAAI,CAAC,GAAG,CAAC,cAAc;YACvB,IAAI,CAAC,GAAG,CAAC,OAAO;SACjB,CAAC,CAAC,SAAS,CAAC,CAAC,KAA0C,EAAE,EAAE;YAC1D,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;YACnC,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,kCAAkC,CACxC,MAAe,EACf,aAAsB,EACtB,KAAY;QAEZ,IAAI,CAAC,MAAM,IAAI,aAAa,EAAE;YAC5B,KAAK,CAAC,aAAa,GAAG,CAAC,CAAC;SACzB;aAAM,IAAI,MAAM,IAAI,CAAC,aAAa,EAAE;YACnC,KAAK,CAAC,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,aAAa,IAAI,QAAQ,CAAC;SAC/D;IACH,CAAC;IAEO,uBAAuB,CAC7B,MAAe,EACf,aAAsB,EACtB,MAAe;QAEf,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YACvB,IAAI,4BAA4B,CAAC;YACjC,IAAI,KAAK,CAAC,kBAAkB,EAAE;gBAC5B,OAAO;aACR;YACD,sEAAsE;YACtE,IACG,KAAK,CAAC,OAAO,CAAC,aAAyC,EAAE,WAAW,EACrE;gBACA,4BAA4B,GAAG,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC;aAC5D;YACD,IAAI,4BAA4B,EAAE;gBAChC,MAAM,IAAI,GAAG,4BAA4B,CAAC,IAAI,CAAC;gBAC/C,IAAI,IAAI,KAAK,KAAK,EAAE;oBAClB,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC;iBAChC;gBACD,IAAI,CAAC,MAAM,IAAI,aAAa,EAAE;oBAC5B,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;wBACxC,OAAO;qBACR;oBACA,KAAK,CAAC,EAAE,CAAC,SAAS,EAAU,CAAC,MAAM,CAClC,4BAA4B,CAAC,WAAW,CACzC,CAAC;iBACH;qBAAM,IAAI,CAAC,MAAM,IAAI,CAAC,aAAa,EAAE;oBACpC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;wBACxC,OAAO;qBACR;oBACA,KAAK,CAAC,EAAE,CAAC,SAAS,EAAU,CAAC,MAAM,CAClC,4BAA4B,CAAC,GAAG,CACjC,CAAC;iBACH;qBAAM;oBACL,IAAI,CAAC,kCAAkC,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;iBACvE;aACF;iBAAM;gBACL,wDAAwD;gBACxD,IAAI,CAAC,kCAAkC,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;gBACtE,OAAO;aACR;QACH,CAAC,CAAC,CAAC;IACL,CAAC;6EA/GU,mBAAmB;6DAAnB,mBAAmB;;uFAAnB,mBAAmB;cAH/B,SAAS;eAAC;gBACT,QAAQ,EAAE,iBAAiB;aAC5B","sourcesContent":["import { Directive, AfterViewInit } from '@angular/core';\nimport { NetworkService, ConnectionState, MessageService } from '@igo2/core';\n\nimport { IgoMap } from './map';\nimport { MapBrowserComponent } from '../map-browser/map-browser.component';\nimport { Layer } from '../../layer/shared/layers/layer';\nimport { combineLatest } from 'rxjs';\n\nimport { DataSourceOptions } from '../../datasource/shared/datasources/datasource.interface';\n\ninterface OfflinableSourceOptions extends DataSourceOptions {\n  pathOffline?: string;\n}\n\n@Directive({\n  selector: '[igoMapOffline]'\n})\nexport class MapOfflineDirective implements AfterViewInit {\n  private component: MapBrowserComponent;\n\n  get map(): IgoMap {\n    return this.component.map;\n  }\n\n  private previousMessageId;\n\n  constructor(\n    component: MapBrowserComponent,\n    private networkService: NetworkService,\n    private messageService: MessageService\n  ) {\n    this.component = component;\n  }\n\n  ngAfterViewInit() {\n    const initialOnline = window.navigator.onLine;\n    this.map.forcedOffline$.subscribe((forcedOffline: boolean) => {\n      const online = window.navigator.onLine;\n      // prevent first online message if no state change.\n      if (initialOnline && initialOnline === online && !forcedOffline) {\n        return;\n      }\n      if (this.previousMessageId) {\n        this.messageService.remove(this.previousMessageId);\n      }\n      if (!forcedOffline && online) {\n        const messageObj = this.messageService.info(\n          'igo.geo.network.online.message',\n          'igo.geo.network.online.title'\n        );\n        this.previousMessageId = messageObj.toastId;\n      } else if (forcedOffline) {\n        const messageObj = this.messageService.info(\n          'igo.geo.network.offline.message',\n          'igo.geo.network.offline.title'\n        );\n        this.previousMessageId = messageObj.toastId;\n      }\n    });\n\n    combineLatest([\n      this.networkService.currentState(),\n      this.map.forcedOffline$,\n      this.map.layers$\n    ]).subscribe((bunch: [ConnectionState, boolean, Layer[]]) => {\n      const online = bunch[0].connection;\n      const forcedOffline = bunch[1];\n      const layers = bunch[2];\n      this.handleLayersOnlineState(online, forcedOffline, layers);\n    });\n  }\n\n  private handleNonOfflinableLayerResolution(\n    online: boolean,\n    forcedOffline: boolean,\n    layer: Layer\n  ) {\n    if (!online || forcedOffline) {\n      layer.maxResolution = 0;\n    } else if (online || !forcedOffline) {\n      layer.maxResolution = layer.options.maxResolution || Infinity;\n    }\n  }\n\n  private handleLayersOnlineState(\n    online: boolean,\n    forcedOffline: boolean,\n    layers: Layer[]\n  ) {\n    layers.forEach((layer) => {\n      let offlinableByUrlSourceOptions;\n      if (layer.isIgoInternalLayer) {\n        return;\n      }\n      // detect if layer/source are offlinable by url/pathOffline properties\n      if (\n        (layer.options.sourceOptions as OfflinableSourceOptions)?.pathOffline\n      ) {\n        offlinableByUrlSourceOptions = layer.options.sourceOptions;\n      }\n      if (offlinableByUrlSourceOptions) {\n        const type = offlinableByUrlSourceOptions.type;\n        if (type === 'mvt') {\n          layer.ol.getSource().refresh();\n        }\n        if (!online || forcedOffline) {\n          if (['vector', 'cluster'].includes(type)) {\n            return;\n          }\n          (layer.ol.getSource() as any).setUrl(\n            offlinableByUrlSourceOptions.pathOffline\n          );\n        } else if (!online || !forcedOffline) {\n          if (['vector', 'cluster'].includes(type)) {\n            return;\n          }\n          (layer.ol.getSource() as any).setUrl(\n            offlinableByUrlSourceOptions.url\n          );\n        } else {\n          this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);\n        }\n      } else {\n        // FOR ALL NON OFFLINABLE SOURCE (i.e. EXCEPT PREVIOUS);\n        this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);\n        return;\n      }\n    });\n  }\n}\n"]}