@reearth/core 0.0.1

package/src/mantle/evaluator/simple/expression/expression.ts

@@ -0,0 +1,116 @@
+import jsep from "jsep";
+
+import { Feature } from "../../../types";
+
+import { backslashRegex, backslashReplacement } from "./constants";
+import { Node } from "./node";
+import { createRuntimeAst } from "./runtime";
+import { replaceVariables, VARIABLE_PREFIX } from "./variableReplacer";
+
+export type JPLiteral = {
+  literalName: string;
+  literalValue: any;
+};
+
+export const EXPRESSION_CACHES = new Map<string, Node | Error>();
+export const REPLACED_VARIABLES_CACHE = new Map<string, [string, JPLiteral[]]>();
+const DEFINE_PLACEHOLDER_REGEX_CACHE = new Map<string, RegExp>();
+const DEFINE_REPLACEMENT_CACHE = new Map<string, string>();
+
+export class Expression {
+  private _expression: string;
+  private _runtimeAst: Node | Error;
+  private _feature?: Feature;
+
+  constructor(expression: string, feature?: Feature, defines?: any) {
+    this._expression = expression;
+    this._feature = feature;
+    let literalJP: JPLiteral[] = [];
+
+    expression = replaceDefines(expression, defines);
+    const cachedReplacedVariables = REPLACED_VARIABLES_CACHE.get(expression);
+    // JSONPath returns simple literal so we can not cache in here
+    if (cachedReplacedVariables) {
+      [expression, literalJP] = cachedReplacedVariables;
+    } else {
+      const originalExpression = expression;
+      [expression, literalJP] = replaceVariables(
+        removeBackslashes(expression),
+        this._feature?.properties,
+      );
+      if (expression.includes(VARIABLE_PREFIX)) {
+        REPLACED_VARIABLES_CACHE.set(originalExpression, [expression, literalJP]);
+      }
+    }
+
+    const cachedAST = EXPRESSION_CACHES.get(expression);
+    if (cachedAST) {
+      this._runtimeAst = cachedAST;
+    } else {
+      if (literalJP.length !== 0) {
+        for (const elem of literalJP) {
+          jsep.addLiteral(elem.literalName, elem.literalValue);
+        }
+      }
+
+      // customize jsep operators
+      jsep.addBinaryOp("=~", 0);
+      jsep.addBinaryOp("!~", 0);
+
+      let ast;
+      try {
+        ast = jsep(expression);
+      } catch (e) {
+        throw new Error(`failed to generate ast: ${e}`);
+      }
+
+      this._runtimeAst = createRuntimeAst(this, ast);
+      EXPRESSION_CACHES.set(expression, this._runtimeAst);
+    }
+  }
+
+  evaluate() {
+    const value = (this._runtimeAst as Node).evaluate(this._feature);
+    return value;
+  }
+}
+
+export function replaceDefines(expression: string, defines: any): string {
+  if (typeof defines === "undefined") {
+    return expression;
+  }
+  const definesKey = JSON.stringify(Object.entries(defines).sort());
+  const cacheKey = expression + definesKey;
+
+  const cachedResult = DEFINE_REPLACEMENT_CACHE.get(cacheKey);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let definePlaceholderRegex = DEFINE_PLACEHOLDER_REGEX_CACHE.get(expression);
+  if (!definePlaceholderRegex) {
+    definePlaceholderRegex = new RegExp(`\\$\\{(${Object.keys(defines).join("|")})\\}`, "g");
+    DEFINE_PLACEHOLDER_REGEX_CACHE.set(expression, definePlaceholderRegex);
+  }
+  const replacedExpression = expression.replace(definePlaceholderRegex, (_, key) =>
+    typeof defines[key] !== "undefined" ? `(${defines[key]})` : "",
+  );
+
+  DEFINE_REPLACEMENT_CACHE.set(cacheKey, replacedExpression);
+  return replacedExpression;
+}
+
+export function removeBackslashes(expression: string): string {
+  return expression.replace(backslashRegex, backslashReplacement);
+}
+
+export function clearExpressionCaches(
+  expression: string,
+  feature: Feature | undefined,
+  defines: any | undefined,
+) {
+  REPLACED_VARIABLES_CACHE.delete(expression);
+
+  expression = replaceDefines(expression, defines);
+  [expression] = replaceVariables(removeBackslashes(expression), feature?.properties);
+  EXPRESSION_CACHES.delete(expression);
+}

