ol 7.5.1 → 8.0.0-dev.1692053484481

package/expr/cpu.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview This module includes functions to build expressions for evaluation on the CPU.
+ * Building is composed of two steps: parsing and compiling.  The parsing step takes an encoded
+ * expression and returns an instance of one of the expression classes.  The compiling step takes
+ * the expression instance and returns a function that can be evaluated in to return a literal
+ * value.  The evaluator function should do as little allocation and work as possible.
+ */
+/**
+ * @typedef {Object} EvaluationContext
+ * @property {Object} properties The values for properties used in 'get' expressions.
+ * @property {Object} variables The values for variables used in 'var' expressions.
+ * @property {number} resolution The map resolution.
+ */
+/**
+ * @return {EvaluationContext} A new evaluation context.
+ */
+export function newEvaluationContext(): EvaluationContext;
+/**
+ * @typedef {function(EvaluationContext):import("./expression.js").LiteralValue} ExpressionEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):boolean} BooleanEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):number} NumberEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):string} StringEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):(Array<number>|string)} ColorLikeEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):Array<number>} NumberArrayEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):Array<number>} CoordinateEvaluator
+ */
+/**
+ * @typedef {function(EvaluationContext):(Array<number>|number)} SizeLikeEvaluator
+ */
+/**
+ * @param {import('./expression.js').EncodedExpression} encoded The encoded expression.
+ * @param {number} type The expected type.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {ExpressionEvaluator} The expression evaluator.
+ */
+export function buildExpression(encoded: import('./expression.js').EncodedExpression, type: number, context: import('./expression.js').ParsingContext): ExpressionEvaluator;
+export type EvaluationContext = {
+    /**
+     * The values for properties used in 'get' expressions.
+     */
+    properties: any;
+    /**
+     * The values for variables used in 'var' expressions.
+     */
+    variables: any;
+    /**
+     * The map resolution.
+     */
+    resolution: number;
+};
+export type ExpressionEvaluator = (arg0: EvaluationContext) => import("./expression.js").LiteralValue;
+export type BooleanEvaluator = (arg0: EvaluationContext) => boolean;
+export type NumberEvaluator = (arg0: EvaluationContext) => number;
+export type StringEvaluator = (arg0: EvaluationContext) => string;
+export type ColorLikeEvaluator = (arg0: EvaluationContext) => (Array<number> | string);
+export type NumberArrayEvaluator = (arg0: EvaluationContext) => Array<number>;
+export type CoordinateEvaluator = (arg0: EvaluationContext) => Array<number>;
+export type SizeLikeEvaluator = (arg0: EvaluationContext) => (Array<number> | number);
+//# sourceMappingURL=cpu.d.ts.map

package/expr/cpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpu.d.ts","sourceRoot":"","sources":["cpu.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;GAEG;AACH,wCAFY,iBAAiB,CAQ5B;AAED;;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;;;;;;;;;;;;;gBA9Da,MAAM;;yCAeE,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;uCAIhC,iBAAiB,KAAE,CAAC,MAAM,MAAM,CAAC,GAAC,MAAM,CAAC"}

package/expr/cpu.js

