@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/internal/stores/hybrid_viewer/brightness.ts

@@ -0,0 +1,124 @@
+import { BACKGROUND_GREY_VALUE, RGB_MAX } from "./constants";
+import { useHybridViewerCore } from "./core";
+
+const RGBA_CHANNELS = 4;
+const SAMPLE_SIZE = 10;
+const TOTAL_CHANNELS = 400;
+
+interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+// The decoded background image handed to us by the viewer's image stream (see app/stores/hybrid_viewer.ts's onImageReady) - draw-able onto a 2D canvas.
+type DrawableImage = CanvasImageSource & { width: number; height: number };
+
+interface BrightnessOptions {
+  latestImage: DrawableImage | undefined;
+  offscreenCtx: CanvasRenderingContext2D | undefined;
+  offscreenCanvas: HTMLCanvasElement | undefined;
+}
+
+interface RelativeRect {
+  relX: number;
+  relY: number;
+  relW: number;
+  relH: number;
+}
+
+function mapRect(rect: Rect, latestImage: DrawableImage, canvasRect: DOMRect): RelativeRect {
+  const scaleX = latestImage.width / canvasRect.width;
+  const scaleY = latestImage.height / canvasRect.height;
+  return {
+    relX: (rect.x - canvasRect.left) * scaleX,
+    relY: (rect.y - canvasRect.top) * scaleY,
+    relW: rect.width * scaleX,
+    relH: rect.height * scaleY,
+  };
+}
+
+function sampleMinBrightness(
+  ctx: CanvasRenderingContext2D,
+  image: DrawableImage,
+  relRect: RelativeRect,
+): number {
+  ctx.drawImage(
+    image,
+    Math.max(0, relRect.relX),
+    Math.max(0, relRect.relY),
+    Math.min(image.width, relRect.relW),
+    Math.min(image.height, relRect.relH),
+    0,
+    0,
+    SAMPLE_SIZE,
+    SAMPLE_SIZE,
+  );
+  const { data } = ctx.getImageData(0, 0, SAMPLE_SIZE, SAMPLE_SIZE);
+  let minBrightness = 1;
+  for (let i = 0; i < TOTAL_CHANNELS; i += RGBA_CHANNELS) {
+    const brightness = ((data[i] ?? 0) + (data[i + 1] ?? 0) + (data[i + 2] ?? 0)) / (3 * RGB_MAX);
+    if (brightness < minBrightness) {
+      minBrightness = brightness;
+    }
+  }
+  return minBrightness;
+}
+
+function computeAverageBrightness(rect: Rect, options: BrightnessOptions): number {
+  const { latestImage, offscreenCtx, offscreenCanvas } = options;
+  const { genericRenderWindow } = useHybridViewerCore();
+  if (!latestImage || !offscreenCtx || !offscreenCanvas || !genericRenderWindow.value) {
+    return BACKGROUND_GREY_VALUE / RGB_MAX;
+  }
+  // oxlint-disable-next-line no-unsafe-assignment -- vtk.js has no types for getApiSpecificRenderWindow(); narrowed below.
+  const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+  const apiSpecificRenderWindow = webGLRenderWindow as unknown as {
+    getCanvas: () => HTMLCanvasElement | null | undefined;
+  };
+  const canvas = apiSpecificRenderWindow.getCanvas();
+  if (canvas === undefined || canvas === null) {
+    return BACKGROUND_GREY_VALUE / RGB_MAX;
+  }
+  if (rect.width <= 0 || rect.height <= 0) {
+    return BACKGROUND_GREY_VALUE / RGB_MAX;
+  }
+  const relRect = mapRect(rect, latestImage, canvas.getBoundingClientRect());
+  if (relRect.relW <= 0 || relRect.relH <= 0) {
+    return BACKGROUND_GREY_VALUE / RGB_MAX;
+  }
+  offscreenCanvas.width = SAMPLE_SIZE;
+  offscreenCanvas.height = SAMPLE_SIZE;
+  try {
+    return sampleMinBrightness(offscreenCtx, latestImage, relRect);
+  } catch {
+    return BACKGROUND_GREY_VALUE / RGB_MAX;
+  }
+}
+function useHybridViewerBrightness(): {
+  latestImage: Ref<DrawableImage | undefined>;
+  getAverageBrightness: (rect: Rect) => number;
+} {
+  const latestImage = ref<DrawableImage | undefined>(undefined);
+  const offscreenCanvas: HTMLCanvasElement | undefined =
+    typeof document === "undefined" ? undefined : document.createElement("canvas");
+  const offscreenCtx: CanvasRenderingContext2D | undefined = offscreenCanvas
+    ? (offscreenCanvas.getContext("2d", {
+        willReadFrequently: true,
+      }) ?? undefined)
+    : undefined;
+  function getAverageBrightness(rect: Rect): number {
+    return computeAverageBrightness(rect, {
+      latestImage: latestImage.value,
+      offscreenCtx,
+      offscreenCanvas,
+    });
+  }
+  return {
+    latestImage,
+    getAverageBrightness,
+  };
+}
+export { computeAverageBrightness, useHybridViewerBrightness };

