@reearth/core 0.0.7-alpha.7 → 0.0.7-alpha.70

package/src/mantle/atoms/compute.test.ts

@@ -1,6 +1,6 @@
-import { renderHook, act, waitFor } from "@testing-library/react";
+import { renderHook, waitFor } from "@testing-library/react";
 import { useAtom } from "jotai";
-import { useMemo } from "react";
+import { act, useMemo } from "react";
 import { test, expect, vi, beforeEach } from "vitest";
 
 import * as DataCache from "../data";
@@ -79,7 +79,7 @@ test("computeAtom", async () => {
     result.current.set({ type: "setLayer", layer });
   });
 
-  expect(result.current.result).toEqual({
+  (expect(result.current.result).toEqual({
     id: "xxx",
     layer,
     status: "ready",
@@ -94,7 +94,7 @@ test("computeAtom", async () => {
         features: [],
         originalFeatures: [],
       }),
-    );
+    ));
 
   // delete delegatedDataTypes
   act(() => {

package/src/mantle/atoms/compute.ts

@@ -43,7 +43,7 @@ export function computeAtom(cache?: typeof globalDataFeaturesCache) {
   });
 
   const layer = atom<Layer | undefined>(undefined);
-  const overrides = atom<Record<string, any> | undefined, Record<string, any> | undefined>(
+  const overrides = atom<Record<string, any> | undefined, [Record<string, any> | undefined], void>(
     undefined,
     (_, set, value) => {
       set(overrides, pick(value, appearanceKeys));
@@ -68,7 +68,7 @@ export function computeAtom(cache?: typeof globalDataFeaturesCache) {
       features: get(finalFeatures) ?? [],
       originalFeatures:
         currentLayer.type === "simple" && currentLayer.data
-          ? get(dataAtoms.getAll)(currentLayer.id, currentLayer.data)?.flat() ?? []
+          ? (get(dataAtoms.getAll)(currentLayer.id, currentLayer.data)?.flat() ?? [])
           : [],
       properties: currentLayer.type === "simple" ? currentLayer.properties : undefined,
       ...get(computedResult)?.layer,
@@ -109,7 +109,11 @@ export function computeAtom(cache?: typeof globalDataFeaturesCache) {
         return true;
       }
 
-      const curFeatures = processGeoJSON(currentLayer.data.value);
+      const curFeatures = processGeoJSON(
+        currentLayer.data.value,
+        undefined,
+        currentLayer.data.idProperty,
+      );
       if (curFeatures.length === prevFeatures?.length) {
         return !curFeatures.every((cur, i) => {
           const prev = prevFeatures[i];
@@ -304,7 +308,7 @@ export function computeAtom(cache?: typeof globalDataFeaturesCache) {
     await set(compute, { forceUpdateData: true });
   });
 
-  return atom<ComputedLayer | undefined, Command>(
+  return atom<ComputedLayer | undefined, [Command], void>(
     g => g(get),
     async (_, s, value) => {
       switch (value.type) {

package/src/mantle/compat/forward.ts

@@ -9,7 +9,7 @@ import { LegacyCluster } from "./types";
 import type { LegacyLayer } from ".";
 
 export function convertLegacyLayer(l: LegacyLayer | undefined): Layer | undefined {
-  return l ? convertLegacyLayerGroup(l) ?? convertLegacyLayerItem(l) : undefined;
+  return l ? (convertLegacyLayerGroup(l) ?? convertLegacyLayerItem(l)) : undefined;
 }
 
 function convertLegacyLayerCommon(l: LegacyLayer): any {

package/src/mantle/data/geojson.ts

@@ -10,62 +10,85 @@ export async function fetchGeoJSON(
   options?: FetchOptions,
 ): Promise<Feature[] | void> {
   const d = data.url ? await (await f(data.url, options)).json() : data.value;
-  return processGeoJSON(d, range);
+  return processGeoJSON(d, range, data.idProperty);
 }
 
-export function processGeoJSON(geojson: GeoJSON, range?: DataRange): Feature[] {
+export function processGeoJSON(
+  geojson: GeoJSON,
+  range?: DataRange,
+  idProperty?: string,
+): Feature[] {
   if (geojson.type === "FeatureCollection") {
-    return geojson.features.flatMap(f => processGeoJSON(f, range));
+    return geojson.features.flatMap(f => processGeoJSON(f, range, idProperty));
   }
 
   if (geojson.type === "Feature") {
     const geo = geojson.geometry;
     if (geo.type === "GeometryCollection") {
       return geo.geometries.flatMap(geometry => {
-        return processGeoJSON({
-          ...geojson,
-          geometry,
-        });
+        return processGeoJSON(
+          {
+            ...geojson,
+            geometry,
+          },
+          undefined,
+          idProperty,
+        );
       });
     }
     if (geo.type === "MultiPoint") {
       return geo.coordinates.flatMap(coord => {
-        return processGeoJSON({
-          ...geojson,
-          geometry: {
-            type: "Point",
-            coordinates: coord,
+        return processGeoJSON(
+          {
+            ...geojson,
+            geometry: {
+              type: "Point",
+              coordinates: coord,
+            },
           },
-        });
+          undefined,
+          idProperty,
+        );
       });
     }
     if (geo.type === "MultiLineString") {
       return geo.coordinates.flatMap(coord => {
-        return processGeoJSON({
-          ...geojson,
-          geometry: {
-            type: "LineString",
-            coordinates: coord,
+        return processGeoJSON(
+          {
+            ...geojson,
+            geometry: {
+              type: "LineString",
+              coordinates: coord,
+            },
           },
-        });
+          undefined,
+          idProperty,
+        );
       });
     }
     if (geo.type === "MultiPolygon") {
       return geo.coordinates.flatMap(coord => {
-        return processGeoJSON({
-          ...geojson,
-          geometry: {
-            type: "Polygon",
-            coordinates: coord,
+        return processGeoJSON(
+          {
+            ...geojson,
+            geometry: {
+              type: "Polygon",
+              coordinates: coord,
+            },
           },
-        });
+          undefined,
+          idProperty,
+        );
       });
     }
 
     return [
       {
         type: "feature",
-        id: generateRandomString(12),
+        id:
+          idProperty && geojson.properties && geojson.properties[idProperty]
+            ? geojson.properties[idProperty]
+            : generateRandomString(12),
         geometry:
           geo.type === "Point" || geo.type === "LineString" || geo.type === "Polygon"
             ? geo

package/src/mantle/data/georss.ts

@@ -1,4 +1,4 @@
-import { XMLParser, X2jOptionsOptional } from "fast-xml-parser";
+import { XMLParser, type X2jOptions } from "fast-xml-parser";
 
 import type { Data, DataRange, Feature, Geometry } from "../types";
 
@@ -28,7 +28,7 @@ function handler(xmlDataStr: string) {
 }
 
 function parseBuffer(xmlDataStr: string) {
-  const options: X2jOptionsOptional = {
+  const options: X2jOptions = {
     ignoreAttributes: false,
     attributeNamePrefix: "",
   };

package/src/mantle/data/gml.ts

@@ -1,4 +1,4 @@
-import { XMLParser, X2jOptionsOptional } from "fast-xml-parser";
+import { XMLParser, X2jOptions } from "fast-xml-parser";
 
 import type { Data, DataRange, Feature, Geometry } from "../types";
 
@@ -21,7 +21,7 @@ function handler(xmlDataStr: string) {
 }
 
 function parseBuffer(xmlDataStr: string) {
-  const options: X2jOptionsOptional = {
+  const options: X2jOptions = {
     ignoreAttributes: false,
     attributeNamePrefix: "",
   };

package/src/mantle/data/gpx.ts

@@ -243,7 +243,7 @@ const parseGPXWithCustomParser = (
           extensions[name] = parseFloat(
             (extension as Element).innerHTML != undefined
               ? (extension as Element).innerHTML
-              : (extension as Element).childNodes[0].textContent ?? "",
+              : ((extension as Element).childNodes[0].textContent ?? ""),
           );
         }
 
@@ -325,7 +325,7 @@ const getElementValue = (parent: Element, tag: string): string => {
   if (element !== null) {
     return element.innerHTML != undefined
       ? element.innerHTML
-      : element.childNodes[0].textContent ?? "";
+      : (element.childNodes[0].textContent ?? "");
   } else return "";
 };
 

package/src/mantle/data/shapefile/parseZip.ts

@@ -3,6 +3,7 @@ import proj4 from "proj4";
 
 import { parseDbf } from "./parseDbf";
 import { parseShp } from "./parseShp";
+
 import { combine } from ".";
 
 export async function parseZip(buffer: ArrayBuffer): Promise<GeoJSON.GeoJSON | GeoJSON.GeoJSON[]> {

package/src/mantle/evaluator/simple/expression/README.md

@@ -0,0 +1,392 @@
+# Expression Evaluator
+
+A powerful expression evaluator for evaluating dynamic expressions with feature properties, supporting various operators, functions, and property access methods.
+
+## Table of Contents
+
+- [Basic Usage](#basic-usage)
+- [Property Access](#property-access)
+- [Operators](#operators)
+- [Functions](#functions)
+- [Data Types](#data-types)
+- [Advanced Features](#advanced-features)
+
+## Basic Usage
+
+```typescript
+import { Expression } from "./expression";
+
+const feature = {
+  properties: {
+    height: 100,
+    name: "Building A",
+  },
+};
+
+const expr = new Expression("${height} > 50", feature);
+const result = expr.evaluate(); // true
+```
+
+## Property Access
+
+### 1. Standard Property Names (No Spaces)
+
+For properties without spaces or special characters, use the simple syntax:
+
+```typescript
+${propertyName}
+${height}
+${temperature}
+```
+
+**Example:**
+```typescript
+const feature = {
+  properties: {
+    height: 100,
+    width: 50,
+  },
+};
+
+const expr = new Expression("${height} * ${width}", feature);
+expr.evaluate(); // 5000
+```
+
+### 2. Quoted Property Names (With Spaces)
+
+**✨ NEW:** For properties with spaces or special characters, wrap the property name in quotes:
+
+```typescript
+${"property name"}      // Double quotes (recommended)
+${'property name'}      // Single quotes
+```
+
+**Example:**
+```typescript
+const feature = {
+  properties: {
+    "user name": "Alice",
+    "user score": 95,
+    "email@address": "alice@example.com",
+    "user-info:age": 25,
+  },
+};
+
+// Access properties with spaces
+const expr1 = new Expression('${"user name"}', feature);
+expr1.evaluate(); // "Alice"
+
+// Use in conditionals
+const expr2 = new Expression('${"user score"} > 90 ? "Excellent" : "Good"', feature);
+expr2.evaluate(); // "Excellent"
+
+// Arithmetic operations
+const expr3 = new Expression('${"user-info:age"} + 5', feature);
+expr3.evaluate(); // 30
+
+// Properties with special characters
+const expr4 = new Expression('${"email@address"} !== ""', feature);
+expr4.evaluate(); // true
+```
+
+**Supported Characters in Quoted Names:**
+- Spaces: `${"user name"}`
+- Hyphens: `${"user-info"}`
+- Colons: `${"category:name"}`
+- At signs: `${"email@domain"}`
+- Any other special characters
+
+### 3. Special Variables
+
+```typescript
+${id}              // Access feature.id
+${rootProperties}  // Access entire feature.properties object
+```
+
+**Example:**
+```typescript
+const feature = {
+  id: "feature-123",
+  properties: {
+    height: 100,
+  },
+};
+
+const expr = new Expression('${id}', feature);
+expr.evaluate(); // "feature-123"
+```
+
+## Operators
+
+### Comparison Operators
+
+```typescript
+${height} > 50          // Greater than
+${height} >= 50         // Greater than or equal
+${height} < 100         // Less than
+${height} <= 100        // Less than or equal
+${height} === 50        // Strict equality
+${height} !== 50        // Strict inequality
+${height} == 50         // Loose equality (with type coercion)
+${height} != 50         // Loose inequality
+```
+
+### Arithmetic Operators
+
+```typescript
+${a} + ${b}            // Addition
+${a} - ${b}            // Subtraction
+${a} * ${b}            // Multiplication
+${a} / ${b}            // Division
+${a} % ${b}            // Modulo
+```
+
+### Logical Operators
+
+```typescript
+${a} && ${b}           // Logical AND
+${a} || ${b}           // Logical OR
+!${a}                  // Logical NOT
+```
+
+### Conditional (Ternary) Operator
+
+```typescript
+${condition} ? ${trueValue} : ${falseValue}
+```
+
+**Example:**
+```typescript
+const expr = new Expression('${height} > 100 ? "Tall" : "Short"', feature);
+```
+
+## Functions
+
+### Type Conversion Functions
+
+```typescript
+Boolean(${value})      // Convert to boolean
+Number(${value})       // Convert to number
+String(${value})       // Convert to string
+```
+
+### Math Functions
+
+```typescript
+abs(${value})          // Absolute value
+sqrt(${value})         // Square root
+ceil(${value})         // Round up
+floor(${value})        // Round down
+round(${value})        // Round to nearest integer
+sin(${value})          // Sine
+cos(${value})          // Cosine
+tan(${value})          // Tangent
+```
+
+### Utility Functions
+
+```typescript
+isNaN(${value})        // Check if Not a Number
+isFinite(${value})     // Check if finite number
+```
+
+### Color Functions
+
+```typescript
+color("red")                           // Named color
+color("#ff0000")                       // Hex color
+color("#ff0000", 0.5)                  // Hex color with alpha
+rgb(255, 0, 0)                         // RGB color
+rgba(255, 0, 0, 0.5)                   // RGBA color
+hsl(0, 100, 50)                        // HSL color
+hsla(0, 100, 50, 0.5)                  // HSLA color
+```
+
+**Example:**
+```typescript
+const expr = new Expression('${height} > 100 ? color("red") : color("blue")', feature);
+```
+
+## Data Types
+
+### Supported Types
+
+- **Numbers**: `42`, `3.14`, `Infinity`, `NaN`
+- **Strings**: `"hello"`, `'world'`
+- **Booleans**: `true`, `false`
+- **Null**: `null`
+- **Undefined**: `undefined`
+- **Arrays**: `[1, 2, 3]`
+- **Colors**: Result of color functions
+
+### Constants
+
+```typescript
+Math.PI                // 3.141592653589793
+Math.E                 // 2.718281828459045
+Number.POSITIVE_INFINITY
+NaN
+Infinity
+undefined
+```
+
+## Advanced Features
+
+### String Interpolation
+
+Within string literals, you can interpolate property values:
+
+```typescript
+"Hello, ${name}!"
+"Height: ${height}m"
+```
+
+**Note:** String interpolation only supports simple property names (without spaces). For properties with spaces or special characters, use concatenation instead (see below).
+
+**Example:**
+```typescript
+const feature = {
+  properties: {
+    name: "Building A",
+    height: 100,
+  },
+};
+
+const expr = new Expression('"Building: ${name}, Height: ${height}m"', feature);
+expr.evaluate(); // "Building: Building A, Height: 100m"
+```
+
+**For properties with spaces, use concatenation:**
+```typescript
+const feature = {
+  properties: {
+    "building name": "Tower A",
+    floors: 30,
+  },
+};
+
+// Use concatenation with + operator
+const expr = new Expression('${"building name"} + " has " + ${floors} + " floors"', feature);
+expr.evaluate(); // "Tower A has 30 floors"
+```
+
+### Array Comparisons
+
+The equality operators support checking if a value is in an array:
+
+```typescript
+${value} == [1, 2, 3]      // Check if value is in array
+${value} != [1, 2, 3]      // Check if value is not in array
+```
+
+**Example:**
+```typescript
+const feature = {
+  properties: {
+    status: "active",
+  },
+};
+
+const expr = new Expression('${status} == ["active", "pending"]', feature);
+expr.evaluate(); // true
+```
+
+### Defines (Variable Substitution)
+
+You can define placeholder values that get substituted before evaluation:
+
+```typescript
+const defines = {
+  MAX_HEIGHT: "100",
+  MIN_HEIGHT: "10",
+};
+
+const expr = new Expression("${height} > ${MAX_HEIGHT}", feature, defines);
+// Becomes: "${height} > 100"
+```
+
+### Expression Caching
+
+Expressions are cached automatically for better performance. To clear caches:
+
+```typescript
+import { clearExpressionCaches } from "./expression";
+
+clearExpressionCaches(expressionString, feature, defines);
+```
+
+## Property Name Comparison
+
+| Syntax | Use Case | Example |
+|--------|----------|---------|
+| `${name}` | Simple properties (no spaces) | `${height}`, `${temperature}` |
+| `${"property name"}` | Properties with spaces/special chars | `${"user name"}`, `${"email@domain"}` |
+| `${rootProperties}` | Access entire properties object | `${rootProperties["dynamic-key"]}` |
+
+## Complete Example
+
+```typescript
+import { Expression } from "./expression";
+
+const feature = {
+  id: "building-001",
+  properties: {
+    "building name": "Tower A",
+    "building height": 150,
+    "building color": "blue",
+    floors: 30,
+    status: "active",
+    "contact info": {
+      "email address": "info@tower-a.com",
+    },
+  },
+};
+
+// Simple comparison
+const expr1 = new Expression('${"building height"} > 100', feature);
+console.log(expr1.evaluate()); // true
+
+// Conditional with color
+const expr2 = new Expression(
+  '${"building height"} > 100 ? color("red") : color("green")',
+  feature
+);
+console.log(expr2.evaluate()); // #ff0000 (red)
+
+// String concatenation (for properties with spaces)
+const expr3 = new Expression(
+  '${"building name"} + " has " + ${floors} + " floors"',
+  feature
+);
+console.log(expr3.evaluate()); // "Tower A has 30 floors"
+
+// Array membership check
+const expr4 = new Expression(
+  '${status} == ["active", "pending"]',
+  feature
+);
+console.log(expr4.evaluate()); // true
+```
+
+## Migration Guide
+
+### From Standard Syntax to Quoted Syntax
+
+If you have properties with spaces, you need to update your expressions:
+
+**Before (doesn't work):**
+```typescript
+${user name}           // ❌ Fails: interpreted as two separate identifiers
+```
+
+**After (works):**
+```typescript
+${"user name"}         // ✅ Works: quoted property name
+```
+
+### Best Practices
+
+1. **Use simple syntax** for properties without spaces: `${height}`
+2. **Use quoted syntax** for properties with spaces: `${"user name"}`
+3. **Prefer double quotes** for consistency: `${"property"}` instead of `${'property'}`
+4. **Avoid special characters in property names** when possible to keep expressions simple