@nextgis/ngw-map 1.18.9 → 1.18.11

package/lib/ngw-map.cjs.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 */
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });

package/lib/ngw-map.esm-browser.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 events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -1210,6 +1210,13 @@ function fallback(cb) {
     };
 }
 
+function evaluateArgs(cb) {
+    return (args, data) => {
+        const unwrap = args.map((a) => a());
+        return cb(unwrap, data);
+    };
+}
+
 const array = (args) => {
     const [firstArg, secondArg, thirdArg] = args;
     let requiredType = undefined;
@@ -1240,47 +1247,78 @@ 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,
-    boolean: fallback((arg) => (typeof arg === 'boolean' ? arg : undefined)),
-    literal: ([arg]) => arg,
-    number: fallback((arg) => (typeof arg === 'number' ? arg : undefined)),
-    object: fallback((arg) => arg !== null && typeof arg === 'object' && !Array.isArray(arg)
+    array: evaluateArgs(array),
+    boolean: evaluateArgs(fallback((arg) => (typeof arg === 'boolean' ? arg : undefined))),
+    literal: evaluateArgs(([arg]) => arg),
+    number: evaluateArgs(fallback((arg) => (typeof arg === 'number' ? arg : undefined))),
+    object: evaluateArgs(fallback((arg) => arg !== null && typeof arg === 'object' && !Array.isArray(arg)
         ? arg
-        : undefined),
-    string: fallback((arg) => (typeof arg === 'string' ? arg : undefined)),
-    'to-boolean': fallback(Boolean),
-    'to-number': fallback(Number),
-    'to-string': fallback(String),
-    typeof: ([arg]) => typeof arg,
+        : undefined)),
+    string: evaluateArgs(fallback((arg) => (typeof arg === 'string' ? arg : undefined))),
+    'to-boolean': evaluateArgs(fallback(Boolean)),
+    'to-number': evaluateArgs(fallback(Number)),
+    'to-string': evaluateArgs(fallback(String)),
+    typeof: evaluateArgs(([arg]) => typeOfValue(arg)),
 };
 
 const mathExpressions = {
-    '+': (args) => args.reduce((a, b) => a + b, 0),
-    '-': (args) => args.reduce((a, b) => a - b),
-    '*': (args) => args.reduce((a, b) => a * b, 1),
-    '/': (args) => args.reduce((a, b) => a / b),
-    '%': (args) => args[0] % args[1],
-    '^': (args) => Math.pow(args[0], args[1]),
-    abs: (args) => Math.abs(args[0]),
-    acos: (args) => Math.acos(args[0]),
-    asin: (args) => Math.asin(args[0]),
-    atan: (args) => Math.atan(args[0]),
-    ceil: (args) => Math.ceil(args[0]),
-    cos: (args) => Math.cos(args[0]),
+    '+': evaluateArgs((args) => args.reduce((a, b) => a + b, 0)),
+    '-': evaluateArgs((args) => args.reduce((a, b) => a - b)),
+    '*': evaluateArgs((args) => args.reduce((a, b) => a * b, 1)),
+    '/': evaluateArgs((args) => args.reduce((a, b) => a / b)),
+    '%': evaluateArgs((args) => args[0] % args[1]),
+    '^': evaluateArgs((args) => Math.pow(args[0], args[1])),
+    abs: evaluateArgs((args) => Math.abs(args[0])),
+    acos: evaluateArgs((args) => Math.acos(args[0])),
+    asin: evaluateArgs((args) => Math.asin(args[0])),
+    atan: evaluateArgs((args) => Math.atan(args[0])),
+    ceil: evaluateArgs((args) => Math.ceil(args[0])),
+    cos: evaluateArgs((args) => Math.cos(args[0])),
     e: () => Math.E,
-    floor: (args) => Math.floor(args[0]),
-    ln: (args) => Math.log(args[0]),
+    floor: evaluateArgs((args) => Math.floor(args[0])),
+    ln: evaluateArgs((args) => Math.log(args[0])),
     ln2: () => Math.LN2,
-    log10: (args) => Math.log10(args[0]),
-    log2: (args) => Math.log2(args[0]),
-    max: (args) => Math.max(...args),
-    min: (args) => Math.min(...args),
+    log10: evaluateArgs((args) => Math.log10(args[0])),
+    log2: evaluateArgs((args) => Math.log2(args[0])),
+    max: evaluateArgs((args) => Math.max(...args)),
+    min: evaluateArgs((args) => Math.min(...args)),
     pi: () => Math.PI,
-    round: (args) => Math.round(args[0]),
-    sin: (args) => Math.sin(args[0]),
-    sqrt: (args) => Math.sqrt(args[0]),
-    tan: (args) => Math.tan(args[0]),
+    round: evaluateArgs((args) => Math.round(args[0])),
+    sin: evaluateArgs((args) => Math.sin(args[0])),
+    sqrt: evaluateArgs((args) => Math.sqrt(args[0])),
+    tan: evaluateArgs((args) => Math.tan(args[0])),
 };
 
 function get([key, objExp], data) {
@@ -1332,132 +1370,133 @@ function slice(args) {
     throw new Error(`Invalid input type for 'slice'. Expected string or array, got ${typeof input}.`);
 }
 const lookupExpressions = {
-    get,
-    length,
-    at,
-    has,
-    in: inFunc,
-    'index-of': indexOf,
-    slice,
+    get: evaluateArgs(get),
+    length: evaluateArgs(length),
+    at: evaluateArgs(at),
+    has: evaluateArgs(has),
+    in: evaluateArgs(inFunc),
+    'index-of': evaluateArgs(indexOf),
+    slice: evaluateArgs(slice),
 };
 
 const stringExpressions = {
-    concat: (args) => args.reduce((a, b) => String(a) + String(b), ''),
-    downcase: (args) => String(args[0]).toLowerCase(),
-    upcase: (args) => String(args[0]).toUpperCase(),
+    concat: evaluateArgs((args) => args.reduce((a, b) => String(a) + String(b), '')),
+    downcase: evaluateArgs((args) => String(args[0]).toLowerCase()),
+    upcase: evaluateArgs((args) => String(args[0]).toUpperCase()),
 };
 
 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;
 }
