@reearth/core 0.0.1

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

@@ -0,0 +1,178 @@
+import { cloneDeep, pick } from "lodash-es";
+
+import type { EvalContext, EvalResult } from "..";
+import {
+  appearanceKeys,
+  AppearanceTypes,
+  ComputedFeature,
+  Feature,
+  LayerAppearanceTypes,
+  LayerSimple,
+  ExpressionContainer,
+  TimeInterval,
+} from "../../types";
+
+import { ConditionalExpression } from "./conditionalExpression";
+import { clearExpressionCaches, Expression } from "./expression";
+import { evalTimeInterval } from "./interval";
+import { recursiveJSONParse } from "./utils";
+
+export async function evalSimpleLayer(
+  layer: LayerSimple,
+  ctx: EvalContext,
+): Promise<EvalResult | undefined> {
+  const features = layer.data ? await ctx.getAllFeatures(layer.data) : undefined;
+  const appearances: Partial<LayerAppearanceTypes> = pick(layer, appearanceKeys);
+  const timeIntervals = evalTimeInterval(features, layer.data?.time);
+  return {
+    layer: evalLayerAppearances(appearances, layer),
+    features: features?.map((f, i) => evalSimpleLayerFeature(layer, f, timeIntervals?.[i])),
+  };
+}
+
+export const evalSimpleLayerFeature = (
+  layer: LayerSimple,
+  feature: Feature,
+  interval?: TimeInterval,
+): ComputedFeature => {
+  const appearances: Partial<LayerAppearanceTypes> = pick(layer, appearanceKeys);
+  const nextFeature = evalJsonProperties(layer, feature);
+  return {
+    ...nextFeature,
+    ...evalLayerAppearances(appearances, layer, nextFeature),
+    type: "computedFeature",
+    interval,
+  };
+};
+
+export function evalLayerAppearances(
+  appearance: Partial<LayerAppearanceTypes>,
+  layer: LayerSimple,
+  feature?: Feature,
+): Partial<AppearanceTypes> {
+  if (!feature) {
+    if (!layer.id) {
+      throw new Error("layer id is required");
+    }
+    feature = {
+      type: "feature",
+      id: layer.id,
+      properties: layer.properties || {},
+    };
+  }
+
+  return Object.fromEntries(
+    Object.entries(appearance)
+      .map(([k, v]) => (v ? [k, recursiveValEval(v, layer, feature)] : undefined))
+      .filter((v): v is [keyof LayerAppearanceTypes, LayerAppearanceTypes] => !!v),
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function recursiveValEval(obj: any, layer: LayerSimple, feature?: Feature): any {
+  return Object.fromEntries(
+    Object.entries(obj).map(([k, v]) => {
+      // if v is an object itself and not a null, recurse deeper
+      if (hasNonExpressionObject(v)) {
+        return [k, recursiveValEval(v, layer, feature)];
+      }
+      // if v is not an object, apply the evalExpression function
+      return [k, evalExpression(v, layer, feature)];
+    }),
+  );
+}
+
+export function clearAllExpressionCaches(
+  layer: LayerSimple | undefined,
+  feature: Feature | undefined,
+) {
+  const appearances: Partial<LayerAppearanceTypes> = pick(layer, appearanceKeys);
+  Object.entries(appearances).forEach(([, v]) => {
+    recursiveClear(v, layer, feature);
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function recursiveClear(obj: any, layer: LayerSimple | undefined, feature: Feature | undefined) {
+  Object.entries(obj).forEach(([, v]) => {
+    // if v is an object itself and not a null, recurse deeper
+    if (hasNonExpressionObject(v)) {
+      recursiveClear(v, layer, feature);
+    } else if (hasExpression(v)) {
+      // if v is not an object, apply the clearExpressionCaches function
+      const styleExpression = v.expression;
+      if (typeof styleExpression === "object" && styleExpression.conditions) {
+        styleExpression.conditions.forEach(([expression1, expression2]) => {
+          clearExpressionCaches(expression1, feature, layer?.defines);
+          clearExpressionCaches(expression2, feature, layer?.defines);
+        });
+      } else if (typeof styleExpression === "boolean" || typeof styleExpression === "number") {
+        clearExpressionCaches(String(styleExpression), feature, layer?.defines);
+      } else if (typeof styleExpression === "string") {
+        clearExpressionCaches(styleExpression, feature, layer?.defines);
+      }
+    }
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasExpression(e: any): e is ExpressionContainer {
+  return typeof e === "object" && e && "expression" in e;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasNonExpressionObject(v: any): boolean {
+  return typeof v === "object" && v && !("expression" in v) && !Array.isArray(v);
+}
+
+export function evalExpression(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  expressionContainer: any,
+  layer?: LayerSimple,
+  feature?: Feature,
+): unknown | undefined {
+  try {
+    if (hasExpression(expressionContainer)) {
+      const styleExpression = expressionContainer.expression;
+      const parsedFeature = recursiveJSONParse(cloneDeep(feature));
+      if (typeof styleExpression === "undefined") {
+        return undefined;
+      } else if (typeof styleExpression === "object" && styleExpression.conditions) {
+        return new ConditionalExpression(styleExpression, parsedFeature, layer?.defines).evaluate();
+      } else if (typeof styleExpression === "boolean" || typeof styleExpression === "number") {
+        return new Expression(String(styleExpression), parsedFeature, layer?.defines).evaluate();
+      } else if (typeof styleExpression === "string") {
+        return new Expression(styleExpression, parsedFeature, layer?.defines).evaluate();
+      }
+      return styleExpression;
+    }
+    return expressionContainer;
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+}
+
+function evalJsonProperties(layer: LayerSimple, feature: Feature): Feature {
+  const keys = layer.data?.jsonProperties;
+  if (!feature.properties || !keys || !keys.length) {
+    return feature;
+  }
+
+  const next = {
+    ...feature,
+    ...(feature?.properties ? { properties: { ...feature.properties } } : {}),
+  };
+  keys.forEach(k => {
+    next.properties[k] = (() => {
+      const p = next.properties[k];
+      try {
+        return JSON.parse(p);
+      } catch {
+        return p;
+      }
+    })();
+  });
+
+  return next;
+}

package/src/mantle/evaluator/simple/interval.test.ts

@@ -0,0 +1,102 @@
+import { expect, test } from "vitest";
+
+import { evalTimeInterval } from "./interval";
+
+test("evalTimeInterval", () => {
+  expect(
+    evalTimeInterval(
+      [
+        {
+          type: "feature",
+          id: "a",
+          properties: {
+            time: "2023-02-03T00:00:00.000Z",
+          },
+        },
+      ],
+      { property: "time" },
+    ),
+  ).toEqual([[new Date("2023-02-03T00:00:00.000Z"), undefined]]);
+
+  expect(
+    evalTimeInterval(
+      [
+        {
+          type: "feature",
+          id: "d",
+          properties: {
+            time: "2024-02-03T00:00:00.000Z",
+          },
+        },
+        {
+          type: "feature",
+          id: "b",
+          properties: {
+            time: "2023-02-04T00:00:00.000Z",
+          },
+        },
+        {
+          type: "feature",
+          id: "a",
+          properties: {
+            time: "2023-02-03T00:00:00.000Z",
+          },
+        },
+        {
+          type: "feature",
+          id: "c",
+          properties: {
+            time: "2023-02-05T00:00:00.000Z",
+          },
+        },
+      ],
+      { property: "time" },
+    ),
+  ).toEqual([
+    [new Date("2023-02-03T00:00:00.000Z"), new Date("2023-02-04T00:00:00.000Z")],
+    [new Date("2023-02-04T00:00:00.000Z"), new Date("2023-02-05T00:00:00.000Z")],
+    [new Date("2023-02-05T00:00:00.000Z"), new Date("2024-02-03T00:00:00.000Z")],
+    [new Date("2024-02-03T00:00:00.000Z"), undefined],
+  ]);
+
+  expect(
+    evalTimeInterval(
+      [
+        {
+          type: "feature",
+          id: "d",
+          properties: {
+            time: "2024-02-03T00:00:00.000Z",
+          },
+        },
+        {
+          type: "feature",
+          id: "b",
+          properties: {
+            time: "2023-02-04T00:00:00.000Z",
+          },
+        },
+        {
+          type: "feature",
+          id: "a",
+          properties: {
+            time: "2023-02-03T00:00:00.000Z",
+          },
+        },
+        {
+          type: "feature",
+          id: "c",
+          properties: {
+            time: "2023-02-05T00:00:00.000Z",
+          },
+        },
+      ],
+      { property: "time", interval: 1000 },
+    ),
+  ).toEqual([
+    [new Date("2023-02-03T00:00:00.000Z"), new Date("2023-02-03T00:00:01.000Z")],
+    [new Date("2023-02-04T00:00:00.000Z"), new Date("2023-02-04T00:00:01.000Z")],
+    [new Date("2023-02-05T00:00:00.000Z"), new Date("2023-02-05T00:00:01.000Z")],
+    [new Date("2024-02-03T00:00:00.000Z"), new Date("2024-02-03T00:00:01.000Z")],
+  ]);
+});

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

@@ -0,0 +1,27 @@
+import { Data, Feature, TimeInterval } from "../../types";
+
+export function evalTimeInterval(
+  features: Feature[] | undefined,
+  time: Data["time"],
+): TimeInterval[] | void {
+  if (!features || !time?.property) {
+    return;
+  }
+  const startTimes: Date[] = [];
+  for (const feature of features) {
+    const property = feature.properties[time.property];
+    if (!property) {
+      continue;
+    }
+    try {
+      startTimes.push(new Date(property));
+    } catch {
+      // do nothing
+    }
+  }
+  startTimes.sort((a, b) => a.getTime() - b.getTime());
+  return startTimes.map((start, i) => [
+    start,
+    time.interval ? new Date(start.getTime() + time.interval) : startTimes[i + 1],
+  ]);
+}

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

@@ -0,0 +1,56 @@
+import { expect, test, describe } from "vitest";
+
+import { recursiveJSONParse } from "./utils"; // Import the function from your module/file
+
+describe("recursiveJSONParse", () => {
+  test("should parse nested JSON strings within an object", () => {
+    const obj = {
+      name: "John",
+      age: "25",
+      data: '{"city": "New York", "country": "USA"}',
+    };
+    const expected = {
+      name: "John",
+      age: "25",
+      data: {
+        city: "New York",
+        country: "USA",
+      },
+    };
+
+    const result = recursiveJSONParse(obj);
+    expect(result).toEqual(expected);
+  });
+
+  test("should handle non-object values and null", () => {
+    const str = "Test";
+    const num = 123;
+    const bool = true;
+    const arr = ["one", "two"];
+    const emptyObj = {};
+    const nullValue = null;
+
+    expect(recursiveJSONParse(str)).toBe(str);
+    expect(recursiveJSONParse(num)).toBe(num);
+    expect(recursiveJSONParse(bool)).toBe(bool);
+    expect(recursiveJSONParse(arr)).toEqual(arr);
+    expect(recursiveJSONParse(emptyObj)).toEqual(emptyObj);
+    expect(recursiveJSONParse(nullValue)).toBe(nullValue);
+  });
+
+  test("should handle invalid JSON strings", () => {
+    const obj = {
+      name: "John",
+      age: "25",
+      data: '{city: "New York", country: "USA"}', // Invalid JSON string
+    };
+    const expected = {
+      name: "John",
+      age: "25",
+      data: '{city: "New York", country: "USA"}', // Invalid JSON string remains unchanged
+    };
+
+    const result = recursiveJSONParse(obj);
+    expect(result).toEqual(expected);
+  });
+});

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

@@ -0,0 +1,31 @@
+const usableChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+export const generateRandomString = (len: number): string => {
+  return Array.from(window.crypto.getRandomValues(new Uint8Array(len)))
+    .map(n => usableChars[n % len])
+    .join("")
+    .toLowerCase();
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const recursiveJSONParse = (obj: any): any => {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+
+  for (const key in obj) {
+    if (typeof obj[key] === "string") {
+      try {
+        if (obj[key].startsWith("{") && obj[key].endsWith("}")) {
+          obj[key] = JSON.parse(obj[key]);
+        }
+      } catch (error) {
+        console.error("Invalid JSON:", obj[key]);
+      }
+    } else if (typeof obj[key] === "object") {
+      obj[key] = recursiveJSONParse(obj[key]);
+    }
+  }
+
+  return obj;
+};

package/src/mantle/index.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./compat";
+export { evalFeature, clearAllExpressionCaches, evalExpression } from "./evaluator";
+export { computeAtom } from "./atoms";
+export type { Atom } from "./atoms";
+export { guessType } from "./data";