ol 9.0.1-dev.1708958348077 → 9.0.1-dev.1709106981367

package/expr/cpu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cpu.d.ts","sourceRoot":"","sources":["cpu.js"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AACH,wCAFY,iBAAiB,CAU5B;AAED;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;GAKG;AACH,yCALW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,MAAM,WACN,OAAO,iBAAiB,EAAE,cAAc,GACvC,mBAAmB,CAY9B;;;;;;;;;;;;;gBAtEa,MAAM;;;;eACN,MAAM,GAAC,MAAM,GAAC,IAAI;;;;kBAClB,MAAM;;yCAiBE,iBAAiB,KAAE,OAAO,iBAAiB,EAAE,YAAY;sCAIzD,iBAAiB,KAAE,OAAO;qCAI1B,iBAAiB,KAAE,MAAM;qCAIzB,iBAAiB,KAAE,MAAM;wCAIzB,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,GAAC,MAAM,CAAC;0CAIzC,iBAAiB,KAAE,MAAM,MAAM,CAAC;yCAIhC,iBAAiB,KAAE,MAAM,MAAM,CAAC;mCAIhC,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,CAAC;uCAIlC,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,GAAC,MAAM,CAAC"}
+{"version":3,"file":"cpu.d.ts","sourceRoot":"","sources":["cpu.js"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AACH,wCAFY,iBAAiB,CAU5B;AAED;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;GAKG;AACH,yCALW,OAAO,iBAAiB,EAAE,iBAAiB,QAC3C,MAAM,WACN,OAAO,iBAAiB,EAAE,cAAc,GACvC,mBAAmB,CAY9B;;;;;;;;;;;;;gBAtEa,MAAM;;;;eACN,MAAM,GAAC,MAAM,GAAC,IAAI;;;;kBAClB,MAAM;;yCAiBE,iBAAiB,KAAE,OAAO,iBAAiB,EAAE,YAAY;sCAIzD,iBAAiB,KAAE,OAAO;qCAI1B,iBAAiB,KAAE,MAAM;qCAIzB,iBAAiB,KAAE,MAAM;wCAIzB,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,GAAC,MAAM,CAAC;0CAIzC,iBAAiB,KAAE,MAAM,MAAM,CAAC;yCAIhC,iBAAiB,KAAE,MAAM,MAAM,CAAC;mCAIhC,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,CAAC;uCAIlC,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,GAAC,MAAM,CAAC"}

package/expr/cpu.js

@@ -15,6 +15,7 @@ import {
   lchaToRgba,
   normalize,
   rgbaToLcha,
+  toString,
   withAlpha,
 } from '../color.js';
 
@@ -147,6 +148,8 @@ function compileExpression(expression, context) {
     }
     case Ops.Any:
     case Ops.All:
+    case Ops.Between:
+    case Ops.In:
     case Ops.Not: {
       return compileLogicalExpression(expression, context);
     }
@@ -184,14 +187,15 @@ function compileExpression(expression, context) {
     case Ops.Interpolate: {
       return compileInterpolateExpression(expression, context);
     }
+    case Ops.ToString: {
+      return compileConvertExpression(expression, context);
+    }
     default: {
       throw new Error(`Unsupported operator ${operator}`);
     }
     // TODO: unimplemented
     // Ops.Zoom
     // Ops.Time
-    // Ops.Between
-    // Ops.In
     // Ops.Array
     // Ops.Color
     // Ops.Band
@@ -331,6 +335,25 @@ function compileLogicalExpression(expression, context) {
         return true;
       };
     }
+    case Ops.Between: {
+      return (context) => {
+        const value = args[0](context);
+        const min = args[1](context);
+        const max = args[2](context);
+        return value >= min && value <= max;
+      };
+    }
+    case Ops.In: {
+      return (context) => {
+        const value = args[0](context);
+        for (let i = 1; i < length; ++i) {
+          if (value === args[i](context)) {
+            return true;
+          }
+        }
+        return false;
+      };
+    }
     case Ops.Not: {
       return (context) => !args[0](context);
     }
@@ -529,6 +552,35 @@ function compileInterpolateExpression(expression, context) {
   };
 }
 
+/**
+ * @param {import('./expression.js').CallExpression} expression The call expression.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {ExpressionEvaluator} The evaluator function.
+ */
+function compileConvertExpression(expression, context) {
+  const op = expression.operator;
+  const length = expression.args.length;
+
+  const args = new Array(length);
+  for (let i = 0; i < length; ++i) {
+    args[i] = compileExpression(expression.args[i], context);
+  }
+  switch (op) {
+    case Ops.ToString: {
+      return (context) => {
+        const value = args[0](context);
+        if (expression.args[0].type === ColorType) {
+          return toString(value);
+        }
+        return value.toString();
+      };
+    }
+    default: {
+      throw new Error(`Unsupported convert operator ${op}`);
+    }
+  }
+}
+
 /**
  * @param {number} base The base.
  * @param {number} value The value.

package/expr/expression.d.ts

@@ -193,9 +193,9 @@ export type ArgValidator = (arg0: Array<EncodedExpression>, arg1: ParsingContext
  *   * `['all', value1, value2, ...]` returns `true` if all the inputs are `true`, `false` otherwise.
  *   * `['any', value1, value2, ...]` returns `true` if any of the inputs are `true`, `false` otherwise.
  *   * `['between', value1, value2, value3]` returns `true` if `value1` is contained between `value2` and `value3`
- *     (inclusively), or `false` otherwise (WebGL only).
+ *     (inclusively), or `false` otherwise.
  *   * `['in', needle, haystack]` returns `true` if `needle` is found in `haystack`, and
- *     `false` otherwise (WebGL only).
+ *     `false` otherwise.
  *     This operator has the following limitations:
  *     * `haystack` has to be an array of numbers or strings (searching for a substring in a string is not supported yet)
  *     * Only literal arrays are supported as `haystack` for now; this means that `haystack` cannot be the result of an
@@ -213,6 +213,9 @@ export type ArgValidator = (arg0: Array<EncodedExpression>, arg1: ParsingContext
  *     (e.g. `'#86A136'`), colors using the rgba[a] functional notation (e.g. `'rgb(134, 161, 54)'` or `'rgba(134, 161, 54, 1)'`),
  *     named colors (e.g. `'red'`), or array literals with 3 ([r, g, b]) or 4 ([r, g, b, a]) values (with r, g, and b
  *     in the 0-255 range and a in the 0-1 range) (WebGL only).
+ *   * `['to-string', value]` converts the input value to a string. If the input is a boolean, the result is "true" or "false".
+ *     If the input is a number, it is converted to a string as specified by the "NumberToString" algorithm of the ECMAScript
+ *     Language Specification. If the input is a color, it is converted to a string of the form "rgba(r,g,b,a)". (Canvas only)
  *
  * Values can either be literals or another operator, as they will be evaluated recursively.
  * Literal values can be of the following types:

package/expr/expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AA0IA;;;;GAIG;AACH,+BAHW,MAAM,GACL,MAAM,CAgBjB;AAED;;;;GAIG;AACH,oCAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,sCAJW,MAAM,aACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,6BAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AA8BD;;GAEG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AACH,qCAFY,cAAc,CAUzB;AAuBD;;GAEG;AAEH;;;;;GAKG;AACH,+BALW,iBAAiB,WACjB,cAAc,kCAEb,UAAU,CAoDrB;AAqyBD;;;;GAIG;AACH,8CAHW,OAAO,qBAAqB,EAAE,OAAO,GAAC,OAAO,sBAAsB,EAAE,OAAO,GAC3E,OAAO,GAAC,YAAY,GAAC,SAAS,GAAC,EAAE,CA2B5C;AA5gCD,yBAA0B;AAC1B,iCAA2C;AAC3C,gCAA0C;AAC1C,gCAA0C;AAC1C,+BAAyC;AACzC,qCAA+C;AAC/C,6BAAiD;AA4DjD;;GAEG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,YAAY,EAKtB;IAFC,aAAgB;IAChB,oBAAkB;CAErB;AAED;IACE;;;;OAIG;IACH,kBAJW,MAAM,YACN,MAAM,WACH,UAAU,IAMvB;IAHC,aAAgB;IAChB,iBAAwB;IACxB,mBAAgB;CAEnB;AA+GD;;GAEG;AACH;QAFiB,MAAM,GAAE,MAAM;EA+C7B;yBA5JW,iBAAiB,GAAC,cAAc;;;;;eAK/B,IAAI,MAAM,CAAC;;;;gBACX,IAAI,MAAM,CAAC;;;;eACX,OAAO;;;;kBACP,OAAO;;;;WACP,OAAO,kBAAkB,EAAE,SAAS,GAAC,OAAO,mBAAmB,EAAE,UAAU;;gCAsC5E,YAAY,QAAM;;;;;;;kCAoXT,MAAM,iBAAiB,CAAC,QAAE,cAAc,QAAE,MAAM,UAAU,CAAC,QAAE,MAAM,YAAG,MAAM,UAAU,CAAC,GAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAvgBrG,UAAQ,GAAC,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO;2BAwE1D,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,MAAM,CAAC;;;;yCA2LnB,cAAc,QAAE,MAAM,KAAE,UAAU"}
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AA6IA;;;;GAIG;AACH,+BAHW,MAAM,GACL,MAAM,CAgBjB;AAED;;;;GAIG;AACH,oCAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,sCAJW,MAAM,aACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,6BAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AA8BD;;GAEG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AACH,qCAFY,cAAc,CAUzB;AAuBD;;GAEG;AAEH;;;;;GAKG;AACH,+BALW,iBAAiB,WACjB,cAAc,kCAEb,UAAU,CAoDrB;AA2yBD;;;;GAIG;AACH,8CAHW,OAAO,qBAAqB,EAAE,OAAO,GAAC,OAAO,sBAAsB,EAAE,OAAO,GAC3E,OAAO,GAAC,YAAY,GAAC,SAAS,GAAC,EAAE,CA2B5C;AAlhCD,yBAA0B;AAC1B,iCAA2C;AAC3C,gCAA0C;AAC1C,gCAA0C;AAC1C,+BAAyC;AACzC,qCAA+C;AAC/C,6BAAiD;AA4DjD;;GAEG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,YAAY,EAKtB;IAFC,aAAgB;IAChB,oBAAkB;CAErB;AAED;IACE;;;;OAIG;IACH,kBAJW,MAAM,YACN,MAAM,WACH,UAAU,IAMvB;IAHC,aAAgB;IAChB,iBAAwB;IACxB,mBAAgB;CAEnB;AA+GD;;GAEG;AACH;QAFiB,MAAM,GAAE,MAAM;EAgD7B;yBA7JW,iBAAiB,GAAC,cAAc;;;;;eAK/B,IAAI,MAAM,CAAC;;;;gBACX,IAAI,MAAM,CAAC;;;;eACX,OAAO;;;;kBACP,OAAO;;;;WACP,OAAO,kBAAkB,EAAE,SAAS,GAAC,OAAO,mBAAmB,EAAE,UAAU;;gCAsC5E,YAAY,QAAM;;;;;;;kCA0XT,MAAM,iBAAiB,CAAC,QAAE,cAAc,QAAE,MAAM,UAAU,CAAC,QAAE,MAAM,YAAG,MAAM,UAAU,CAAC,GAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA7gBrG,UAAQ,GAAC,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO;2BAwE1D,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,MAAM,CAAC;;;;yCA4LnB,cAAc,QAAE,MAAM,KAAE,UAAU"}

package/expr/expression.js

@@ -84,9 +84,9 @@ import {isStringColor} from '../color.js';
  *   * `['all', value1, value2, ...]` returns `true` if all the inputs are `true`, `false` otherwise.
  *   * `['any', value1, value2, ...]` returns `true` if any of the inputs are `true`, `false` otherwise.
  *   * `['between', value1, value2, value3]` returns `true` if `value1` is contained between `value2` and `value3`
- *     (inclusively), or `false` otherwise (WebGL only).
+ *     (inclusively), or `false` otherwise.
  *   * `['in', needle, haystack]` returns `true` if `needle` is found in `haystack`, and
- *     `false` otherwise (WebGL only).
+ *     `false` otherwise.
  *     This operator has the following limitations:
  *     * `haystack` has to be an array of numbers or strings (searching for a substring in a string is not supported yet)
  *     * Only literal arrays are supported as `haystack` for now; this means that `haystack` cannot be the result of an
@@ -104,6 +104,9 @@ import {isStringColor} from '../color.js';
  *     (e.g. `'#86A136'`), colors using the rgba[a] functional notation (e.g. `'rgb(134, 161, 54)'` or `'rgba(134, 161, 54, 1)'`),
  *     named colors (e.g. `'red'`), or array literals with 3 ([r, g, b]) or 4 ([r, g, b, a]) values (with r, g, and b
  *     in the 0-255 range and a in the 0-1 range) (WebGL only).
+ *   * `['to-string', value]` converts the input value to a string. If the input is a boolean, the result is "true" or "false".
+ *     If the input is a number, it is converted to a string as specified by the "NumberToString" algorithm of the ECMAScript
+ *     Language Specification. If the input is a color, it is converted to a string of the form "rgba(r,g,b,a)". (Canvas only)
  *
  * Values can either be literals or another operator, as they will be evaluated recursively.
  * Literal values can be of the following types:
@@ -369,6 +372,7 @@ export const Ops = {
   Id: 'id',
   Band: 'band',
   Palette: 'palette',
+  ToString: 'to-string',
 };
 
 /**
@@ -629,6 +633,11 @@ const parsers = {
     parseArgsOfType(NumberType),
   ),
   [Ops.Palette]: createParser(ColorType, withArgsCount(2, 2), parsePaletteArgs),
+  [Ops.ToString]: createParser(
+    StringType,
+    withArgsCount(1, 1),
+    parseArgsOfType(BooleanType | NumberType | StringType | ColorType),
+  ),
 };
 
 /**

package/expr/gpu.js

@@ -440,6 +440,7 @@ ${ifBlocks}
   // Ops.String
   // Ops.Coalesce
   // Ops.Concat
+  // Ops.ToString
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "9.0.1-dev.1708958348077",
+  "version": "9.0.1-dev.1709106981367",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '9.0.1-dev.1708958348077';
+export const VERSION = '9.0.1-dev.1709106981367';