package/src/mantle/evaluator/simple/expression/functions/binaryFunctions.ts

@@ -0,0 +1,43 @@
+type BinaryFunction = (call: string, left: number | string, right: number | string) => any;
+
+export function getEvaluateBinaryFunction(call: string): (feature: any) => number {
+  const evaluate = binaryFunctions[call];
+  return function (this: { _left: any; _right: any }, feature: any): number {
+    const left = this._left.evaluate(feature);
+    const right = this._right.evaluate(feature);
+    return evaluate(call, left, right);
+  };
+}
+
+export const binaryFunctions: { [key: string]: BinaryFunction } = {
+  atan2: getEvaluateBinaryComponentwise(Math.atan2, false),
+  pow: getEvaluateBinaryComponentwise(Math.pow, false),
+  min: getEvaluateBinaryComponentwise(Math.min, true),
+  max: getEvaluateBinaryComponentwise(Math.max, true),
+  startsWith: getEvaluateBinaryComponentwise(startsWith, false),
+};
+
+function getEvaluateBinaryComponentwise(operation: any, allowScalar: boolean): BinaryFunction {
+  return function (call: any, left: any, right: any) {
+    if (allowScalar && typeof right === "number") {
+      if (typeof left === "number") {
+        return operation(left, right);
+      }
+    }
+    if (typeof left === "number" && typeof right === "number") {
+      return operation(left, right);
+    }
+
+    if (typeof left === "string" && typeof right === "string") {
+      return operation(left, right);
+    }
+
+    throw new Error(
+      `Function "${call}" requires vector or number arguments of matching types. Arguments are ${left} and ${right}.`,
+    );
+  };
+}
+
+function startsWith(left: string, right: string): boolean {
+  return left.startsWith(right);
+}

package/src/mantle/evaluator/simple/expression/functions/colors.ts