@@ -0,0 +1,312 @@
+/**
+ * @module ol/expr/cpu
+ */
+
+import {
+  LiteralExpression,
+  Ops,
+  overlapsType,
+  parse,
+  typeName,
+} from './expression.js';
+
+/**
+ * @fileoverview This module includes functions to build expressions for evaluation on the CPU.
+ * Building is composed of two steps: parsing and compiling.  The parsing step takes an encoded
+ * expression and returns an instance of one of the expression classes.  The compiling step takes
+ * the expression instance and returns a function that can be evaluated in to return a literal
+ * value.  The evaluator function should do as little allocation and work as possible.
+ */
+
+/**
+ * @typedef {Object} EvaluationContext
+ * @property {Object} properties The values for properties used in 'get' expressions.
+ * @property {Object} variables The values for variables used in 'var' expressions.
+ * @property {number} resolution The map resolution.
+ */
+
+/**
+ * @return {EvaluationContext} A new evaluation context.
+ */
+export function newEvaluationContext() {
+  return {
+    variables: {},
+    properties: {},
+    resolution: NaN,
+  };
+}
+
+/**
+ * @typedef {function(EvaluationContext):import("./expression.js").LiteralValue} ExpressionEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):boolean} BooleanEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):number} NumberEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):string} StringEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):(Array<number>|string)} ColorLikeEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):Array<number>} NumberArrayEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):Array<number>} CoordinateEvaluator
+ */
+
+/**
+ * @typedef {function(EvaluationContext):(Array<number>|number)} SizeLikeEvaluator
+ */
+
+/**
+ * @param {import('./expression.js').EncodedExpression} encoded The encoded expression.
+ * @param {number} type The expected type.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {ExpressionEvaluator} The expression evaluator.
+ */
+export function buildExpression(encoded, type, context) {
+  const expression = parse(encoded, context);
+  if (!overlapsType(type, expression.type)) {
+    const expected = typeName(type);
+    const actual = typeName(expression.type);
+    throw new Error(
+      `Expected expression to be of type ${expected}, got ${actual}`
+    );
+  }
+  return compileExpression(expression, context);
+}
+
+/**
+ * @param {import("./expression.js").Expression} expression The expression.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {ExpressionEvaluator} The evaluator function.
+ */
+function compileExpression(expression, context) {
+  if (expression instanceof LiteralExpression) {
+    return function () {
+      return expression.value;
+    };
+  }
+  const operator = expression.operator;
+  switch (operator) {
+    case Ops.Get:
+    case Ops.Var: {
+      return compileAccessorExpression(expression, context);
+    }
+    case Ops.Equal:
+    case Ops.NotEqual:
+    case Ops.LessThan:
+    case Ops.LessThanOrEqualTo:
+    case Ops.GreaterThan:
+    case Ops.GreaterThanOrEqualTo: {
+      return compileComparisonExpression(expression, context);
+    }
+    case Ops.Multiply:
+    case Ops.Divide:
+    case Ops.Add:
+    case Ops.Subtract:
+    case Ops.Clamp:
+    case Ops.Mod:
+    case Ops.Pow:
+    case Ops.Abs:
+    case Ops.Floor:
+    case Ops.Ceil:
+    case Ops.Round:
+    case Ops.Sin:
+    case Ops.Cos:
+    case Ops.Atan:
+    case Ops.Sqrt: {
+      return compileNumericExpression(expression, context);
+    }
+    case Ops.Match: {
+      return compileMatchExpression(expression, context);
+    }
+    default: {
+      throw new Error(`Unsupported operator ${operator}`);
+    }
+  }
+}
+
+/**
+ * @param {import('./expression.js').CallExpression} expression The call expression.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {ExpressionEvaluator} The evaluator function.
+ */
+function compileAccessorExpression(expression, context) {
+  const nameExpression = expression.args[0];
+  if (!(nameExpression instanceof LiteralExpression)) {
+    throw new Error('Expected literal name');
+  }
+  const name = nameExpression.value;
+  if (typeof name !== 'string') {
+    throw new Error('Expected string name');
+  }
+  switch (expression.operator) {
+    case Ops.Get: {
+      return (context) => context.properties[name];
+    }
+    case Ops.Var: {
+      return (context) => context.variables[name];
+    }
+    default: {
+      throw new Error(`Unsupported accessor operator ${expression.operator}`);
+    }
+  }
+}
+
+/**
+ * @param {import('./expression.js').CallExpression} expression The call expression.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {BooleanEvaluator} The evaluator function.
+ */
+function compileComparisonExpression(expression, context) {
+  const op = expression.operator;
+  const left = compileExpression(expression.args[0], context);
+  const right = compileExpression(expression.args[1], context);
+  switch (op) {
+    case Ops.Equal: {
+      return (context) => left(context) === right(context);
+    }
+    case Ops.NotEqual: {
+      return (context) => left(context) !== right(context);
+    }
+    case Ops.LessThan: {
+      return (context) => left(context) < right(context);
+    }
+    case Ops.LessThanOrEqualTo: {
+      return (context) => left(context) <= right(context);
+    }
+    case Ops.GreaterThan: {
+      return (context) => left(context) > right(context);
+    }
+    case Ops.GreaterThanOrEqualTo: {
+      return (context) => left(context) >= right(context);
+    }
+    default: {
+      throw new Error(`Unsupported comparison operator ${op}`);
+    }
+  }
+}
+
+/**
+ * @param {import('./expression.js').CallExpression} expression The call expression.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {NumberEvaluator} The evaluator function.
+ */
+function compileNumericExpression(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.Multiply: {
+      return (context) => {
+        let value = 1;
+        for (let i = 0; i < length; ++i) {
+          value *= args[i](context);
+        }
+        return value;
+      };
+    }
+    case Ops.Divide: {
+      return (context) => args[0](context) / args[1](context);
+    }
+    case Ops.Add: {
+      return (context) => {
+        let value = 0;
+        for (let i = 0; i < length; ++i) {
+          value += args[i](context);
+        }
+        return value;
+      };
+    }
+    case Ops.Subtract: {
+      return (context) => args[0](context) - args[1](context);
+    }
+    case Ops.Clamp: {
+      return (context) => {
+        const value = args[0](context);
+        const min = args[1](context);
+        if (value < min) {
+          return min;
+        }
+        const max = args[2](context);
+        if (value > max) {
+          return max;
+        }
+        return value;
+      };
+    }
+    case Ops.Mod: {
+      return (context) => args[0](context) % args[1](context);
+    }
+    case Ops.Pow: {
+      return (context) => Math.pow(args[0](context), args[1](context));
+    }
+    case Ops.Abs: {
+      return (context) => Math.abs(args[0](context));
+    }
+    case Ops.Floor: {
+      return (context) => Math.floor(args[0](context));
+    }
+    case Ops.Ceil: {
+      return (context) => Math.ceil(args[0](context));
+    }
+    case Ops.Round: {
+      return (context) => Math.round(args[0](context));
+    }
+    case Ops.Sin: {
+      return (context) => Math.sin(args[0](context));
+    }
+    case Ops.Cos: {
+      return (context) => Math.cos(args[0](context));
+    }
+    case Ops.Atan: {
+      if (length === 2) {
+        return (context) => Math.atan2(args[0](context), args[1](context));
+      }
+      return (context) => Math.atan(args[0](context));
+    }
+    case Ops.Sqrt: {
+      return (context) => Math.sqrt(args[0](context));
+    }
+    default: {
+      throw new Error(`Unsupported numeric operator ${op}`);
+    }
+  }
+}
+
+/**
+ * @param {import('./expression.js').CallExpression} expression The call expression.
+ * @param {import('./expression.js').ParsingContext} context The parsing context.
+ * @return {ExpressionEvaluator} The evaluator function.
+ */
+function compileMatchExpression(expression, context) {
+  const length = expression.args.length;
+  const args = new Array(length);
+  for (let i = 0; i < length; ++i) {
+    args[i] = compileExpression(expression.args[i], context);
+  }
+  return (context) => {
+    const value = args[0](context);
+    for (let i = 1; i < length; i += 2) {
+      if (value === args[i](context)) {
+        return args[i + 1](context);
+      }
+    }
+    return args[length - 1](context);
+  };
+}

