@geode/opengeodeweb-front 10.34.0-rc.8 → 10.34.0

package/internal/stores/hybrid_viewer/camera.ts

@@ -1,17 +1,15 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
+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 { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
+import { useHybridViewerScene } from "./scene";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-import type { Ref } from "vue";
-import type { CameraOptions, HybridViewerStorePublic, Vector3, vtkCamera } from "./vtk_types";
 
 const BUMP_MULTIPLIER = 0.2;
 const ALIGNMENT_THRESHOLD = 0.9;
@@ -49,26 +47,20 @@ const ORIENTATIONS: Record<string, OrientationConfig> = {
   },
 };
 
-// `genericRenderWindow.value` and its vtk objects are only ever read from these functions after the viewer has been initialized (see app/stores/hybrid_viewer.ts's initHybridViewer), so the non-null assertions below reflect that existing invariant rather than a new assumption.
-
-function getImageStyle(): unknown {
-  const { genericRenderWindow } = useHybridViewerStore() as unknown as HybridViewerStorePublic;
+function getImageStyle(): CSSStyleDeclaration | undefined {
+  const { genericRenderWindow } = useHybridViewerCore();
   if (!genericRenderWindow.value) {
     return undefined;
   }
-  const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
-  if (!webGLRenderWindow) {
-    return undefined;
-  }
-  const bgImage = webGLRenderWindow.getReferenceByName("bgImage");
-  return bgImage ? bgImage.style : 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 | undefined): CameraOptions | undefined {
-  if (!camera || !camera.getFocalPoint) {
-    // Dead branch in practice (a real vtkCamera always has getFocalPoint); kept for parity with the original defensive check.
-    return camera as CameraOptions | 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,
@@ -79,38 +71,11 @@ function getCameraOptions(camera: vtkCamera | undefined): CameraOptions | undefi
   };
 }
 
-function performSyncRemoteCamera(): void {
-  const { genericRenderWindow, camera_options, remoteRender } =
-    useHybridViewerStore() as unknown as HybridViewerStorePublic;
-  const viewerStore = useViewerStore();
-  const renderer = genericRenderWindow.value!.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: () => {
-        remoteRender();
-        if (camera_options) {
-          Object.assign(camera_options, options_camera);
-        }
-      },
-    },
-  );
-}
-
 function applyCameraOptions(
   camera: vtkCamera | undefined,
-  options: CameraOptions | undefined,
+  options: Partial<CameraOptions> | undefined,
 ): void {
-  if (camera && camera.set && options) {
+  if (camera && options) {
     camera.set({
       focalPoint: options.focal_point,
       viewUp: options.view_up,
@@ -121,136 +86,206 @@ function applyCameraOptions(
   }
 }
 
-function performSetCamera(targetCameraOptions: CameraOptions): void {
-  const hybridViewerStore = useHybridViewerStore();
-  const { genericRenderWindow } = hybridViewerStore as unknown as HybridViewerStorePublic;
-  const { is_moving } = storeToRefs(hybridViewerStore) as unknown as { is_moving: Ref<boolean> };
-  const imageStyle = getImageStyle() as { opacity: number } | undefined;
-  const renderer = genericRenderWindow.value!.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: startState!,
-    targetState: targetCameraOptions,
-    duration,
-    bumpMultiplier: 0,
-    easeExponent: EASE_EXPONENT,
-    onUpdate: () => {
-      const renderWindow = genericRenderWindow.value!.getRenderWindow();
-      renderWindow.render();
-    },
-    onEnd: () => {
-      applyCameraOptions(camera, targetCameraOptions);
-      const renderWindow = genericRenderWindow.value!.getRenderWindow();
-      renderWindow.render();
-      is_moving.value = false;
-      performSyncRemoteCamera();
-    },
-  });
+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")
+  );
 }
 
-async function performFocusCameraOnObject(id: string, block_ids: string[] = []): Promise<void> {
-  const { genericRenderWindow, hybridDb } =
-    useHybridViewerStore() as unknown as HybridViewerStorePublic;
-  if (!hybridDb[id]) {
-    return;
+function toBounds(value: unknown): [number, number, number, number, number, number] {
+  if (!isBounds(value)) {
+    throw new Error("Expected a six-element numeric bounds array");
   }
-  const viewerStore = useViewerStore();
-  let bounds: number[] = [];
-  if (block_ids.length > 0) {
-    const schema = viewer_schemas.opengeodeweb_viewer.model.get_blocks_bounds;
-    const params = {
-      id,
-      block_ids,
-    };
-    bounds = (await viewerStore.request({
-      schema,
-      params,
-    })) as number[];
-  } else {
-    bounds = hybridDb[id].actor.getBounds();
-  }
-  const renderer = genericRenderWindow.value!.getRenderer();
-  const camera = renderer.getActiveCamera();
-  const startOptions = getCameraOptions(camera);
-  renderer.resetCamera(bounds as [number, number, number, number, number, number]);
-  const targetOptions = getCameraOptions(camera);
-  applyCameraOptions(camera, startOptions);
-  performSetCamera(targetOptions!);
+  return value;
 }
 
-function performCameraOrientation(orientation: string): void {
-  const config = ORIENTATIONS[orientation.toLowerCase()];
-  if (!config) {
+function centerCameraOnPosition(
+  camera: vtkCamera | undefined,
+  pickedPosition: Vector3 | undefined,
+): void {
+  if (!camera || !pickedPosition) {
     return;
   }
-  const hybridViewerStore = useHybridViewerStore();
-  const { genericRenderWindow } = hybridViewerStore as unknown as HybridViewerStorePublic;
-  const { is_moving } = storeToRefs(hybridViewerStore) as unknown as { is_moving: Ref<boolean> };
-  const imageStyle = getImageStyle() as { opacity: number } | undefined;
-  const renderer = genericRenderWindow.value!.getRenderer();
-  const camera = renderer.getActiveCamera();
-  const startState = getCameraOptions(camera);
-  applyCameraOptions(camera, {
-    ...config,
-    focal_point: [0, 0, 0],
-  } as CameraOptions);
-  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: startState!,
-    targetState: targetState!,
-    duration,
-    bumpMultiplier: BUMP_MULTIPLIER,
-    easeExponent: EASE_EXPONENT,
-    onUpdate: () => {
-      const renderWindow = genericRenderWindow.value!.getRenderWindow();
-      renderWindow.render();
-    },
-    onEnd: () => {
-      is_moving.value = false;
-      performSyncRemoteCamera();
-    },
-  });
+  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],
+  );
 }
 
-function useHybridViewerCamera() {
+// 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 } = useHybridViewerStore() as unknown as HybridViewerStorePublic;
-    const renderer = genericRenderWindow.value!.getRenderer();
+    const { genericRenderWindow } = useHybridViewerCore();
+    const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
     renderer.resetCamera();
-    const renderWindow = genericRenderWindow.value!.getRenderWindow();
+    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,
@@ -259,24 +294,7 @@ function useHybridViewerCamera() {
     focusCameraOnObject,
     setCameraOrientation,
   };
-}
-
-function centerCameraOnPosition(
-  camera: vtkCamera | undefined,
-  pickedPosition: Vector3 | undefined,
-): void {
-  if (!camera || !pickedPosition) {
-    return;
-  }
-  const focalPoint = camera.getFocalPoint();
-  const position = camera.getPosition();
-  camera.setFocalPoint(...pickedPosition);
-  camera.setPosition(
-    position[0] + pickedPosition[0] - focalPoint[0],
-    position[1] + pickedPosition[1] - focalPoint[1],
-    position[2] + pickedPosition[2] - focalPoint[2],
-  );
-}
+});
 
 interface CameraSnapshot {
   zScale?: number;
@@ -287,12 +305,11 @@ async function applySnapshot(snapshot: CameraSnapshot | undefined): Promise<void
   if (!snapshot) {
     return;
   }
-  const { setZScaling, setCamera } = useHybridViewerStore() as unknown as HybridViewerStorePublic;
   if (typeof snapshot.zScale === "number") {
-    await setZScaling(snapshot.zScale);
+    await useHybridViewerScene().setZScaling(snapshot.zScale);
   }
   if (snapshot.camera_options) {
-    setCamera(snapshot.camera_options);
+    useHybridViewerCamera().setCamera(snapshot.camera_options);
   }
 }
 export {
@@ -304,9 +321,6 @@ export {
   applySnapshot,
   centerCameraOnPosition,
   getCameraOptions,
-  performCameraOrientation,
-  performFocusCameraOnObject,
-  performSetCamera,
-  performSyncRemoteCamera,
   useHybridViewerCamera,
 };
+export type { CameraSnapshot };

package/internal/stores/hybrid_viewer/camera_animation.ts

@@ -1,7 +1,5 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import { dot } from "@kitware/vtk.js/Common/Core/Math";
 import type { CameraOptions, Vector3, vtkCamera } from "./vtk_types";
+import { dot } from "@kitware/vtk.js/Common/Core/Math";
 
 const NEAR_ZERO_THRESHOLD = 1e-10;
 const SLERP_LINEAR_THRESHOLD = 0.9995;
@@ -117,15 +115,18 @@ function animateCamera(options: AnimateCameraOptions): void {
     const bump = bumpMultiplier * Math.sin(Math.PI * progress);
     const dir = slerp(startDir, targetDir, ease, antipodalMid);
     const dist = startDist + (targetDist - startDist) * ease + bump;
-    // `index` ranges over startState.focal_point's own length (3), which always
-    // Matches targetState.focal_point's length, so the lookup is always in bounds.
-    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({
-      // Same reasoning: `index` ranges over focalPoint's length, matching `dir`'s length (3).
-      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/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.ts

@@ -1,13 +1,10 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-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";
-import type { HybridViewerStorePublic } from "./vtk_types";
 
-async function performSetClippingPlanes(ids: string[], planes: unknown): Promise<void> {
+async function setClippingPlanes(ids: string[], planes: unknown): Promise<void> {
   const viewerStore = useViewerStore();
-  const { remoteRender } = useHybridViewerStore() as unknown as HybridViewerStorePublic;
+  const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.clipping_planes;
   const params = {
     ids,
@@ -19,9 +16,9 @@ async function performSetClippingPlanes(ids: string[], planes: unknown): Promise
   });
   await remoteRender();
 }
-async function performSetShrink(ids: string[], shrink_factor: number): Promise<void> {
+async function setShrink(ids: string[], shrink_factor: number): Promise<void> {
   const viewerStore = useViewerStore();
-  const { remoteRender } = useHybridViewerStore() as unknown as HybridViewerStorePublic;
+  const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.shrink;
   const params = {
     ids,
@@ -33,16 +30,13 @@ async function performSetShrink(ids: string[], shrink_factor: number): Promise<v
   });
   await remoteRender();
 }
-function useHybridViewerFilters() {
-  async function setClippingPlanes(ids: string[], planes: unknown): Promise<void> {
-    await performSetClippingPlanes(ids, planes);
-  }
-  async function setShrink(ids: string[], shrink_factor: number): Promise<void> {
-    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 };