@nextgis/ngw-map 1.18.9 → 1.18.11

package/lib/ngw-map.esm-bundler.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-map; version: 1.18.9; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 1.18.11; author: NextGIS */
 import { EventEmitter } from 'events';
 import CancelablePromise from '@nextgis/cancelable-promise';
 import { deepmerge, deprecatedWarn, defined, isObject, getIdentifyRadius } from '@nextgis/utils';

package/lib/ngw-map.global.js

@@ -1,4 +1,4 @@
-/** Bundle of @nextgis/ngw-map; version: 1.18.9; author: NextGIS */
+/** Bundle of @nextgis/ngw-map; version: 1.18.11; author: NextGIS */
 var NgwMap = (function (exports) {
     'use strict';
 
@@ -1384,6 +1384,13 @@ var NgwMap = (function (exports) {
         };
     }
 
+    function evaluateArgs(cb) {
+        return function (args, data) {
+            var unwrap = args.map(function (a) { return a(); });
+            return cb(unwrap, data);
+        };
+    }
+
     var array = function (args) {
         var firstArg = args[0], secondArg = args[1], thirdArg = args[2];
         var requiredType = undefined;
@@ -1414,55 +1421,86 @@ var NgwMap = (function (exports) {
         }
         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)) {
+                    var arrayType = 'value';
+                    if (value.every(function (item) { return typeof item === 'number'; })) {
+                        arrayType = 'number';
+                    }
+                    else if (value.every(function (item) { return typeof item === 'string'; })) {
+                        arrayType = 'string';
+                    }
+                    else if (value.every(function (item) { return typeof item === 'boolean'; })) {
+                        arrayType = 'boolean';
+                    }
+                    return "array<".concat(arrayType, ", ").concat(value.length, ">");
+                }
+                else {
+                    return 'object';
+                }
+            default:
+                return 'undefined';
+        }
+    }
     var typeExpressions = {
-        array: array,
-        boolean: fallback(function (arg) { return (typeof arg === 'boolean' ? arg : undefined); }),
-        literal: function (_a) {
+        array: evaluateArgs(array),
+        boolean: evaluateArgs(fallback(function (arg) { return (typeof arg === 'boolean' ? arg : undefined); })),
+        literal: evaluateArgs(function (_a) {
             var arg = _a[0];
             return arg;
-        },
-        number: fallback(function (arg) { return (typeof arg === 'number' ? arg : undefined); }),
-        object: fallback(function (arg) {
+        }),
+        number: evaluateArgs(fallback(function (arg) { return (typeof arg === 'number' ? arg : undefined); })),
+        object: evaluateArgs(fallback(function (arg) {
             return arg !== null && typeof arg === 'object' && !Array.isArray(arg)
                 ? arg
                 : undefined;
-        }),
-        string: fallback(function (arg) { return (typeof arg === 'string' ? arg : undefined); }),
-        'to-boolean': fallback(Boolean),
-        'to-number': fallback(Number),
-        'to-string': fallback(String),
-        typeof: function (_a) {
+        })),
+        string: evaluateArgs(fallback(function (arg) { return (typeof arg === 'string' ? arg : undefined); })),
+        'to-boolean': evaluateArgs(fallback(Boolean)),
+        'to-number': evaluateArgs(fallback(Number)),
+        'to-string': evaluateArgs(fallback(String)),
+        typeof: evaluateArgs(function (_a) {
             var arg = _a[0];
-            return typeof arg;
-        },
+            return typeOfValue(arg);
+        }),
     };
 
     var mathExpressions = {
-        '+': function (args) { return args.reduce(function (a, b) { return a + b; }, 0); },
-        '-': function (args) { return args.reduce(function (a, b) { return a - b; }); },
-        '*': function (args) { return args.reduce(function (a, b) { return a * b; }, 1); },
-        '/': function (args) { return args.reduce(function (a, b) { return a / b; }); },
-        '%': function (args) { return args[0] % args[1]; },
-        '^': function (args) { return Math.pow(args[0], args[1]); },
-        abs: function (args) { return Math.abs(args[0]); },
-        acos: function (args) { return Math.acos(args[0]); },
-        asin: function (args) { return Math.asin(args[0]); },
-        atan: function (args) { return Math.atan(args[0]); },
-        ceil: function (args) { return Math.ceil(args[0]); },
-        cos: function (args) { return Math.cos(args[0]); },
+        '+': evaluateArgs(function (args) { return args.reduce(function (a, b) { return a + b; }, 0); }),
+        '-': evaluateArgs(function (args) { return args.reduce(function (a, b) { return a - b; }); }),
+        '*': evaluateArgs(function (args) { return args.reduce(function (a, b) { return a * b; }, 1); }),
+        '/': evaluateArgs(function (args) { return args.reduce(function (a, b) { return a / b; }); }),
+        '%': evaluateArgs(function (args) { return args[0] % args[1]; }),
+        '^': evaluateArgs(function (args) { return Math.pow(args[0], args[1]); }),
+        abs: evaluateArgs(function (args) { return Math.abs(args[0]); }),
+        acos: evaluateArgs(function (args) { return Math.acos(args[0]); }),
+        asin: evaluateArgs(function (args) { return Math.asin(args[0]); }),
+        atan: evaluateArgs(function (args) { return Math.atan(args[0]); }),
+        ceil: evaluateArgs(function (args) { return Math.ceil(args[0]); }),
+        cos: evaluateArgs(function (args) { return Math.cos(args[0]); }),
         e: function () { return Math.E; },
-        floor: function (args) { return Math.floor(args[0]); },
-        ln: function (args) { return Math.log(args[0]); },
+        floor: evaluateArgs(function (args) { return Math.floor(args[0]); }),
+        ln: evaluateArgs(function (args) { return Math.log(args[0]); }),
         ln2: function () { return Math.LN2; },
-        log10: function (args) { return Math.log10(args[0]); },
-        log2: function (args) { return Math.log2(args[0]); },
-        max: function (args) { return Math.max.apply(Math, args); },
-        min: function (args) { return Math.min.apply(Math, args); },
+        log10: evaluateArgs(function (args) { return Math.log10(args[0]); }),
+        log2: evaluateArgs(function (args) { return Math.log2(args[0]); }),
+        max: evaluateArgs(function (args) { return Math.max.apply(Math, args); }),
+        min: evaluateArgs(function (args) { return Math.min.apply(Math, args); }),
         pi: function () { return Math.PI; },
-        round: function (args) { return Math.round(args[0]); },
-        sin: function (args) { return Math.sin(args[0]); },
-        sqrt: function (args) { return Math.sqrt(args[0]); },
-        tan: function (args) { return Math.tan(args[0]); },
+        round: evaluateArgs(function (args) { return Math.round(args[0]); }),
+        sin: evaluateArgs(function (args) { return Math.sin(args[0]); }),
+        sqrt: evaluateArgs(function (args) { return Math.sqrt(args[0]); }),
+        tan: evaluateArgs(function (args) { return Math.tan(args[0]); }),
     };
 
     function get(_a, data) {
@@ -1520,140 +1558,140 @@ var NgwMap = (function (exports) {
         throw new Error("Invalid input type for 'slice'. Expected string or array, got ".concat(typeof input, "."));
     }
     var lookupExpressions = {
-        get: get,
-        length: length,
-        at: at,
-        has: has,
-        in: inFunc,
-        'index-of': indexOf,
-        slice: slice,
+        get: evaluateArgs(get),
+        length: evaluateArgs(length),
+        at: evaluateArgs(at),
+        has: evaluateArgs(has),
+        in: evaluateArgs(inFunc),
+        'index-of': evaluateArgs(indexOf),
+        slice: evaluateArgs(slice),
     };
 
     var stringExpressions = {
-        concat: function (args) { return args.reduce(function (a, b) { return String(a) + String(b); }, ''); },
-        downcase: function (args) { return String(args[0]).toLowerCase(); },
-        upcase: function (args) { return String(args[0]).toUpperCase(); },
+        concat: evaluateArgs(function (args) { return args.reduce(function (a, b) { return String(a) + String(b); }, ''); }),
+        downcase: evaluateArgs(function (args) { return String(args[0]).toLowerCase(); }),
+        upcase: evaluateArgs(function (args) { return String(args[0]).toUpperCase(); }),
     };
 
     function not(_a) {
         var expr = _a[0];
         return !expr;
     }
-    var checkCompareValues = function (_a) {
-        var a = _a[0], b = _a[1];
-        if (typeof a !== typeof b) {
-            throw new Error('Values have different types.');
-        }
-    };
     function notEqual(_a) {
         var a = _a[0], b = _a[1];
-        checkCompareValues([a, b]);
         return a !== b;
     }
     function lessThan(_a) {
         var left = _a[0], right = _a[1];
-        checkCompareValues([left, right]);
         return left < right;
     }
     function lessThanOrEqual(_a) {
         var left = _a[0], right = _a[1];
-        checkCompareValues([left, right]);
         return left <= right;
     }
     function equal(_a) {
         var left = _a[0], right = _a[1];
-        checkCompareValues([left, right]);
         return left === right;
     }
     function greaterThan(_a) {
         var left = _a[0], right = _a[1];
-        checkCompareValues([left, right]);
         return left > right;
     }
     function greaterThanOrEqual(_a) {
         var left = _a[0], right = _a[1];
-        checkCompareValues([left, right]);
         return left >= right;
     }
-    function all(args) {
+    var coalesce = function (args) {
         for (var i = 0; i < args.length; i++) {
-            var arg = args[i];
+            var arg = args[i]();
+            if (arg !== null && arg !== undefined) {
+                return arg;
+            }
+        }
+        return null;
+    };
+    var all = function (args) {
+        for (var i = 0; i < args.length; i++) {
+            var arg = args[i]();
             if (!arg) {
                 return false;
             }
         }
         return true;
-    }
-    function any(args) {
+    };
+    var any = function (args) {
         for (var i = 0; i < args.length; i++) {
-            var arg = args[i];
+            var arg = args[i]();
             if (arg) {
                 return true;
             }
         }
         return false;
-    }
-    function match(args) {
-        var lookup = args[0], cases = args.slice(1);
+    };
+    var match = function (args) {
+        var lookupFn = args[0], cases = args.slice(1);
+        var lookup = lookupFn();
         // remove last odd item from cases array
         var defValue = cases.splice(-1, cases.length % 2)[0];
         for (var fry = 0; fry < cases.length - 1; fry += 2) {
-            var key = cases[fry];
+            var key = cases[fry]();
             if (key === lookup) {
-                return cases[fry + 1];
+                return cases[fry + 1]();
             }
         }
-        return defValue;
-    }
-    function caseFunc(args) {
+        return defValue();
+    };
+    var caseFunc = function (args) {
         if (args.length < 2) {
             throw new Error('The "case" function requires at least a condition and a corresponding output.');
         }
-        var fallback = args[args.length - 1];
         if (args.length % 2 === 0) {
             throw new Error('Missing a fallback value or unmatched condition-output pair.');
         }
         for (var i = 0; i < args.length - 1; i += 2) {
-            var condition = args[i];
-            var value = args[i + 1];
+            var condition = args[i]();
+            var value = args[i + 1]();
             if (condition) {
                 return value;
             }
         }
-        return fallback;
-    }
+        var fallback = args[args.length - 1];
+        return fallback();
+    };
     var decisionExpressions = {
-        '!': not,
-        '!=': notEqual,
-        '<': lessThan,
-        '<=': lessThanOrEqual,
-        '==': equal,
-        '>': greaterThan,
-        '>=': greaterThanOrEqual,
+        '!': evaluateArgs(not),
+        '!=': evaluateArgs(notEqual),
+        '<': evaluateArgs(lessThan),
+        '<=': evaluateArgs(lessThanOrEqual),
+        '==': evaluateArgs(equal),
+        '>': evaluateArgs(greaterThan),
+        '>=': evaluateArgs(greaterThanOrEqual),
+        coalesce: coalesce,
         all: all,
         any: any,
         case: caseFunc,
         match: match,
     };
 
-    function step(args) {
-        var input = args[0], defaultValue = args[1], stops = args.slice(2);
+    var step = function (args) {
+        var inputFn = args[0], defaultValue = args[1], stops = args.slice(2);
+        var input = inputFn();
         if (typeof input !== 'number') {
-            return defaultValue;
+            return defaultValue();
         }
         for (var i = 0; i < stops.length - 2; i += 2) {
-            var stopInput = stops[i];
-            var stopOutput = stops[i + 1];
-            var nextStopInput = stops[i + 2];
+            var stopInput = stops[i]();
+            var stopOutput = stops[i + 1]();
+            var nextStopInput = stops[i + 2]();
             if (input >= stopInput && input < nextStopInput) {
                 return stopOutput;
             }
         }
-        if (input >= stops[stops.length - 2]) {
-            return stops[stops.length - 1];
+        if (input >= stops[stops.length - 2]()) {
+            return stops[stops.length - 1]();
         }
-        return defaultValue;
-    }
+        return defaultValue();
+    };
 
     var COLORS = {
         aliceblue: '#f0f8ff',
@@ -1923,22 +1961,24 @@ var NgwMap = (function (exports) {
         }
         throw new Error('Unsupported output type for linear interpolation.');
     }
-    function interpolate(_a) {
-        var interpolation = _a[0], input = _a[1], stops = _a.slice(2);
+    var interpolate = function (_a) {
+        var interpolationFn = _a[0], inputFn = _a[1], stops = _a.slice(2);
         if (stops.length < 2) {
             throw new Error('At least two stops are required');
         }
-        if (typeof input !== 'number') {
-            throw new Error('Input must be a number.');
-        }
         if (stops.length < 2 || stops.length % 2 !== 0) {
             throw new Error('Invalid stops provided.');
         }
+        var input = inputFn();
+        if (typeof input !== 'number') {
+            throw new Error('Input must be a number.');
+        }
+        var interpolation = interpolationFn();
         for (var i = 0; i < stops.length - 2; i += 2) {
-            var stopInput1 = stops[i];
-            var stopOutput1 = stops[i + 1];
-            var stopInput2 = stops[i + 2];
-            var stopOutput2 = stops[i + 3];
+            var stopInput1 = stops[i]();
+            var stopOutput1 = stops[i + 1]();
+            var stopInput2 = stops[i + 2]();
+            var stopOutput2 = stops[i + 3]();
             if (input >= stopInput1 && input <= stopInput2) {
                 if (interpolation[0] === 'linear') {
                     return linearInterpolation(input, stopInput1, stopOutput1, stopInput2, stopOutput2);
@@ -1957,7 +1997,7 @@ var NgwMap = (function (exports) {
             }
         }
         throw new Error('Invalid interpolation type.');
-    }
+    };
 
     var interpolationExpressions = {
         step: step,
@@ -1981,7 +2021,7 @@ var NgwMap = (function (exports) {
         var name = expression[0], args = expression.slice(1);
         var expressionFun = expressions[name];
         if (expressionFun) {
-            return expressionFun(args.map(function (arg) { return (isExpression(arg) ? evaluate(arg, data) : arg); }), data);
+            return expressionFun(args.map(function (arg) { return function () { return isExpression(arg) ? evaluate(arg, data) : arg; }; }), data);
         }
         throw new Error("Expression \"".concat(name, "\" is not supported."));
     }