@reearth/core 0.0.7-alpha.1 → 0.0.7-alpha.3

package/src/engines/Cesium/Feature/Tileset/useClippingBox.ts

@@ -411,7 +411,16 @@ export const useClippingBox = ({
     eventHandler.setInputAction(handleMouseUp, ScreenSpaceEventType.LEFT_UP);
   }, [eventHandler, handleMouseDown, handleRawMouseMove, handleMouseUp]);
 
-  useEffect(() => () => eventHandler.destroy(), [eventHandler]);
+  useEffect(
+    () => () => {
+      requestAnimationFrame(() => {
+        if (!eventHandler.isDestroyed()) {
+          eventHandler.destroy();
+        }
+      });
+    },
+    [eventHandler],
+  );
 
   const boxProperty = useMemo(
     () => ({ ...boxState, ...dimensions, allowEnterGround }),

package/src/engines/Cesium/core/Globe.tsx

@@ -30,9 +30,9 @@ export default function Globe({ property, cesiumIonAccessToken }: Props): JSX.El
       terrain: terrainProperty?.enabled,
       terrainType: terrainProperty?.type,
       normal: terrainProperty?.normal,
-      ionAccessToken: property?.assets?.cesium?.terrian?.ionAccessToken || cesiumIonAccessToken,
-      ionAsset: property?.assets?.cesium?.terrian?.ionAsset,
-      ionUrl: property?.assets?.cesium?.terrian?.ionUrl,
+      ionAccessToken: property?.assets?.cesium?.terrain?.ionAccessToken || cesiumIonAccessToken,
+      ionAsset: property?.assets?.cesium?.terrain?.ionAsset,
+      ionUrl: property?.assets?.cesium?.terrain?.ionUrl,
     };
     const provider = opts.terrain ? terrainProviders[opts.terrainType || "cesium"] : undefined;
     return (typeof provider === "function" ? provider(opts) : provider) ?? defaultTerrainProvider;
@@ -40,9 +40,9 @@ export default function Globe({ property, cesiumIonAccessToken }: Props): JSX.El
     terrainProperty?.enabled,
     terrainProperty?.type,
     terrainProperty?.normal,
-    property?.assets?.cesium?.terrian?.ionAccessToken,
-    property?.assets?.cesium?.terrian?.ionAsset,
-    property?.assets?.cesium?.terrian?.ionUrl,
+    property?.assets?.cesium?.terrain?.ionAccessToken,
+    property?.assets?.cesium?.terrain?.ionAsset,
+    property?.assets?.cesium?.terrain?.ionUrl,
     cesiumIonAccessToken,
   ]);
 