@@ -0,0 +1,189 @@
+import { defaultValue } from "../../../../utils";
+import { rgbaMatcher, rrggbbaaMatcher, builtInColor } from "../constants";
+
+//rgb(), rgba(), or rgb%()
+const rgbParenthesesMatcher =
+  /^rgba?\(\s*([0-9.]+%?)\s*,\s*([0-9.]+%?)\s*,\s*([0-9.]+%?)(?:\s*,\s*([0-9.]+))?\s*\)$/i;
+//hsl() or hsla()
+const hslParenthesesMatcher =
+  /^hsla?\(\s*([0-9.]+)\s*,\s*([0-9.]+%)\s*,\s*([0-9.]+%)(?:\s*,\s*([0-9.]+))?\s*\)$/i;
+
+export class Color {
+  red: number;
+  green: number;
+  blue: number;
+  alpha: number;
+  constructor(red?: number, green?: number, blue?: number, alpha?: number) {
+    this.red = defaultValue(red, 1.0);
+    this.green = defaultValue(green, 1.0);
+    this.blue = defaultValue(blue, 1.0);
+    this.alpha = defaultValue(alpha, 1.0);
+  }
+
+  static byteToFloat(number: number): number {
+    return number / 255.0;
+  }
+  static floatToByte(number: number): number {
+    return number === 1.0 ? 255.0 : (number * 256.0) | 0;
+  }
+
+  static fromCssColorString(color: string): Color | undefined {
+    // Remove all whitespaces from the color string
+    color = color.replace(/\s/g, "");
+
+    const namedColor = getColor(color);
+    if (typeof namedColor !== "undefined") {
+      return namedColor;
+    }
+
+    let matches = rgbaMatcher.exec(color);
+    if (matches !== null) {
+      const result = new Color();
+      result.red = parseInt(matches[1], 16) / 15;
+      result.green = parseInt(matches[2], 16) / 15.0;
+      result.blue = parseInt(matches[3], 16) / 15.0;
+      result.alpha = parseInt(defaultValue(matches[4], "f"), 16) / 15.0;
+      return result;
+    }
+
+    matches = rrggbbaaMatcher.exec(color);
+    if (matches !== null) {
+      const result = new Color();
+      result.red = parseInt(matches[1], 16) / 255.0;
+      result.green = parseInt(matches[2], 16) / 255.0;
+      result.blue = parseInt(matches[3], 16) / 255.0;
+      result.alpha = parseInt(defaultValue(matches[4], "ff"), 16) / 255.0;
+      return result;
+    }
+
+    matches = rgbParenthesesMatcher.exec(color);
+    if (matches !== null) {
+      const result = new Color();
+      result.red = parseFloat(matches[1]) / ("%" === matches[1].substr(-1) ? 100.0 : 255.0);
+      result.green = parseFloat(matches[2]) / ("%" === matches[2].substr(-1) ? 100.0 : 255.0);
+      result.blue = parseFloat(matches[3]) / ("%" === matches[3].substr(-1) ? 100.0 : 255.0);
+      result.alpha = parseFloat(defaultValue(matches[4], "1.0"));
+      return result;
+    }
+
+    matches = hslParenthesesMatcher.exec(color);
+    if (matches !== null) {
+      return Color.fromHsl(
+        parseFloat(matches[1]) / 360.0,
+        parseFloat(matches[2]) / 100.0,
+        parseFloat(matches[3]) / 100.0,
+        parseFloat(defaultValue(matches[4], "1.0")),
+      );
+    }
+    return undefined;
+  }
+
+  static fromHsl(
+    hue?: number,
+    saturation?: number,
+    lightness?: number,
+    alpha?: number,
+  ): Color | undefined {
+    hue = defaultValue(hue, 0.0) % 1.0;
+    saturation = defaultValue(saturation, 0.0);
+    lightness = defaultValue(lightness, 0.0);
+    alpha = defaultValue(alpha, 1.0);
+
+    if (hue && saturation && lightness && alpha) {
+      let red = lightness;
+      let green = lightness;
+      let blue = lightness;
+      const result = new Color();
+
+      if (saturation !== 0) {
+        let m2;
+        if (lightness < 0.5) {
+          m2 = lightness * (1 + saturation);
+        } else {
+          m2 = lightness + saturation - lightness * saturation;
+        }
+
+        const m1 = 2.0 * lightness - m2;
+        red = hue2rgb(m1, m2, hue + 1 / 3);
+        green = hue2rgb(m1, m2, hue);
+        blue = hue2rgb(m1, m2, hue - 1 / 3);
+      }
+
+      if (typeof result === "undefined") {
+        return new Color(red, green, blue, alpha);
+      }
+
+      result.red = red;
+      result.green = green;
+      result.blue = blue;
+      result.alpha = alpha;
+      return result;
+    }
+    return undefined;
+  }
+
+  toCssHexString() {
+    let r = Color.floatToByte(this.red).toString(16);
+    if (r.length < 2) {
+      r = `0${r}`;
+    }
+    let g = Color.floatToByte(this.green).toString(16);
+    if (g.length < 2) {
+      g = `0${g}`;
+    }
+    let b = Color.floatToByte(this.blue).toString(16);
+    if (b.length < 2) {
+      b = `0${b}`;
+    }
+    if (this.alpha < 1) {
+      let hexAlpha = Color.floatToByte(this.alpha).toString(16);
+      if (hexAlpha.length < 2) {
+        hexAlpha = `0${hexAlpha}`;
+      }
+      return `#${r}${g}${b}${hexAlpha}`;
+    }
+    return `#${r}${g}${b}`.toUpperCase();
+  }
+
+  static fromBytes(red: number, green: number, blue: number, alpha: number) {
+    red = this.byteToFloat(defaultValue(red, 255.0));
+    green = Color.byteToFloat(defaultValue(green, 255.0));
+    blue = Color.byteToFloat(defaultValue(blue, 255.0));
+    alpha = Color.byteToFloat(defaultValue(alpha, 255.0));
+
+    return new Color(red, green, blue, alpha);
+  }
+}
+
+function getColor(color: string): Color | undefined {
+  color = color.toUpperCase();
+  if (builtInColor[color]) {
+    return Color.fromCssColorString(builtInColor[color]);
+  }
+
+  switch (color) {
+    case "TRANSPARENT":
+      return new Color(0, 0, 0, 0);
+    default:
+      return undefined;
+  }
+}
+
+function hue2rgb(m1: number, m2: number, h: number): number {
+  if (h < 0) {
+    h += 1;
+  }
+  if (h > 1) {
+    h -= 1;
+  }
+  if (h * 6 < 1) {
+    return m1 + (m2 - m1) * 6 * h;
+  }
+  if (h * 2 < 1) {
+    return m2;
+  }
+  if (h * 3 < 2) {
+    return m1 + (m2 - m1) * (2 / 3 - h) * 6;
+  }
+  return m1;
+}

