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

package/app/composables/clipping_planes_widget.ts

@@ -1,58 +1,38 @@
-// 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 {
-  AXIS_SCALE,
   CHANGE_THRESHOLD,
-  PLANE_COLORS,
-  SIZE_RATIO,
+  type MainCameraOptions,
+  type SceneBoundsInfo,
+  alignCameraToMainCamera,
   computeSceneBoundsInfo,
-  getPlaneStyle,
-  hasPlaneChanged,
+  resolveActiveActors,
 } from "@ogw_front/utils/clipping_planes";
-import { newInstance as vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
-// ImplicitPlaneWidget ships no type declarations at all (unlike most of vtk.js), unlike a module that simply doesn't exist, so it can't be given an ambient `declare module` shim either - suppress the resulting implicit-any error at the import site instead.
-// @ts-expect-error -- see comment above; newInstance() below is implicitly `any`.
-import { newInstance as vtkImplicitPlaneWidget } from "@kitware/vtk.js/Widgets/Widgets3D/ImplicitPlaneWidget";
-import { newInstance as vtkWidgetManager } from "@kitware/vtk.js/Widgets/Core/WidgetManager";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { vtkWidgetManager as WidgetManagerInstance } from "@kitware/vtk.js/Widgets/Core/WidgetManager";
-import type { Ref } from "vue";
-import type vtkActor from "@kitware/vtk.js/Rendering/Core/Actor";
-import type { vtkCamera } from "@kitware/vtk.js/Rendering/Core/Camera";
+import {
+  type ClippingPlane,
+  useWidgetEntryManager,
+} from "@ogw_front/composables/clipping_planes_widget_entries";
+import {
+  type vtkWidgetManager as WidgetManagerInstance,
+  newInstance as vtkWidgetManager,
+} from "@kitware/vtk.js/Widgets/Core/WidgetManager";
 import type { vtkGenericRenderWindow as GenericRenderWindowInstance } from "@ogw_internal/stores/hybrid_viewer/vtk_types";
 import type { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
-
-interface ClippingPlane {
-  origin?: number[];
-  normal: number[];
-}
+import type { vtkCamera } from "@kitware/vtk.js/Rendering/Core/Camera";
+import { newInstance as vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
 
 interface DataItemLike {
   id: string;
 }
 
-// Vtk.js's plane-widget factory/handle/state objects (from ImplicitPlaneWidget, which ships no type declarations) are kept as `any` here - deep vtk.js widget internals with no typed surface to build on.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type PlaneWidget = any;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type WidgetHandle = any;
-
-interface WidgetEntry {
-  planeWidget: PlaneWidget;
-  widgetHandle: WidgetHandle;
-  subscription: { unsubscribe: () => void };
-}
-
 interface ClippingPlanesWidgetParams {
   planes: Ref<ClippingPlane[]>;
   targetAllVisible: Ref<boolean>;
   selectedDatasetIds: Ref<string[]>;
   allItems: Ref<DataItemLike[]>;
   hybridViewerStore: ReturnType<typeof useHybridViewerStore>;
-  debouncedApply: (...args: unknown[]) => void;
+  debouncedApply: (...args: readonly unknown[]) => void;
 }
 
-// oxlint-disable-next-line max-params max-lines-per-function
+// oxlint-disable-next-line max-params max-lines-per-function typescript/prefer-readonly-parameter-types -- Ref-backed params are inherently mutable through .value.
 function useClippingPlanesWidget({
   planes,
   targetAllVisible,
@@ -60,118 +40,48 @@ function useClippingPlanesWidget({
   allItems,
   hybridViewerStore,
   debouncedApply,
-}: ClippingPlanesWidgetParams) {
+}: ClippingPlanesWidgetParams): {
+  getSceneCenter: typeof getSceneCenter;
+  syncWidgets: typeof syncWidgets;
+  syncLocalCamera: typeof syncLocalCamera;
+  cleanupLocalWidget: typeof cleanupLocalWidget;
+  initLocalWidget: typeof initLocalWidget;
+  updateWidgetPlacement: typeof updateWidgetPlacement;
+  isFromWidget: typeof isFromWidget;
+  setFromWidget: typeof setFromWidget;
+} {
   let localRenderWindow: GenericRenderWindowInstance | undefined = undefined;
   let widgetManager: WidgetManagerInstance | undefined = undefined;
-  let widgetEntries: WidgetEntry[] = [];
-  let fromWidget = false;
   let maxDistance = 0;
   let isLimitingCameraZoom = false;
-  function resolveActiveActors(): vtkActor[] {
-    const targetIds = targetAllVisible.value
-      ? allItems.value.map((item) => item.id)
-      : selectedDatasetIds.value;
-    const targeted = targetIds
-      .map((id) => {
-        const item = hybridViewerStore.hybridDb[id];
-        return item ? item.actor : undefined;
-      })
-      .filter((actor): actor is vtkActor => Boolean(actor));
-    if (targeted.length > 0) {
-      return targeted;
-    }
-    return Object.values(hybridViewerStore.hybridDb)
-      .map((entry) => entry && entry.actor)
-      .filter((actor): actor is vtkActor => Boolean(actor));
-  }
-  function getSceneBoundsInfo() {
-    return computeSceneBoundsInfo(resolveActiveActors());
+  const widgetEntryManager = useWidgetEntryManager({ planes, debouncedApply });
+
+  function getSceneBoundsInfo(): SceneBoundsInfo {
+    return computeSceneBoundsInfo(
+      resolveActiveActors(
+        targetAllVisible.value,
+        allItems.value,
+        selectedDatasetIds.value,
+        hybridViewerStore.hybridDb,
+      ),
+    );
   }
-  function getSceneCenter(): number[] {
+  function getSceneCenter(): readonly number[] {
     return getSceneBoundsInfo().center;
   }
-  function createWidgetEntry(
-    planeWidget: PlaneWidget,
-    widgetHandle: WidgetHandle,
-    planeIndex: number,
-  ): WidgetEntry {
-    const widgetState = planeWidget.getWidgetState();
-    const plane = planes.value[planeIndex];
-    if (plane?.origin) {
-      widgetState.setOrigin(plane.origin);
-    }
-    if (plane) {
-      widgetState.setNormal(plane.normal);
-    }
-    const subscription = widgetState.onModified(() => {
-      if (fromWidget) {
-        return;
-      }
-      const origin: number[] = widgetState.getOrigin().map((val: number) => Number(val.toFixed(4)));
-      const normal: number[] = widgetState.getNormal().map((val: number) => Number(val.toFixed(4)));
-      const currentPlane = planes.value[planeIndex];
-      if (
-        !currentPlane ||
-        !hasPlaneChanged(origin, normal, currentPlane.origin, currentPlane.normal)
-      ) {
-        return;
-      }
-      fromWidget = true;
-      currentPlane.origin = origin;
-      currentPlane.normal = normal;
-      nextTick(() => {
-        fromWidget = false;
-      });
-      debouncedApply();
-    });
-    return {
-      planeWidget,
-      widgetHandle,
-      subscription,
-    };
-  }
+
   function syncWidgets(): void {
     if (!widgetManager || !localRenderWindow) {
       return;
     }
-    while (widgetEntries.length > planes.value.length) {
-      const entry = widgetEntries.pop();
-      if (!entry) {
-        continue;
-      }
-      entry.subscription.unsubscribe();
-      widgetManager.removeWidget(entry.planeWidget);
-      entry.planeWidget.delete();
-    }
+    widgetEntryManager.removeExtraWidgets(widgetManager);
     const { cubicBounds } = getSceneBoundsInfo();
     for (const [idx, plane] of planes.value.entries()) {
-      // Modulo guarantees this index is within bounds of the non-empty PLANE_COLORS array.
-      const rgb = PLANE_COLORS[idx % PLANE_COLORS.length]!;
-      if (!widgetEntries[idx]) {
-        const planeWidget = vtkImplicitPlaneWidget();
-        const widgetHandle = widgetManager.addWidget(planeWidget);
-        widgetHandle.setAxisScale(AXIS_SCALE);
-        widgetHandle.setHandleSizeRatio(SIZE_RATIO);
-        widgetEntries.push(createWidgetEntry(planeWidget, widgetHandle, idx));
-      }
-      const entry = widgetEntries[idx];
-      if (!entry) {
-        continue;
-      }
-      entry.widgetHandle.setRepresentationStyle(getPlaneStyle(rgb));
-      fromWidget = true;
-      entry.widgetHandle.placeWidget(cubicBounds);
-      fromWidget = false;
-      entry.widgetHandle.setAxisScale(AXIS_SCALE);
-      entry.widgetHandle.setHandleSizeRatio(SIZE_RATIO);
-      const widgetState = entry.planeWidget.getWidgetState();
-      if (plane.origin) {
-        widgetState.setOrigin(plane.origin);
-      }
-      widgetState.setNormal(plane.normal);
+      widgetEntryManager.updateWidgetEntry(idx, plane, cubicBounds, widgetManager);
     }
     localRenderWindow.getRenderWindow().render();
   }
+
   function limitCameraZoomOut(camera: vtkCamera): void {
     if (maxDistance <= 0 || isLimitingCameraZoom) {
       return;
@@ -192,65 +102,33 @@ function useClippingPlanesWidget({
     localRenderWindow?.getRenderWindow().render();
     isLimitingCameraZoom = false;
   }
-  // The `noUncheckedIndexedAccess` compiler option (needed elsewhere in this migration) forces every `focal_point[i]`/`position[i]`/`view_up[i]` access below into its own `?? 0` fallback branch, which is what pushes this pre-existing function's cyclomatic complexity over the limit - the control flow itself is unchanged from the plain-JS version.
-  // oxlint-disable-next-line complexity
+
   function syncLocalCamera(): void {
     if (!localRenderWindow) {
       return;
     }
     const renderer = localRenderWindow.getRenderer();
     const camera = renderer.getActiveCamera();
-    const mainCam = hybridViewerStore.camera_options as {
-      focal_point?: number[];
-      position?: number[];
-      view_up?: number[];
-    };
+    const mainCam = hybridViewerStore.camera_options as MainCameraOptions;
     const { center, cubicBounds } = getSceneBoundsInfo();
+    // oxlint-disable-next-line no-unsafe-type-assertion -- cubicBounds is always a 6-element bounds tuple.
     renderer.resetCamera(cubicBounds as [number, number, number, number, number, number]);
-    if (mainCam && mainCam.focal_point && mainCam.position) {
-      const { focal_point, position } = mainCam;
-      const dir = [
-        (position[0] ?? 0) - (focal_point[0] ?? 0),
-        (position[1] ?? 0) - (focal_point[1] ?? 0),
-        (position[2] ?? 0) - (focal_point[2] ?? 0),
-      ];
-      const dirLen = Math.hypot(...dir);
-      if (dirLen > 0) {
-        const distance = camera.getDistance();
-        const normDir = dir.map((component) => component / dirLen);
-        camera.setFocalPoint(center[0] ?? 0, center[1] ?? 0, center[2] ?? 0);
-        camera.setPosition(
-          (center[0] ?? 0) + (normDir[0] ?? 0) * distance,
-          (center[1] ?? 0) + (normDir[1] ?? 0) * distance,
-          (center[2] ?? 0) + (normDir[2] ?? 0) * distance,
-        );
-        if (mainCam.view_up) {
-          const [viewUpX = 0, viewUpY = 0, viewUpZ = 0] = mainCam.view_up;
-          camera.setViewUp(viewUpX, viewUpY, viewUpZ);
-        }
-      }
-    }
+    alignCameraToMainCamera(camera, mainCam, center);
     limitCameraZoomOut(camera);
     localRenderWindow.getRenderWindow().render();
   }
+
   function cleanupLocalWidget(): void {
     maxDistance = 0;
     isLimitingCameraZoom = false;
-    for (const entry of widgetEntries) {
-      entry.subscription.unsubscribe();
-      if (widgetManager) {
-        widgetManager.removeWidget(entry.planeWidget);
-      }
-      entry.planeWidget.delete();
-    }
-    widgetEntries = [];
+    widgetEntryManager.cleanupAll(widgetManager);
     if (localRenderWindow) {
       localRenderWindow.delete();
       localRenderWindow = undefined;
       widgetManager = undefined;
     }
   }
-  function updateWidgetPlacement({ isReset = false } = {}): void {
+  function updateWidgetPlacement({ isReset = false }: { isReset?: boolean } = {}): void {
     if (!widgetManager || !localRenderWindow) {
       return;
     }
@@ -272,20 +150,32 @@ function useClippingPlanesWidget({
 
   function initLocalWidget(container: HTMLElement): void {
     cleanupLocalWidget();
-    container.addEventListener("wheel", (event) => event.stopPropagation(), { passive: true });
+    container.addEventListener(
+      "wheel",
+      (event: WheelEvent) => {
+        event.stopPropagation();
+      },
+      { passive: true },
+    );
     localRenderWindow = vtkGenericRenderWindow({
       background: [0, 0, 0, 0],
       listenWindowResize: false,
     });
     localRenderWindow.setContainer(container);
     const camera = localRenderWindow.getRenderer().getActiveCamera();
-    camera.onModified(() => limitCameraZoomOut(camera));
-    const canvas = (
-      localRenderWindow.getApiSpecificRenderWindow() as unknown as {
-        getCanvas: () => HTMLCanvasElement;
-      }
-    ).getCanvas();
-    Object.assign(canvas.style, { width: "100%", height: "100%", background: "transparent" });
+    camera.onModified(() => {
+      limitCameraZoomOut(camera);
+    });
+    // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vtk.js OpenGL render window API boundary.
+    const openGLRenderWindow = localRenderWindow.getApiSpecificRenderWindow() as unknown as {
+      getCanvas: () => HTMLCanvasElement;
+    };
+    const canvas = openGLRenderWindow.getCanvas();
+    Object.assign(canvas.style, {
+      width: "100%",
+      height: "100%",
+      background: "transparent",
+    });
     localRenderWindow.resize();
     widgetManager = vtkWidgetManager();
     widgetManager.setRenderer(localRenderWindow.getRenderer());
@@ -293,11 +183,13 @@ function useClippingPlanesWidget({
   }
 
   function isFromWidget(): boolean {
-    return fromWidget;
+    return widgetEntryManager.isFromWidget();
   }
+
   function setFromWidget(value: boolean): void {
-    fromWidget = value;
+    widgetEntryManager.setFromWidget(value);
   }
+
   return {
     getSceneCenter,
     syncWidgets,

package/app/composables/clipping_planes_widget_entries.ts

@@ -0,0 +1,189 @@
+import {
+  AXIS_SCALE,
+  PLANE_COLORS,
+  SIZE_RATIO,
+  getPlaneStyle,
+  hasPlaneChanged,
+} from "@ogw_front/utils/clipping_planes";
+import type { vtkWidgetManager as WidgetManagerInstance } from "@kitware/vtk.js/Widgets/Core/WidgetManager";
+import type vtkAbstractWidget from "@kitware/vtk.js/Widgets/Core/AbstractWidget";
+import type vtkAbstractWidgetFactory from "@kitware/vtk.js/Widgets/Core/AbstractWidgetFactory";
+import { newInstance as vtkImplicitPlaneWidget } from "@kitware/vtk.js/Widgets/Widgets3D/ImplicitPlaneWidget";
+
+interface ClippingPlane {
+  origin?: number[];
+  normal: number[];
+}
+
+interface ClippingWidgetState {
+  getOrigin: () => number[];
+  setOrigin: (origin: readonly number[]) => void;
+  getNormal: () => number[];
+  setNormal: (normal: readonly number[]) => void;
+  onModified: (callback: () => void) => { unsubscribe: () => void };
+}
+
+interface PlaneWidget {
+  getWidgetState: () => ClippingWidgetState;
+  delete: () => void;
+}
+
+interface WidgetHandle {
+  setAxisScale: (scale: number) => void;
+  setHandleSizeRatio: (ratio: number) => void;
+  setRepresentationStyle: (style: unknown) => void;
+  placeWidget: (bounds: readonly number[]) => void;
+}
+
+interface WidgetEntry {
+  planeWidget: PlaneWidget;
+  widgetHandle: WidgetHandle;
+  subscription: { unsubscribe: () => void };
+}
+
+function asWidgetFactory(widget: PlaneWidget): vtkAbstractWidgetFactory<vtkAbstractWidget> {
+  // oxlint-disable-next-line no-unsafe-type-assertion -- vtk.js's WidgetManager APIs (addWidget/removeWidget) are untyped for our custom PlaneWidget shape; narrowed once here.
+  return widget as unknown as vtkAbstractWidgetFactory<vtkAbstractWidget>;
+}
+
+interface WidgetEntryManagerParams {
+  planes: Ref<ClippingPlane[]>;
+  debouncedApply: (...args: readonly unknown[]) => void;
+}
+
+// oxlint-disable-next-line max-lines-per-function typescript/prefer-readonly-parameter-types -- Ref-backed params are inherently mutable through .value.
+function useWidgetEntryManager({ planes, debouncedApply }: WidgetEntryManagerParams): {
+  removeExtraWidgets: (widgetManager: WidgetManagerInstance | undefined) => void;
+  updateWidgetEntry: (
+    idx: number,
+    plane: ClippingPlane,
+    cubicBounds: readonly number[],
+    widgetManager: WidgetManagerInstance,
+  ) => void;
+  cleanupAll: (widgetManager: WidgetManagerInstance | undefined) => void;
+  isFromWidget: () => boolean;
+  setFromWidget: (value: boolean) => void;
+} {
+  let widgetEntries: WidgetEntry[] = [];
+  let fromWidget = false;
+
+  function createWidgetEntry(
+    planeWidget: PlaneWidget,
+    widgetHandle: WidgetHandle,
+    planeIndex: number,
+  ): WidgetEntry {
+    const widgetState = planeWidget.getWidgetState();
+    const plane = planes.value[planeIndex];
+    if (plane?.origin) {
+      widgetState.setOrigin(plane.origin);
+    }
+    if (plane) {
+      widgetState.setNormal(plane.normal);
+    }
+    const subscription = widgetState.onModified(() => {
+      if (fromWidget) {
+        return;
+      }
+      const origin: number[] = widgetState.getOrigin().map((val: number) => Number(val.toFixed(4)));
+      const normal: number[] = widgetState.getNormal().map((val: number) => Number(val.toFixed(4)));
+      const currentPlane = planes.value[planeIndex];
+      if (
+        !currentPlane ||
+        !hasPlaneChanged(origin, normal, currentPlane.origin, currentPlane.normal)
+      ) {
+        return;
+      }
+      fromWidget = true;
+      currentPlane.origin = origin;
+      currentPlane.normal = normal;
+      nextTick(() => {
+        fromWidget = false;
+        // oxlint-disable-next-line promise/prefer-await-to-then -- fire-and-forget inside a sync widget callback; see codebase convention in global_attribute_style.ts.
+      }).catch(() => undefined);
+      debouncedApply();
+    });
+    return {
+      planeWidget,
+      widgetHandle,
+      subscription,
+    };
+  }
+
+  function removeExtraWidgets(widgetManager: WidgetManagerInstance | undefined): void {
+    while (widgetEntries.length > planes.value.length) {
+      const entry = widgetEntries.pop();
+      if (!entry) {
+        continue;
+      }
+      entry.subscription.unsubscribe();
+      widgetManager?.removeWidget(asWidgetFactory(entry.planeWidget));
+      entry.planeWidget.delete();
+    }
+  }
+
+  function updateWidgetEntry(
+    idx: number,
+    plane: ClippingPlane,
+    cubicBounds: readonly number[],
+    widgetManager: WidgetManagerInstance,
+  ): void {
+    // Modulo guarantees this index is within bounds of the non-empty PLANE_COLORS array.
+    const rgb = PLANE_COLORS[idx % PLANE_COLORS.length];
+    if (rgb === undefined) {
+      return;
+    }
+    if (!widgetEntries[idx]) {
+      // oxlint-disable-next-line no-unsafe-call no-unsafe-type-assertion -- vtk.js has no types for ImplicitPlaneWidget's factory; narrowed here.
+      const planeWidget = vtkImplicitPlaneWidget() as PlaneWidget;
+      const widgetHandle = widgetManager.addWidget(
+        asWidgetFactory(planeWidget),
+        // oxlint-disable-next-line no-unsafe-type-assertion -- vtk.js WidgetManager.addWidget is untyped for our custom WidgetHandle shape; narrowed here.
+      ) as unknown as WidgetHandle;
+      widgetEntries.push(createWidgetEntry(planeWidget, widgetHandle, idx));
+    }
+    const entry = widgetEntries[idx];
+    if (!entry) {
+      return;
+    }
+    entry.widgetHandle.setRepresentationStyle(getPlaneStyle(rgb));
+    fromWidget = true;
+    entry.widgetHandle.placeWidget(cubicBounds);
+    fromWidget = false;
+    entry.widgetHandle.setAxisScale(AXIS_SCALE);
+    entry.widgetHandle.setHandleSizeRatio(SIZE_RATIO);
+    const widgetState = entry.planeWidget.getWidgetState();
+    if (plane.origin) {
+      widgetState.setOrigin(plane.origin);
+    }
+    widgetState.setNormal(plane.normal);
+  }
+
+  function cleanupAll(widgetManager: WidgetManagerInstance | undefined): void {
+    for (const entry of widgetEntries) {
+      entry.subscription.unsubscribe();
+      if (widgetManager) {
+        widgetManager.removeWidget(asWidgetFactory(entry.planeWidget));
+      }
+      entry.planeWidget.delete();
+    }
+    widgetEntries = [];
+  }
+
+  function isFromWidget(): boolean {
+    return fromWidget;
+  }
+
+  function setFromWidget(value: boolean): void {
+    fromWidget = value;
+  }
+
+  return {
+    removeExtraWidgets,
+    updateWidgetEntry,
+    cleanupAll,
+    isFromWidget,
+    setFromWidget,
+  };
+}
+
+export { useWidgetEntryManager, type ClippingPlane };

package/app/composables/copy_to_clipboard.ts

@@ -0,0 +1,7 @@
+import { type UseClipboardReturn, useClipboard } from "@vueuse/core";
+
+const COPIED_FEEDBACK_TIMEOUT = 1500;
+
+export function useCopyToClipboard(): UseClipboardReturn<false> {
+  return useClipboard({ copiedDuring: COPIED_FEEDBACK_TIMEOUT });
+}