@nextgis/ngw-leaflet 1.18.10 → 1.18.12

package/lib/ngw-leaflet.esm-browser.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-leaflet; version: 1.18.10; author: NextGIS */
+/** Bundle of @nextgis/ngw-leaflet; version: 1.18.12; author: NextGIS */
 function styleInject(css, ref) {
   if ( ref === void 0 ) ref = {};
   var insertAt = ref.insertAt;
@@ -15338,6 +15338,37 @@ const array = (args) => {
     }
     return value;
 };
+function typeOfValue(value) {
+    if (value === null)
+        return 'null';
+    switch (typeof value) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'object':
+            if (Array.isArray(value)) {
+                let arrayType = 'value';
+                if (value.every((item) => typeof item === 'number')) {
+                    arrayType = 'number';
+                }
+                else if (value.every((item) => typeof item === 'string')) {
+                    arrayType = 'string';
+                }
+                else if (value.every((item) => typeof item === 'boolean')) {
+                    arrayType = 'boolean';
+                }
+                return `array<${arrayType}, ${value.length}>`;
+            }
+            else {
+                return 'object';
+            }
+        default:
+            return 'undefined';
+    }
+}
 const typeExpressions = {
     array: evaluateArgs(array),
     boolean: evaluateArgs(fallback((arg) => (typeof arg === 'boolean' ? arg : undefined))),
@@ -15350,7 +15381,7 @@ const typeExpressions = {
     'to-boolean': evaluateArgs(fallback(Boolean)),
     'to-number': evaluateArgs(fallback(Number)),
     'to-string': evaluateArgs(fallback(String)),
-    typeof: evaluateArgs(([arg]) => typeof arg),
+    typeof: evaluateArgs(([arg]) => typeOfValue(arg)),
 };
 
 const mathExpressions = {
@@ -15448,35 +15479,33 @@ const stringExpressions = {
 function not([expr]) {
     return !expr;
 }
-const checkCompareValues = ([a, b]) => {
-    if (typeof a !== typeof b) {
-        throw new Error('Values have different types.');
-    }
-};
 function notEqual([a, b]) {
-    checkCompareValues([a, b]);
     return a !== b;
 }
 function lessThan([left, right]) {
-    checkCompareValues([left, right]);
     return left < right;
 }
 function lessThanOrEqual([left, right]) {
-    checkCompareValues([left, right]);
     return left <= right;
 }
 function equal([left, right]) {
-    checkCompareValues([left, right]);
     return left === right;
 }
 function greaterThan([left, right]) {
-    checkCompareValues([left, right]);
     return left > right;
 }
 function greaterThanOrEqual([left, right]) {
-    checkCompareValues([left, right]);
     return left >= right;
 }
+const coalesce = (args) => {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i]();
+        if (arg !== null && arg !== undefined) {
+            return arg;
+        }
+    }
+    return null;
+};
 const all = (args) => {
     for (let i = 0; i < args.length; i++) {
         const arg = args[i]();
@@ -15533,6 +15562,7 @@ const decisionExpressions = {
     '==': evaluateArgs(equal),
     '>': evaluateArgs(greaterThan),
     '>=': evaluateArgs(greaterThanOrEqual),
+    coalesce,
     all,
     any,
     case: caseFunc,
@@ -21984,44 +22014,44 @@ function fetchIdentifyItem(options) {
     return CancelablePromise.resolve(undefined);
 }
 function featureLayerIdentify(options) {
-    const { geom, signal, cache } = options;
-    let geom_ = [];
+    const { geom, signal, cache, layers } = options;
+    const wkt = typeof geom === 'string' ? geom : convertGeomToWKT(geom);
+    if (!wkt) {
+        throw new Error('Not valid geometry format to make intersection');
+    }
+    const data = {
+        geom: wkt,
+        srs: 3857,
+        layers,
+    };
+    return options.connector.post('feature_layer.identify', {
+        data,
+        signal,
+        cache,
+    });
+}
+function convertGeomToWKT(geom) {
+    const coordinates = getPolygonCoordinates(geom);
+    if (!coordinates)
+        return null;
+    const polygonStr = coordinates.map(([lng, lat]) => {
+        const [x, y] = degrees2meters(lng, lat);
+        return `${x} ${y}`;
+    });
+    return `POLYGON((${polygonStr.join(',')}))`;
+}
+function getPolygonCoordinates(geom) {
+    var _a;
     if (Array.isArray(geom)) {
-        geom_ = geom;
+        return geom;
     }
-    else {
-        const polygon = geom.type === 'Feature'
-            ? geom.geometry
-            : geom.type === 'Polygon'
-                ? geom
-                : false;
-        if (polygon) {
-            geom_ = polygon.coordinates[0];
-        }
-    }
-    if (geom_) {
-        // create wkt string
-        const polygonStr = [];
-        for (const [lng, lat] of geom_) {
-            const [x, y] = degrees2meters(lng, lat);
-            polygonStr.push(x + ' ' + y);
-        }
-        const wkt = `POLYGON((${polygonStr.join(', ')}))`;
-        const layers = options.layers;
-        const data = {
-            geom: wkt,
-            srs: 3857,
-            layers,
-        };
-        return options.connector.post('feature_layer.identify', {
-            data,
-            signal,
-            cache,
-        });
+    if (geom.type === 'Feature') {
+        return (_a = geom.geometry) === null || _a === void 0 ? void 0 : _a.coordinates[0];
     }
-    else {
-        throw new Error('Not valid geometry format to make intersection');
+    if (geom.type === 'Polygon') {
+        return geom.coordinates[0];
     }
+    return null;
 }
 function sendIdentifyRequest(ev, options) {
     deprecatedMapClick(ev);