package/src/mantle/evaluator/simple/expression/functions/index.ts

@@ -0,0 +1,3 @@
+export { binaryFunctions, getEvaluateBinaryFunction } from "./binaryFunctions";
+export { unaryFunctions, getEvaluateUnaryFunction } from "./unaryFunctions";
+export { Color } from "./colors";

package/src/mantle/evaluator/simple/expression/functions/unaryFunctions.ts

@@ -0,0 +1,54 @@
+import { Math as CesiumMath } from "cesium";
+
+type UnaryFunction = (call: string, left: number) => number;
+
+export function getEvaluateUnaryFunction(call: string): (feature: any) => number {
+  const evaluate = unaryFunctions[call];
+  return function (this: { _left: any }, feature: any): number {
+    const left = this._left.evaluate(feature);
+    return evaluate(call, left);
+  };
+}
+
+export const unaryFunctions: { [key: string]: UnaryFunction } = {
+  abs: getEvaluateUnaryComponentwise(Math.abs),
+  sqrt: getEvaluateUnaryComponentwise(Math.sqrt),
+  cos: getEvaluateUnaryComponentwise(Math.cos),
+  sin: getEvaluateUnaryComponentwise(Math.sin),
+  tan: getEvaluateUnaryComponentwise(Math.tan),
+  acos: getEvaluateUnaryComponentwise(Math.acos),
+  asin: getEvaluateUnaryComponentwise(Math.asin),
+  atan: getEvaluateUnaryComponentwise(Math.atan),
+  radians: getEvaluateUnaryComponentwise(CesiumMath.toRadians),
+  degrees: getEvaluateUnaryComponentwise(CesiumMath.toDegrees),
+  sign: getEvaluateUnaryComponentwise(CesiumMath.sign),
+  floor: getEvaluateUnaryComponentwise(Math.floor),
+  ceil: getEvaluateUnaryComponentwise(Math.ceil),
+  round: getEvaluateUnaryComponentwise(Math.round),
+  exp2: getEvaluateUnaryComponentwise(exp2),
+  log: getEvaluateUnaryComponentwise(Math.log),
+  log2: getEvaluateUnaryComponentwise(log2),
+  fract: getEvaluateUnaryComponentwise(fract),
+};
+function getEvaluateUnaryComponentwise(operation: (value: number) => number): UnaryFunction {
+  return function (call: any, left: any) {
+    if (typeof left === "number") {
+      return operation(left);
+    }
+    throw new Error(
+      `Function "${call}" requires a vector or number argument. Argument is ${left}.`,
+    );
+  };
+}
+
+function fract(number: number): number {
+  return number - Math.floor(number);
+}
+
+function exp2(exponent: number): number {
+  return Math.pow(2.0, exponent);
+}
+
+function log2(number: number): number {
+  return CesiumMath.log2(number);
+}

package/src/mantle/evaluator/simple/expression/index.ts

@@ -0,0 +1 @@
+export { Expression, clearExpressionCaches } from "./expression";