perf: add cache support to evaluation in reearth/core

package.json

@@ -135,6 +135,7 @@
         "leaflet": "1.9.3",
         "localforage": "1.10.0",
         "lodash-es": "4.17.21",
+        "lru-cache": "^8.0.4",
         "mini-svg-data-uri": "1.4.4",
         "parse-domain": "7.0.1",
         "quickjs-emscripten": "0.21.1",

src/core/mantle/evaluator/simple/index.ts

@@ -1,4 +1,5 @@
 import { pick } from "lodash-es";
+import LRUCache from "lru-cache";
 
 import type { EvalContext, EvalResult } from "..";
 import {
@@ -15,6 +16,9 @@ import {
 import { ConditionalExpression } from "./conditionalExpression";
 import { clearExpressionCaches, Expression } from "./expression";
 import { evalTimeInterval } from "./interval";
+import { getCacheableProperties } from "./utils";
+
+const EVAL_EXPRESSION_CACHES = new LRUCache({ max: 10000 });
 
 export async function evalSimpleLayer(
   layer: LayerSimple,
@@ -23,6 +27,11 @@ export async function evalSimpleLayer(
   const features = layer.data ? await ctx.getAllFeatures(layer.data) : undefined;
   const appearances: Partial<LayerAppearanceTypes> = pick(layer, appearanceKeys);
   const timeIntervals = evalTimeInterval(features, layer.data?.time);
+
+  if (!features) {
+    return undefined;
+  }
+
   return {
     layer: evalLayerAppearances(appearances, layer),
     features: features?.map((f, i) => evalSimpleLayerFeature(layer, f, timeIntervals?.[i])),
@@ -111,11 +120,41 @@ function evalExpression(
       if (typeof styleExpression === "undefined") {
         return undefined;
       } else if (typeof styleExpression === "object" && styleExpression.conditions) {
-        return new ConditionalExpression(styleExpression, feature, layer.defines).evaluate();
+        const cacheKey = JSON.stringify([
+          styleExpression,
+          getCacheableProperties(styleExpression, feature?.properties),
+          layer.defines,
+        ]);
+
+        if (EVAL_EXPRESSION_CACHES.has(cacheKey)) {
+          return EVAL_EXPRESSION_CACHES.get(cacheKey);
+        }
+
+        const result = new ConditionalExpression(
+          styleExpression,
+          feature,
+          layer.defines,
+        ).evaluate();
+        EVAL_EXPRESSION_CACHES.set(cacheKey, result);
+
+        return result;
       } else if (typeof styleExpression === "boolean" || typeof styleExpression === "number") {
-        return new Expression(String(styleExpression), feature, layer.defines).evaluate();
+        return styleExpression;
       } else if (typeof styleExpression === "string") {
-        return new Expression(styleExpression, feature, layer.defines).evaluate();
+        const cacheKey = JSON.stringify([
+          styleExpression,
+          getCacheableProperties(styleExpression, feature?.properties),
+          layer.defines,
+        ]);
+
+        if (EVAL_EXPRESSION_CACHES.has(cacheKey)) {
+          return EVAL_EXPRESSION_CACHES.get(cacheKey);
+        }
+
+        const result = new Expression(styleExpression, feature, layer.defines).evaluate();
+        EVAL_EXPRESSION_CACHES.set(cacheKey, result);
+
+        return result;
       }
       return styleExpression;
     }

src/core/mantle/evaluator/simple/utils.test.ts

@@ -0,0 +1,97 @@
+import { expect, test, describe } from "vitest";
+
+import { ConditionsExpression } from "../../types";
+
+import { getReferences, getCacheableProperties, getCombinedReferences } from "./utils";
+
+describe("getCacheableProperties", () => {
+  const feature = { foo: "bar", baz: "qux" };
+  const styleExpression: ConditionsExpression = {
+    conditions: [
+      ["${foo}", "${baz}"],
+      ["${qux}", "121"],
+    ],
+  };
+
+  test("should return properties that exist in feature and are referenced in styleExpression", () => {
+    const result = getCacheableProperties(styleExpression, feature);
+    expect(result).toEqual({ foo: "bar", baz: "qux" });
+  });
+
+  test("should return an empty object if no properties are referenced in styleExpression", () => {
+    const styleExpression = "some string";
+    const result = getCacheableProperties(styleExpression, feature);
+    expect(result).toEqual({});
+  });
+});
+
+describe("getCombinedReferences", () => {
+  const feature = { foo: "bar", baz: "qux" };
+
+  test("should return references in a single expression", () => {
+    const expression = "${foo}";
+    const result = getCombinedReferences(expression, feature);
+    expect(result).toEqual(["foo"]);
+  });
+
+  test("should return references in a style expression with multiple conditions", () => {
+    const expression: ConditionsExpression = {
+      conditions: [
+        ["${foo}", "${baz}"],
+        ["${qux}", "121"],
+      ],
+    };
+    const result = getCombinedReferences(expression, feature);
+    expect(result).toEqual(["foo", "baz", "qux"]);
+  });
+
+  test("should return an empty array if expression is a string with no references", () => {
+    const expression = "some string";
+    const result = getCombinedReferences(expression, feature);
+    expect(result).toEqual([]);
+  });
+});
+
+describe("getReferences", () => {
+  const feature = {
+    foo: "bar",
+    baz: "qux",
+    obj: {
+      arr: [1, 2, 3],
+      nestedObj: {
+        a: "A",
+        b: "B",
+      },
+    },
+  };
+
+  test("should return references in a single expression", () => {
+    const expression = "${foo}";
+    const result = getReferences(expression, feature);
+    expect(result).toEqual(["foo"]);
+  });
+
+  test("should return references in an expression with JSONPath expressions", () => {
+    const expression = "${$.baz}";
+    const result = getReferences(expression, feature);
+    expect(result).toEqual(['["baz"]']);
+  });
+
+  test("should return references for nested JSONPath expressions", () => {
+    const expression = "${$.obj.nestedObj.a}";
+    const result = getReferences(expression, feature);
+    expect(result).toEqual(['["obj"]["nestedObj"]["a"]']);
+  });
+
+  test("should handle JSONPath expressions that return arrays", () => {
+    const expression = "${$.obj.arr[1]}";
+    const result = getReferences(expression, feature);
+    expect(result).toEqual(['["obj"]["arr"]["1"]']);
+  });
+
+  test("should return an empty array if expression has no references", () => {
+    const expression = "some string";
+    const result = getReferences(expression, feature);
+    expect(result).toEqual([]);
+  });
+});

src/core/mantle/evaluator/simple/utils.ts

@@ -0,0 +1,92 @@
+import { JSONPath } from "jsonpath-plus";
+import { pick } from "lodash-es";
+
+import { StyleExpression } from "../../types";
+
+export function getCacheableProperties(styleExpression: StyleExpression, feature?: any) {
+  const properties = pick(feature, getCombinedReferences(styleExpression, feature));
+  return properties;
+}
+
+export function getCombinedReferences(expression: StyleExpression, feature?: any): string[] {
+  if (typeof expression === "string") {
+    return getReferences(expression, feature);
+  } else {
+    const references: string[] = [];
+    for (const [condition, value] of expression.conditions) {
+      references.push(...getReferences(condition, feature), ...getReferences(value, feature));
+    }
+    return references;
+  }
+}
+
+export function getReferences(expression: string, feature?: any): string[] {
+  const result: string[] = [];
+  let exp = expression;
+  let i = exp.indexOf("${");
+  const varExpRegex = /^\$./;
+  const jsonPathCache: Record<string, any[]> = {};
+
+  while (i >= 0) {
+    const openSingleQuote = exp.indexOf("'", i);
+    const openDoubleQuote = exp.indexOf('"', i);
+
+    if (openSingleQuote >= 0 && openSingleQuote < i) {
+      const closeQuote = exp.indexOf("'", openSingleQuote + 1);
+      result.push(exp.substring(0, closeQuote + 1));
+      exp = exp.substring(closeQuote + 1);
+    } else if (openDoubleQuote >= 0 && openDoubleQuote < i) {
+      const closeQuote = exp.indexOf('"', openDoubleQuote + 1);
+      result.push(exp.substring(0, closeQuote + 1));
+      exp = exp.substring(closeQuote + 1);
+    } else {
+      const j = exp.indexOf("}", i);
+
+      if (j < 0) {
+        console.log("Unmatched {.");
+      }
+      const varExp = exp.slice(i + 2, j);
+      if (varExpRegex.test(varExp)) {
+        let res = jsonPathCache[varExp];
+        if (!res) {
+          try {
+            res = JSONPath({ json: feature, path: varExp });
+            jsonPathCache[varExp] = res;
+          } catch (error) {
+            console.log("Invalid JSONPath");
+          }
+        }
+        if (res.length !== 0) {
+          console.log("JSONPathEval: ", res[0]);
+          const keyPath = getObjectPathByValue(feature, res[0]);
+          if (keyPath) result.push(keyPath);
+          else return Object.keys(feature);
+        }
+      } else {
+        result.push(exp.substring(i + 2, j));
+      }
+      exp = exp.substring(j + 1);
+    }
+
+    i = exp.indexOf("${");
+  }
+
+  return result;
+}
+
+function getObjectPathByValue(obj: any, value: any): string | undefined {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const prop = obj[key];
+      if (prop === value) {
+        return `[${JSON.stringify(key)}]`;
+      } else if (typeof prop === "object") {
+        const nestedKey = getObjectPathByValue(prop, value);
+        if (nestedKey !== undefined) {
+          return `[${JSON.stringify(key)}]${nestedKey}`;
+        }
+      }
+    }
+  }
+  return undefined;
+}

yarn.lock

@@ -12945,6 +12945,11 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
+lru-cache@^8.0.4:
+  version "8.0.4"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-8.0.4.tgz#49fbbc46c0b4cedc36258885247f93dba341e7ec"
+  integrity sha512-E9FF6+Oc/uFLqZCuZwRKUzgFt5Raih6LfxknOSAVTjNkrCZkBf7DQCwJxZQgd9l4eHjIJDGR+E+1QKD1RhThPw==
+
 lz-string@^1.4.4:
   version "1.4.4"
   resolved "https://registry.yarnpkg.com/lz-string/-/lz-string-1.4.4.tgz#c0d8eaf36059f705796e1e344811cf4c498d3a26"