-function all(args) {
+const coalesce = (args) => {
     for (let i = 0; i < args.length; i++) {
-        const arg = args[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]();
         if (!arg) {
             return false;
         }
     }
     return true;
-}
-function any(args) {
+};
+const any = (args) => {
     for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
+        const arg = args[i]();
         if (arg) {
             return true;
         }
     }
     return false;
-}
-function match(args) {
-    const [lookup, ...cases] = args;
+};
+const match = (args) => {
+    const [lookupFn, ...cases] = args;
+    const lookup = lookupFn();
     // remove last odd item from cases array
     const defValue = cases.splice(-1, cases.length % 2)[0];
     for (let fry = 0; fry < cases.length - 1; fry += 2) {
-        const key = cases[fry];
+        const key = cases[fry]();
         if (key === lookup) {
-            return cases[fry + 1];
+            return cases[fry + 1]();
         }
     }
-    return defValue;
-}
-function caseFunc(args) {
+    return defValue();
+};
+const caseFunc = (args) => {
     if (args.length < 2) {
         throw new Error('The "case" function requires at least a condition and a corresponding output.');
     }
-    const fallback = args[args.length - 1];
     if (args.length % 2 === 0) {
         throw new Error('Missing a fallback value or unmatched condition-output pair.');
     }
     for (let i = 0; i < args.length - 1; i += 2) {
-        const condition = args[i];
-        const value = args[i + 1];
+        const condition = args[i]();
+        const value = args[i + 1]();
         if (condition) {
             return value;
         }
     }
-    return fallback;
-}
+    const fallback = args[args.length - 1];
+    return fallback();
+};
 const decisionExpressions = {
-    '!': not,
-    '!=': notEqual,
-    '<': lessThan,
-    '<=': lessThanOrEqual,
-    '==': equal,
-    '>': greaterThan,
-    '>=': greaterThanOrEqual,
-    all: all,
-    any: any,
+    '!': evaluateArgs(not),
+    '!=': evaluateArgs(notEqual),
+    '<': evaluateArgs(lessThan),
+    '<=': evaluateArgs(lessThanOrEqual),
+    '==': evaluateArgs(equal),
+    '>': evaluateArgs(greaterThan),
+    '>=': evaluateArgs(greaterThanOrEqual),
+    coalesce,
+    all,
+    any,
     case: caseFunc,
     match,
 };
 
-function step(args) {
-    const [input, defaultValue, ...stops] = args;
+const step = (args) => {
+    const [inputFn, defaultValue, ...stops] = args;
+    const input = inputFn();
     if (typeof input !== 'number') {
-        return defaultValue;
+        return defaultValue();
     }
     for (let i = 0; i < stops.length - 2; i += 2) {
-        const stopInput = stops[i];
-        const stopOutput = stops[i + 1];
-        const nextStopInput = stops[i + 2];
+        const stopInput = stops[i]();
+        const stopOutput = stops[i + 1]();
+        const 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();
+};
 
 const COLORS = {
     aliceblue: '#f0f8ff',
@@ -1726,21 +1765,23 @@ function linearInterpolation(input, input1, output1, input2, output2) {
     }
     throw new Error('Unsupported output type for linear interpolation.');
 }
-function interpolate([interpolation, input, ...stops]) {
+const interpolate = ([interpolationFn, inputFn, ...stops]) => {
     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.');
     }
+    const input = inputFn();
+    if (typeof input !== 'number') {
+        throw new Error('Input must be a number.');
+    }
+    const interpolation = interpolationFn();
     for (let i = 0; i < stops.length - 2; i += 2) {
-        const stopInput1 = stops[i];
-        const stopOutput1 = stops[i + 1];
-        const stopInput2 = stops[i + 2];
-        const stopOutput2 = stops[i + 3];
+        const stopInput1 = stops[i]();
+        const stopOutput1 = stops[i + 1]();
+        const stopInput2 = stops[i + 2]();
+        const stopOutput2 = stops[i + 3]();
         if (input >= stopInput1 && input <= stopInput2) {
             if (interpolation[0] === 'linear') {
                 return linearInterpolation(input, stopInput1, stopOutput1, stopInput2, stopOutput2);
@@ -1759,7 +1800,7 @@ function interpolate([interpolation, input, ...stops]) {
         }
     }
     throw new Error('Invalid interpolation type.');
-}
+};
 
 const interpolationExpressions = {
     step,
@@ -1789,7 +1830,7 @@ function evaluate(expression, data = {}) {
     const [name, ...args] = expression;
     const expressionFun = expressions[name];
     if (expressionFun) {
-        return expressionFun(args.map((arg) => (isExpression(arg) ? evaluate(arg, data) : arg)), data);
+        return expressionFun(args.map((arg) => () => isExpression(arg) ? evaluate(arg, data) : arg), data);
     }
     throw new Error(`Expression "${name}" is not supported.`);
 }