package/internal/stores/hybrid_viewer/camera.ts

@@ -0,0 +1,326 @@
+import type { CameraOptions, Vector3, vtkCamera, vtkOpenGLRenderWindow } from "./vtk_types";
+import {
+  LONG_ANIMATION_DURATION,
+  SHORT_ANIMATION_DURATION,
+  animateCamera,
+  computeAnimationDuration,
+} from "./camera_animation";
+import { requireRenderWindow, useHybridViewerCore } from "./core";
+import { dot } from "@kitware/vtk.js/Common/Core/Math";
+import { useHybridViewerScene } from "./scene";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+const BUMP_MULTIPLIER = 0.2;
+const ALIGNMENT_THRESHOLD = 0.9;
+const EASE_EXPONENT = 1.1;
+
+interface OrientationConfig {
+  position: Vector3;
+  view_up: Vector3;
+}
+
+const ORIENTATIONS: Record<string, OrientationConfig> = {
+  zplus: {
+    position: [0, 0, 1],
+    view_up: [0, 1, 0],
+  },
+  zminus: {
+    position: [0, 0, -1],
+    view_up: [0, 1, 0],
+  },
+  yplus: {
+    position: [0, 1, 0],
+    view_up: [0, 0, 1],
+  },
+  yminus: {
+    position: [0, -1, 0],
+    view_up: [0, 0, 1],
+  },
+  xplus: {
+    position: [1, 0, 0],
+    view_up: [0, 0, 1],
+  },
+  xminus: {
+    position: [-1, 0, 0],
+    view_up: [0, 0, 1],
+  },
+};
+
+function getImageStyle(): CSSStyleDeclaration | undefined {
+  const { genericRenderWindow } = useHybridViewerCore();
+  if (!genericRenderWindow.value) {
+    return undefined;
+  }
+  // oxlint-disable-next-line no-unsafe-assignment -- vtk.js has no types for getApiSpecificRenderWindow(); narrowed below.
+  const apiSpecificRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+  const webGLRenderWindow = apiSpecificRenderWindow as unknown as vtkOpenGLRenderWindow;
+  const bgImage: unknown = webGLRenderWindow.getReferenceByName("bgImage");
+  return bgImage instanceof HTMLImageElement ? bgImage.style : undefined;
+}
+
+function getCameraOptions(camera: vtkCamera): CameraOptions {
+  return {
+    focal_point: [...(camera.getFocalPoint() ?? [0, 0, 0])] as Vector3,
+    view_up: [...(camera.getViewUp() ?? [0, 0, 0])] as Vector3,
+    position: [...(camera.getPosition() ?? [0, 0, 0])] as Vector3,
+    view_angle: camera.getViewAngle(),
+    clipping_range: [...(camera.getClippingRange() ?? [0, 0])] as [number, number],
+    distance: camera.getDistance(),
+  };
+}
+
+function applyCameraOptions(
+  camera: vtkCamera | undefined,
+  options: Partial<CameraOptions> | undefined,
+): void {
+  if (camera && options) {
+    camera.set({
+      focalPoint: options.focal_point,
+      viewUp: options.view_up,
+      position: options.position,
+      viewAngle: options.view_angle,
+      clippingRange: options.clipping_range,
+    });
+  }
+}
+
+const BOUNDS_LENGTH = 6;
+
+function isBounds(value: unknown): value is [number, number, number, number, number, number] {
+  return (
+    Array.isArray(value) &&
+    value.length === BOUNDS_LENGTH &&
+    value.every((item): item is number => typeof item === "number")
+  );
+}
+
+function toBounds(value: unknown): [number, number, number, number, number, number] {
+  if (!isBounds(value)) {
+    throw new Error("Expected a six-element numeric bounds array");
+  }
+  return value;
+}
+
+function centerCameraOnPosition(
+  camera: vtkCamera | undefined,
+  pickedPosition: Vector3 | undefined,
+): void {
+  if (!camera || !pickedPosition) {
+    return;
+  }
+  const position = camera.getPosition();
+  const directionOfProjection = camera.getDirectionOfProjection();
+  const distance = dot(
+    [
+      pickedPosition[0] - position[0],
+      pickedPosition[1] - position[1],
+      pickedPosition[2] - position[2],
+    ],
+    directionOfProjection,
+  );
+  camera.setFocalPoint(...pickedPosition);
+  camera.setPosition(
+    pickedPosition[0] - distance * directionOfProjection[0],
+    pickedPosition[1] - distance * directionOfProjection[1],
+    pickedPosition[2] - distance * directionOfProjection[2],
+  );
+}
+
+// Shared via createSharedComposable (rather than merged into the parent hybridViewer store) so sibling slices, e.g. viewport.ts and ruler.ts, can read camera_options/setCamera/syncRemoteCamera directly without importing the parent store and creating a cycle. A Pinia store would work too but its $id/$patch/... properties would leak into the composed store's spread and collapse its inferred type.
+const useHybridViewerCamera = createSharedComposable(() => {
+  const camera_options = reactive<Record<string, unknown>>({});
+
+  function performSyncRemoteCamera(): void {
+    const { genericRenderWindow, remoteRender } = useHybridViewerCore();
+    const viewerStore = useViewerStore();
+    const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
+    const camera = renderer.getActiveCamera();
+    const options_camera = getCameraOptions(camera);
+    const schema = viewer_schemas.opengeodeweb_viewer.viewer.update_camera;
+    const params = {
+      camera_options: options_camera,
+    };
+    viewerStore
+      .request(
+        {
+          schema,
+          params,
+        },
+        {
+          response_function: async () => {
+            await remoteRender().catch(() => undefined);
+            Object.assign(camera_options, options_camera);
+          },
+        },
+      )
+      // oxlint-disable-next-line promise/prefer-await-to-then -- fire-and-forget inside a sync caller; see codebase convention in global_attribute_style.ts.
+      .catch(() => undefined);
+  }
+
+  function syncRemoteCamera(): void {
+    performSyncRemoteCamera();
+  }
+
+  function performSetCamera(targetCameraOptions: CameraOptions): void {
+    const { genericRenderWindow, is_moving } = useHybridViewerCore();
+    const imageStyle = getImageStyle();
+    const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
+    const camera = renderer.getActiveCamera();
+    const startState = getCameraOptions(camera);
+    const duration = computeAnimationDuration(startState, targetCameraOptions);
+    is_moving.value = true;
+    if (imageStyle) {
+      imageStyle.opacity = "0";
+    }
+    animateCamera({
+      camera,
+      startState,
+      targetState: targetCameraOptions,
+      duration,
+      bumpMultiplier: 0,
+      easeExponent: EASE_EXPONENT,
+      onUpdate: () => {
+        const renderWindow = requireRenderWindow(genericRenderWindow).getRenderWindow();
+        renderWindow.render();
+      },
+      onEnd: () => {
+        applyCameraOptions(camera, targetCameraOptions);
+        const renderWindow = requireRenderWindow(genericRenderWindow).getRenderWindow();
+        renderWindow.render();
+        is_moving.value = false;
+        performSyncRemoteCamera();
+      },
+    });
+  }
+
+  function setCamera(targetCameraOptions: CameraOptions): void {
+    performSetCamera(targetCameraOptions);
+  }
+
+  function resetCamera(): void {
+    const { genericRenderWindow } = useHybridViewerCore();
+    const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
+    renderer.resetCamera();
+    const renderWindow = requireRenderWindow(genericRenderWindow).getRenderWindow();
+    renderWindow.render();
+    syncRemoteCamera();
+  }
+
+  async function performFocusCameraOnObject(id: string, block_ids: string[] = []): Promise<void> {
+    const { genericRenderWindow } = useHybridViewerCore();
+    const { hybridDb } = useHybridViewerScene();
+    if (!hybridDb[id]) {
+      return;
+    }
+    const viewerStore = useViewerStore();
+    const bounds: [number, number, number, number, number, number] =
+      block_ids.length > 0
+        ? toBounds(
+            await viewerStore.request({
+              schema: viewer_schemas.opengeodeweb_viewer.model.get_blocks_bounds,
+              params: {
+                id,
+                block_ids,
+              },
+            }),
+          )
+        : hybridDb[id].actor.getBounds();
+    const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
+    const camera = renderer.getActiveCamera();
+    const startOptions = getCameraOptions(camera);
+    renderer.resetCamera(bounds);
+    const targetOptions = getCameraOptions(camera);
+    applyCameraOptions(camera, startOptions);
+    performSetCamera(targetOptions);
+  }
+
+  async function focusCameraOnObject(id: string, block_ids: string[] = []): Promise<void> {
+    await performFocusCameraOnObject(id, block_ids);
+  }
+
+  function performCameraOrientation(orientation: string): void {
+    const config = ORIENTATIONS[orientation.toLowerCase()];
+    if (!config) {
+      return;
+    }
+    const { genericRenderWindow, is_moving } = useHybridViewerCore();
+    const imageStyle = getImageStyle();
+    const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
+    const camera = renderer.getActiveCamera();
+    const startState = getCameraOptions(camera);
+    applyCameraOptions(camera, {
+      ...config,
+      focal_point: [0, 0, 0],
+    });
+    renderer.resetCamera();
+    const targetState = getCameraOptions(camera);
+    applyCameraOptions(camera, startState);
+    const alignment = dot(camera.getDirectionOfProjection(), config.position);
+    const duration =
+      alignment > ALIGNMENT_THRESHOLD ? LONG_ANIMATION_DURATION : SHORT_ANIMATION_DURATION;
+    is_moving.value = true;
+    if (imageStyle) {
+      imageStyle.opacity = "0";
+    }
+    animateCamera({
+      camera,
+      startState,
+      targetState,
+      duration,
+      bumpMultiplier: BUMP_MULTIPLIER,
+      easeExponent: EASE_EXPONENT,
+      onUpdate: () => {
+        const renderWindow = requireRenderWindow(genericRenderWindow).getRenderWindow();
+        renderWindow.render();
+      },
+      onEnd: () => {
+        is_moving.value = false;
+        performSyncRemoteCamera();
+      },
+    });
+  }
+
+  function setCameraOrientation(orientation: string): void {
+    performCameraOrientation(orientation);
+  }
+
+  return {
+    camera_options,
+    syncRemoteCamera,
+    setCamera,
+    resetCamera,
+    focusCameraOnObject,
+    setCameraOrientation,
+  };
+});
+
+interface CameraSnapshot {
+  zScale?: number;
+  camera_options?: CameraOptions;
+}
+
+async function applySnapshot(snapshot: CameraSnapshot | undefined): Promise<void> {
+  if (!snapshot) {
+    return;
+  }
+  if (typeof snapshot.zScale === "number") {
+    await useHybridViewerScene().setZScaling(snapshot.zScale);
+  }
+  if (snapshot.camera_options) {
+    useHybridViewerCamera().setCamera(snapshot.camera_options);
+  }
+}
+export {
+  ALIGNMENT_THRESHOLD,
+  BUMP_MULTIPLIER,
+  EASE_EXPONENT,
+  ORIENTATIONS,
+  applyCameraOptions,
+  applySnapshot,
+  centerCameraOnPosition,
+  getCameraOptions,
+  useHybridViewerCamera,
+};
+export type { CameraSnapshot };