package/expr/expression.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Get a string representation for a type.
+ * @param {number} type The type.
+ * @return {string} The type name.
+ */
+export function typeName(type: number): string;
+/**
+ * @param {number} broad The broad type.
+ * @param {number} specific The specific type.
+ * @return {boolean} The broad type includes the specific type.
+ */
+export function includesType(broad: number, specific: number): boolean;
+/**
+ * @param {number} oneType One type.
+ * @param {number} otherType Another type.
+ * @return {boolean} The set of types overlap (share a common specific type)
+ */
+export function overlapsType(oneType: number, otherType: number): boolean;
+/**
+ * @param {number} type The type.
+ * @param {number} expected The expected type.
+ * @return {boolean} The given type is exactly the expected type.
+ */
+export function isType(type: number, expected: number): boolean;
+/**
+ * @typedef {LiteralExpression|CallExpression} Expression
+ */
+/**
+ * @typedef {Object} ParsingContext
+ * @property {Set<string>} variables Variables referenced with the 'var' operator.
+ * @property {Set<string>} properties Properties referenced with the 'get' operator.
+ */
+/**
+ * @return {ParsingContext} A new parsing context.
+ */
+export function newParsingContext(): ParsingContext;
+/**
+ * @typedef {LiteralValue|Array} EncodedExpression
+ */
+/**
+ * @param {EncodedExpression} encoded The encoded expression.
+ * @param {ParsingContext} context The parsing context.
+ * @return {Expression} The parsed expression result.
+ */
+export function parse(encoded: EncodedExpression, context: ParsingContext): Expression;
+export const NoneType: 0;
+export const BooleanType: number;
+export const NumberType: number;
+export const StringType: number;
+export const ColorType: number;
+export const NumberArrayType: number;
+export const AnyType: number;
+/**
+ * @typedef {boolean|number|string|Array<number>} LiteralValue
+ */
+export class LiteralExpression {
+    /**
+     * @param {number} type The value type.
+     * @param {LiteralValue} value The literal value.
+     */
+    constructor(type: number, value: LiteralValue);
+    type: number;
+    value: LiteralValue;
+}
+export class CallExpression {
+    /**
+     * @param {number} type The return type.
+     * @param {string} operator The operator.
+     * @param {...Expression} args The arguments.
+     */
+    constructor(type: number, operator: string, ...args: Expression[]);
+    type: number;
+    operator: string;
+    args: Expression[];
+}
+/**
+ * @type {Object<string, string>}
+ */
+export const Ops: {
+    [x: string]: string;
+};
+export type Expression = LiteralExpression | CallExpression;
+export type ParsingContext = {
+    /**
+     * Variables referenced with the 'var' operator.
+     */
+    variables: Set<string>;
+    /**
+     * Properties referenced with the 'get' operator.
+     */
+    properties: Set<string>;
+};
+export type EncodedExpression = LiteralValue | any[];
+export type ArgValidator = (arg0: any[], arg1: ParsingContext) => Array<Expression>;
+export type LiteralValue = boolean | number | string | Array<number>;
+export type Parser = (arg0: any[], arg1: ParsingContext) => Expression;
+//# sourceMappingURL=expression.d.ts.map

package/expr/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AAgCA;;;;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;;;;GAIG;AAEH;;GAEG;AACH,qCAFY,cAAc,CAOzB;AAED;;GAEG;AAEH;;;;GAIG;AACH,+BAJW,iBAAiB,WACjB,cAAc,GACb,UAAU,CA0CrB;AAnKD,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;AAyED;;GAEG;AACH;QAFiB,MAAM,GAAE,MAAM;EA4B7B;yBAnGW,iBAAiB,GAAC,cAAc;;;;;eAK/B,IAAI,MAAM,CAAC;;;;gBACX,IAAI,MAAM,CAAC;;gCAcZ,YAAY,QAAM;+CA2HF,cAAc,KAAE,MAAM,UAAU,CAAC;2BA3KjD,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,MAAM,CAAC;yCAkInB,cAAc,KAAE,UAAU"}