@@ -72,7 +72,7 @@ const terrainProviders: {
   [k in NonNullable<TerrainProperty["type"]>]:
     | TerrainProvider
     | ((
-        opts: Pick<TerrainProperty, "normal"> & AssetsCesiumProperty["terrian"],
+        opts: Pick<TerrainProperty, "normal"> & AssetsCesiumProperty["terrain"],
       ) => Promise<TerrainProvider> | TerrainProvider | null);
 } = {
   cesium: ({ ionAccessToken, normal }) =>

package/src/engines/Cesium/hooks/useCamera.ts

@@ -84,21 +84,12 @@ export default ({
       initialCameraFlight.current = true;
       if (property?.camera?.limiter?.enabled && property?.camera?.limiter?.targetArea) {
         engineAPI.flyTo(property?.camera?.limiter?.targetArea, { duration: 0 });
-      } else if (property?.camera?.camera) {
-        const camera = property?.camera?.camera;
-        engineAPI.flyTo(camera as Camera, { duration: 0 });
-      }
-      const camera = getCamera(cesium?.current?.cesiumElement);
-      if (camera) {
-        onCameraChange?.(camera);
+      } else if (camera) {
+        engineAPI.flyTo(camera, { duration: 0 });
       }
     },
-    [engineAPI, property?.camera?.camera, property?.camera?.limiter?.enabled, onCameraChange],
-    (prevDeps, nextDeps) =>
-      prevDeps[0] === nextDeps[0] &&
-      isEqual(prevDeps[1], nextDeps[1]) &&
-      prevDeps[2] === nextDeps[2] &&
-      prevDeps[3] === nextDeps[3],
+    [engineAPI, property?.camera?.limiter?.enabled],
+    (prevDeps, nextDeps) => prevDeps[0] === nextDeps[0] && prevDeps[1] === nextDeps[1],
   );
 
   const unmountCamera = useCallback(() => {

package/src/engines/Cesium/hooks/useEngineRef.test.tsx

@@ -57,86 +57,86 @@ test("bind mouse events", () => {
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onDoubleClick(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.doubleclick[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.doubleClick[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.doubleclick[0]?.(props);
+  result.current.current?.mouseEventCallbacks.doubleClick[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(2);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseDown(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mousedown[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseDown[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mousedown[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseDown[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(3);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseUp(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseup[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseUp[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseup[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseUp[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(4);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onRightClick(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.rightclick[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.rightClick[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.rightclick[0]?.(props);
+  result.current.current?.mouseEventCallbacks.rightClick[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(5);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onRightDown(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.rightdown[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.rightDown[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.rightdown[0]?.(props);
+  result.current.current?.mouseEventCallbacks.rightDown[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(6);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onRightUp(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.rightup[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.rightUp[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.rightup[0]?.(props);
+  result.current.current?.mouseEventCallbacks.rightUp[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(7);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMiddleClick(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.middleclick[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.middleClick[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.middleclick[0]?.(props);
+  result.current.current?.mouseEventCallbacks.middleClick[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(8);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMiddleDown(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.middledown[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.middleDown[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.middledown[0]?.(props);
+  result.current.current?.mouseEventCallbacks.middleDown[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(9);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMiddleUp(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.middleup[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.middleUp[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.middleup[0]?.(props);
+  result.current.current?.mouseEventCallbacks.middleUp[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(10);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseMove(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mousemove[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseMove[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mousemove[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseMove[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(11);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseEnter(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseenter[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseEnter[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseenter[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseEnter[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(12);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseLeave(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseleave[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseLeave[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseleave[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseLeave[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(13);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 

package/src/engines/Cesium/hooks/useEngineRef.ts

@@ -53,18 +53,18 @@ export default function useEngineRef(
   const cancelCameraFlight = useRef<() => void>();
   const mouseEventCallbacks = useRef<MouseEventCallbacks>({
     click: [],
-    doubleclick: [],
-    mousedown: [],
-    mouseup: [],
-    rightclick: [],
-    rightdown: [],
-    rightup: [],
-    middleclick: [],
-    middledown: [],
-    middleup: [],
-    mousemove: [],
-    mouseenter: [],
-    mouseleave: [],
+    doubleClick: [],
+    mouseDown: [],
+    mouseUp: [],
+    rightClick: [],
+    rightDown: [],
+    rightUp: [],
+    middleClick: [],
+    middleDown: [],
+    middleUp: [],
+    mouseMove: [],
+    mouseEnter: [],
+    mouseLeave: [],
     wheel: [],
   });
   const tickEventCallback = useRef<TickEventCallback[]>([]);
@@ -237,6 +237,8 @@ export default function useEngineRef(
       setView: camera => {
         const viewer = cesium.current?.cesiumElement;
         if (!viewer || viewer.isDestroyed()) return false;
+        if (camera.lat === undefined || camera.lng === undefined || camera.height === undefined)
+          return false;
         const scene = viewer.scene;
         if (camera.lng || camera.lat || camera.height) {
           const xyz = Cesium.Cartesian3.fromDegrees(camera.lng, camera.lat, camera.height);
@@ -675,40 +677,40 @@ export default function useEngineRef(
         mouseEventCallbacks.current.click.push(cb);
       },
       onDoubleClick: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.doubleclick.push(cb);
+        mouseEventCallbacks.current.doubleClick.push(cb);
       },
       onMouseDown: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mousedown.push(cb);
+        mouseEventCallbacks.current.mouseDown.push(cb);
       },
       onMouseUp: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseup.push(cb);
+        mouseEventCallbacks.current.mouseUp.push(cb);
       },
       onRightClick: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.rightclick.push(cb);
+        mouseEventCallbacks.current.rightClick.push(cb);
       },
       onRightDown: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.rightdown.push(cb);
+        mouseEventCallbacks.current.rightDown.push(cb);
       },
       onRightUp: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.rightup.push(cb);
+        mouseEventCallbacks.current.rightUp.push(cb);
       },
       onMiddleClick: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.middleclick.push(cb);
+        mouseEventCallbacks.current.middleClick.push(cb);
       },
       onMiddleDown: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.middledown.push(cb);
+        mouseEventCallbacks.current.middleDown.push(cb);
       },
       onMiddleUp: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.middleup.push(cb);
+        mouseEventCallbacks.current.middleUp.push(cb);
       },
       onMouseMove: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mousemove.push(cb);
+        mouseEventCallbacks.current.mouseMove.push(cb);
       },
       onMouseEnter: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseenter.push(cb);
+        mouseEventCallbacks.current.mouseEnter.push(cb);
       },
       onMouseLeave: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseleave.push(cb);
+        mouseEventCallbacks.current.mouseLeave.push(cb);
       },
       onWheel: (cb: (props: MouseEventProps) => void) => {
         mouseEventCallbacks.current.wheel.push(cb);

package/src/engines/Cesium/hooks/useOverrideGlobeShader/useOverrideGlobeShader.ts

@@ -133,7 +133,7 @@ const useTerrainHeatmap = ({
     minHeight: heatmapMinHeight,
     logarithmic: heatmapLogarithmic,
     colorLUT: heatmapColorLUT,
-  } = terrain?.heightMap ?? {};
+  } = terrain?.elevationHeatMap ?? {};
 
   const isCustomHeatmapEnabled = useMemo(() => heatmapType === "custom", [heatmapType]);
 

package/src/engines/Cesium/hooks.ts

@@ -412,18 +412,18 @@ export default ({
       wheel: CesiumMouseWheelEvent | undefined;
     } = {
       click: undefined,
-      doubleclick: undefined,
-      mousedown: undefined,
-      mouseup: undefined,
-      rightclick: undefined,
-      rightdown: undefined,
-      rightup: undefined,
-      middleclick: undefined,
-      middledown: undefined,
-      middleup: undefined,
-      mousemove: undefined,
-      mouseenter: undefined,
-      mouseleave: undefined,
+      doubleClick: undefined,
+      mouseDown: undefined,
+      mouseUp: undefined,
+      rightClick: undefined,
+      rightDown: undefined,
+      rightUp: undefined,
+      middleClick: undefined,
+      middleDown: undefined,
+      middleUp: undefined,
+      mouseMove: undefined,
+      mouseEnter: undefined,
+      mouseLeave: undefined,
       wheel: (delta: number) => {
         handleMouseWheel(delta);
       },
@@ -666,16 +666,15 @@ export default ({
     [selectionReason, engineAPI, onLayerEdit, onLayerVisibility, onLayerLoad, timelineManagerRef],
   );
 
-  const globe = cesium.current?.cesiumElement?.scene.globe;
-
   useEffect(() => {
+    const globe = cesium.current?.cesiumElement?.scene.globe;
     if (globe) {
       const surface = (globe as any)._surface as CustomGlobeSurface;
       if (surface) {
         surface.tileProvider._debug.wireframe = property?.debug?.showGlobeWireframe ?? false;
       }
     }
-  }, [globe, property?.debug?.showGlobeWireframe]);
+  }, [property?.debug?.showGlobeWireframe]);
 
   useEffect(() => {
     if (!time) return;

package/src/engines/Cesium/index.tsx

@@ -143,18 +143,18 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
       }}
       shadows={!!property?.scene?.shadow?.enabled}
       onClick={handleClick}
-      onDoubleClick={mouseEventHandles.doubleclick}
-      onMouseDown={mouseEventHandles.mousedown}
-      onMouseUp={mouseEventHandles.mouseup}
-      onRightClick={mouseEventHandles.rightclick}
-      onRightDown={mouseEventHandles.rightdown}
-      onRightUp={mouseEventHandles.rightup}
-      onMiddleClick={mouseEventHandles.middleclick}
-      onMiddleDown={mouseEventHandles.middledown}
-      onMiddleUp={mouseEventHandles.middleup}
-      onMouseMove={mouseEventHandles.mousemove}
-      onMouseEnter={mouseEventHandles.mouseenter}
-      onMouseLeave={mouseEventHandles.mouseleave}
+      onDoubleClick={mouseEventHandles.doubleClick}
+      onMouseDown={mouseEventHandles.mouseDown}
+      onMouseUp={mouseEventHandles.mouseUp}
+      onRightClick={mouseEventHandles.rightClick}
+      onRightDown={mouseEventHandles.rightDown}
+      onRightUp={mouseEventHandles.rightUp}
+      onMiddleClick={mouseEventHandles.middleClick}
+      onMiddleDown={mouseEventHandles.middleDown}
+      onMiddleUp={mouseEventHandles.middleUp}
+      onMouseMove={mouseEventHandles.mouseMove}
+      onMouseEnter={mouseEventHandles.mouseEnter}
+      onMouseLeave={mouseEventHandles.mouseLeave}
       onWheel={mouseEventHandles.wheel}>
       <Event onMount={handleMount} onUnmount={handleUnmount} />
       <Clock timelineManagerRef={timelineManagerRef} />

package/src/mantle/compat/types.ts

@@ -31,19 +31,19 @@ export type Rect = {
 /** Represents the camera position and state */
 export type CameraPosition = {
   /** degrees */
-  lat: number;
+  lat?: number;
   /** degrees */
-  lng: number;
+  lng?: number;
   /** meters */
-  height: number;
+  height?: number;
   /** radians */
-  heading: number;
+  heading?: number;
   /** radians */
-  pitch: number;
+  pitch?: number;
   /** radians */
-  roll: number;
+  roll?: number;
   /** Field of view expressed in radians */
-  fov: number;
+  fov?: number;
   /** Aspect ratio of frustum */
   aspectRatio?: number;
 };