package/internal/stores/hybrid_viewer/{camera_animation.js → camera_animation.ts}

@@ -1,3 +1,4 @@
+import type { CameraOptions, Vector3, vtkCamera } from "./vtk_types";
 import { dot } from "@kitware/vtk.js/Common/Core/Math";
 
 const NEAR_ZERO_THRESHOLD = 1e-10;
@@ -6,15 +7,15 @@ const LONG_ANIMATION_DURATION = 1000;
 const SHORT_ANIMATION_DURATION = 500;
 const MID_ANIMATION_RATIO = 0.5;
 
-function vecSub(vector, other) {
+function vecSub(vector: Vector3, other: Vector3): Vector3 {
   return [vector[0] - other[0], vector[1] - other[1], vector[2] - other[2]];
 }
 
-function vecLength(vector) {
+function vecLength(vector: Vector3): number {
   return Math.hypot(vector[0], vector[1], vector[2]);
 }
 
-function vecNormalize(vector) {
+function vecNormalize(vector: Vector3): Vector3 {
   const len = vecLength(vector);
   if (len < NEAR_ZERO_THRESHOLD) {
     return [0, 0, 1];
@@ -22,7 +23,7 @@ function vecNormalize(vector) {
   return [vector[0] / len, vector[1] / len, vector[2] / len];
 }
 
-function slerp(from, target, ratio, mid) {
+function slerp(from: Vector3, target: Vector3, ratio: number, mid?: Vector3): Vector3 {
   const normFrom = vecNormalize(from);
   const normTarget = vecNormalize(target);
   let dotProduct =
@@ -51,7 +52,7 @@ function slerp(from, target, ratio, mid) {
   ];
 }
 
-function computeAnimationDuration(startState, targetState) {
+function computeAnimationDuration(startState: CameraOptions, targetState: CameraOptions): number {
   const startDir = vecNormalize(vecSub(startState.position, startState.focal_point));
   const targetDir = vecNormalize(vecSub(targetState.position, targetState.focal_point));
   const dotProduct = Math.max(-1, Math.min(1, dot(startDir, targetDir)));
@@ -62,7 +63,18 @@ function computeAnimationDuration(startState, targetState) {
   );
 }
 
-function animateCamera(options) {
+interface AnimateCameraOptions {
+  camera: vtkCamera;
+  startState: CameraOptions;
+  targetState: CameraOptions;
+  duration: number;
+  bumpMultiplier: number;
+  easeExponent: number;
+  onUpdate: () => void;
+  onEnd: () => void;
+}
+
+function animateCamera(options: AnimateCameraOptions): void {
   const {
     camera,
     startState,
@@ -83,7 +95,7 @@ function animateCamera(options) {
   const startTargetDot =
     normStart[0] * normTarget[0] + normStart[1] * normTarget[1] + normStart[2] * normTarget[2];
 
-  let antipodalMid = undefined;
+  let antipodalMid: Vector3 | undefined = undefined;
   if (startTargetDot < -SLERP_LINEAR_THRESHOLD) {
     const normUp = vecNormalize(startState.view_up);
     antipodalMid = vecNormalize([
@@ -94,7 +106,7 @@ function animateCamera(options) {
   }
 
   const startTime = performance.now();
-  function animate(currentTime) {
+  function animate(currentTime: number): void {
     const progress = Math.min((currentTime - startTime) / duration, 1);
     const ease =
       duration > SHORT_ANIMATION_DURATION
@@ -103,12 +115,18 @@ function animateCamera(options) {
     const bump = bumpMultiplier * Math.sin(Math.PI * progress);
     const dir = slerp(startDir, targetDir, ease, antipodalMid);
     const dist = startDist + (targetDist - startDist) * ease + bump;
-    const focalPoint = startState.focal_point.map(
-      (startValue, index) => startValue + (targetState.focal_point[index] - startValue) * ease,
-    );
+    const focalPoint: Vector3 = [
+      startState.focal_point[0] + (targetState.focal_point[0] - startState.focal_point[0]) * ease,
+      startState.focal_point[1] + (targetState.focal_point[1] - startState.focal_point[1]) * ease,
+      startState.focal_point[2] + (targetState.focal_point[2] - startState.focal_point[2]) * ease,
+    ];
     const viewUp = slerp(startState.view_up, targetState.view_up, ease);
     camera.set({
-      position: focalPoint.map((focalCoord, index) => focalCoord + dir[index] * dist),
+      position: [
+        focalPoint[0] + dir[0] * dist,
+        focalPoint[1] + dir[1] * dist,
+        focalPoint[2] + dir[2] * dist,
+      ],
       viewUp,
       focalPoint,
     });

package/internal/stores/hybrid_viewer/{constants.js → constants.ts}

@@ -3,9 +3,9 @@ const BACKGROUND_GREY_VALUE = 180;
 const ACTOR_DARK_VALUE = 20;
 
 const bgVal = BACKGROUND_GREY_VALUE / RGB_MAX;
-const BACKGROUND_COLOR = [bgVal, bgVal, bgVal];
+const BACKGROUND_COLOR: [number, number, number] = [bgVal, bgVal, bgVal];
 const actVal = ACTOR_DARK_VALUE / RGB_MAX;
-const ACTOR_COLOR = [actVal, actVal, actVal];
+const ACTOR_COLOR: [number, number, number] = [actVal, actVal, actVal];
 const HOVER_TIMEOUT_MS = 500;
 const WHEEL_TIME_OUT_MS = 600;
 const HOVER_DEBOUNCE_MS = 50;

package/internal/stores/hybrid_viewer/core.ts

@@ -0,0 +1,64 @@
+import { Status } from "@ogw_front/utils/status";
+import type { ViewStreamLike } from "./vtk_types";
+import type { vtkGenericRenderWindow as VtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+interface GenericRenderWindowHolder {
+  value?: VtkGenericRenderWindow;
+}
+
+// `genericRenderWindow.value` is only ever read from these functions after the viewer has been initialized (see app/stores/hybrid_viewer.ts's initHybridViewer), so requireRenderWindow throwing on that path would indicate a real bug rather than an expected state.
+function requireRenderWindow(holder: GenericRenderWindowHolder): VtkGenericRenderWindow {
+  if (!holder.value) {
+    throw new Error("genericRenderWindow accessed before the viewer was initialized");
+  }
+  return holder.value;
+}
+
+// Render-window, status and drag/pick state shared across the hybrid viewer's slice composables (app/stores/hybrid_viewer.ts and internal/stores/hybrid_viewer/*), plus the debounced remote-render call they all trigger. Shared via createSharedComposable (a singleton per mounted tree, not a Pinia store) so those slices can depend on it directly instead of on the composed hybridViewer store, which would create an import cycle; a real Pinia store here would also pull its own $id/$patch/... properties into the composed store's spread and collapse its inferred type.
+const useHybridViewerCore = createSharedComposable(() => {
+  const genericRenderWindow = reactive<GenericRenderWindowHolder>({});
+  const status = ref(Status.NOT_CREATED);
+  const is_moving = ref(false);
+  const is_picking = ref(false);
+  const viewStream = ref<ViewStreamLike | undefined>(undefined);
+
+  let renderPromise: Promise<void> | undefined = undefined;
+  let renderPending = false;
+
+  async function remoteRender(): Promise<void> {
+    if (renderPromise) {
+      renderPending = true;
+      await renderPromise;
+      return;
+    }
+
+    renderPromise = (async (): Promise<void> => {
+      try {
+        const viewerStore = useViewerStore();
+        const schema = viewer_schemas.opengeodeweb_viewer.viewer.render;
+        await viewerStore.request({ schema });
+      } finally {
+        renderPromise = undefined;
+        if (renderPending) {
+          renderPending = false;
+          await remoteRender();
+        }
+      }
+    })();
+    return renderPromise;
+  }
+
+  return {
+    genericRenderWindow,
+    status,
+    is_moving,
+    is_picking,
+    viewStream,
+    remoteRender,
+  };
+});
+
+export { requireRenderWindow, useHybridViewerCore };
+export type { GenericRenderWindowHolder };

package/internal/stores/hybrid_viewer/{filters.js → filters.ts}

@@ -1,10 +1,10 @@
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
+import { useHybridViewerCore } from "./core";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-async function performSetClippingPlanes(ids, planes) {
+async function setClippingPlanes(ids: string[], planes: unknown): Promise<void> {
   const viewerStore = useViewerStore();
-  const { remoteRender } = useHybridViewerStore();
+  const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.clipping_planes;
   const params = {
     ids,
@@ -16,9 +16,9 @@ async function performSetClippingPlanes(ids, planes) {
   });
   await remoteRender();
 }
-async function performSetShrink(ids, shrink_factor) {
+async function setShrink(ids: string[], shrink_factor: number): Promise<void> {
   const viewerStore = useViewerStore();
-  const { remoteRender } = useHybridViewerStore();
+  const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.shrink;
   const params = {
     ids,
@@ -30,16 +30,13 @@ async function performSetShrink(ids, shrink_factor) {
   });
   await remoteRender();
 }
-function useHybridViewerFilters() {
-  async function setClippingPlanes(ids, planes) {
-    await performSetClippingPlanes(ids, planes);
-  }
-  async function setShrink(ids, shrink_factor) {
-    await performSetShrink(ids, shrink_factor);
-  }
+function useHybridViewerFilters(): {
+  setClippingPlanes: (ids: string[], planes: unknown) => Promise<void>;
+  setShrink: (ids: string[], shrink_factor: number) => Promise<void>;
+} {
   return {
     setClippingPlanes,
     setShrink,
   };
 }
-export { performSetClippingPlanes, performSetShrink, useHybridViewerFilters };
+export { useHybridViewerFilters };