@reearth/core 0.0.7-alpha.8 → 0.0.7-alpha.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reearth/core",
-  "version": "0.0.7-alpha.8",
+  "version": "0.0.7-alpha.9",
   "author": "Re:Earth contributors <community@reearth.io>",
   "license": "Apache-2.0",
   "description": "A library that abstracts a map engine as one common API.",

package/src/Map/Sketch/hooks.ts

@@ -202,7 +202,10 @@ export default function useHooks({
 
   const handleFeatureCreate = useCallback(
     (feature: SketchFeature) => {
-      updateType(undefined);
+      if (sketchOptions.autoResetInteractionMode) {
+        updateType(undefined);
+      }
+
       if (from === "editor") {
         onSketchFeatureCreate?.(feature);
         return;
@@ -245,6 +248,7 @@ export default function useHooks({
       layersRef,
       from,
       sketchOptions.dataOnly,
+      sketchOptions.autoResetInteractionMode,
       pluginSketchLayerCreate,
       pluginSketchLayerFeatureAdd,
       onSketchFeatureCreate,
@@ -566,21 +570,17 @@ export default function useHooks({
     }
   }, [type, send, updateGeometryOptions]);
 
-  useEffect(() => {
-    if (type) {
-      overrideInteractionMode?.("sketch");
-    } else if (sketchOptions.autoResetInteractionMode) {
-      overrideInteractionMode?.("default");
-    }
+  const fromRef = useRef(from);
+  fromRef.current = from;
+  const overrideInteractionModeRef = useRef(overrideInteractionMode);
+  overrideInteractionModeRef.current = overrideInteractionMode;
+  const onSketchTypeChangeRef = useRef(onSketchTypeChange);
+  onSketchTypeChangeRef.current = onSketchTypeChange;
 
-    onSketchTypeChange?.(type, from);
-  }, [
-    type,
-    from,
-    sketchOptions.autoResetInteractionMode,
-    overrideInteractionMode,
-    onSketchTypeChange,
-  ]);
+  useEffect(() => {
+    overrideInteractionModeRef.current?.(type ? "sketch" : "default");
+    onSketchTypeChangeRef.current?.(type, fromRef.current);
+  }, [type]);
 
   // API
   const getType = useGet(type);

package/src/Visualizer/hooks.ts

@@ -82,12 +82,24 @@ export default function useHooks(
       reason: LayerSelectionReason | undefined,
       info: SelectedFeatureInfo | undefined,
     ) => {
-      if (selectedLayer.layerId === layerId && selectedLayer.featureId === featureId) return;
+      const isSketchLayer =
+        selectedLayer.layer?.layer.type === "simple" &&
+        selectedLayer.layer?.layer?.data?.isSketchLayer;
+      // Sketch layer feature has a fixed featureId, we need to exclude it from the skip condition
+      if (
+        selectedLayer.layerId === layerId &&
+        selectedLayer.featureId === featureId &&
+        !isSketchLayer
+      )
+        return;
 
       const computedLayer = await layer?.();
       const computedFeature =
         layerId && featureId
-          ? mapRef.current?.engine.findComputedFeatureById?.(layerId, featureId) ?? info?.feature
+          ? (isSketchLayer
+              ? computedLayer?.features?.find(f => f.id === featureId)
+              : mapRef.current?.engine.findComputedFeatureById?.(layerId, featureId)) ??
+            info?.feature
           : undefined;
 
       selectFeature(

package/src/mantle/atoms/compute.ts

@@ -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];

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