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

package/app/composables/clipping_planes_widget.js

@@ -1,249 +0,0 @@
-import {
-  AXIS_SCALE,
-  CHANGE_THRESHOLD,
-  PLANE_COLORS,
-  SIZE_RATIO,
-  computeSceneBoundsInfo,
-  getPlaneStyle,
-  hasPlaneChanged,
-} from "@ogw_front/utils/clipping_planes";
-import { newInstance as vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
-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 max-params max-lines-per-function
-function useClippingPlanesWidget({
-  planes,
-  targetAllVisible,
-  selectedDatasetIds,
-  allItems,
-  hybridViewerStore,
-  debouncedApply,
-}) {
-  let localRenderWindow = undefined;
-  let widgetManager = undefined;
-  let widgetEntries = [];
-  let fromWidget = false;
-  let maxDistance = 0;
-  let isLimitingCameraZoom = false;
-  function resolveActiveActors() {
-    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(Boolean);
-    if (targeted.length > 0) {
-      return targeted;
-    }
-    return Object.values(hybridViewerStore.hybridDb)
-      .map((entry) => entry && entry.actor)
-      .filter(Boolean);
-  }
-  function getSceneBoundsInfo() {
-    return computeSceneBoundsInfo(resolveActiveActors());
-  }
-  function getSceneCenter() {
-    return getSceneBoundsInfo().center;
-  }
-  function createWidgetEntry(planeWidget, widgetHandle, planeIndex) {
-    const widgetState = planeWidget.getWidgetState();
-    const plane = planes.value[planeIndex];
-    if (plane.origin) {
-      widgetState.setOrigin(plane.origin);
-    }
-    widgetState.setNormal(plane.normal);
-    const subscription = widgetState.onModified(() => {
-      if (fromWidget) {
-        return;
-      }
-      const origin = widgetState.getOrigin().map((val) => Number(val.toFixed(4)));
-      const normal = widgetState.getNormal().map((val) => Number(val.toFixed(4)));
-      if (
-        !hasPlaneChanged(
-          origin,
-          normal,
-          planes.value[planeIndex].origin,
-          planes.value[planeIndex].normal,
-        )
-      ) {
-        return;
-      }
-      fromWidget = true;
-      planes.value[planeIndex].origin = origin;
-      planes.value[planeIndex].normal = normal;
-      nextTick(() => {
-        fromWidget = false;
-      });
-      debouncedApply();
-    });
-    return {
-      planeWidget,
-      widgetHandle,
-      subscription,
-    };
-  }
-  function syncWidgets() {
-    if (!widgetManager || !localRenderWindow) {
-      return;
-    }
-    while (widgetEntries.length > planes.value.length) {
-      const entry = widgetEntries.pop();
-      entry.subscription.unsubscribe();
-      widgetManager.removeWidget(entry.planeWidget);
-      entry.planeWidget.delete();
-    }
-    const { cubicBounds } = getSceneBoundsInfo();
-    for (const [idx, plane] of planes.value.entries()) {
-      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];
-      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);
-    }
-    localRenderWindow.getRenderWindow().render();
-  }
-  function limitCameraZoomOut(camera) {
-    if (maxDistance <= 0 || isLimitingCameraZoom) {
-      return;
-    }
-    const currentDist = camera.getDistance();
-    if (currentDist <= maxDistance + CHANGE_THRESHOLD) {
-      return;
-    }
-    isLimitingCameraZoom = true;
-    const focal = camera.getFocalPoint();
-    const pos = camera.getPosition();
-    const ratio = maxDistance / currentDist;
-    camera.setPosition(
-      focal[0] + (pos[0] - focal[0]) * ratio,
-      focal[1] + (pos[1] - focal[1]) * ratio,
-      focal[2] + (pos[2] - focal[2]) * ratio,
-    );
-    localRenderWindow.getRenderWindow().render();
-    isLimitingCameraZoom = false;
-  }
-  function syncLocalCamera() {
-    if (!localRenderWindow) {
-      return;
-    }
-    const renderer = localRenderWindow.getRenderer();
-    const camera = renderer.getActiveCamera();
-    const mainCam = hybridViewerStore.camera_options;
-    const { center, cubicBounds } = getSceneBoundsInfo();
-    renderer.resetCamera(cubicBounds);
-    if (mainCam && mainCam.focal_point && mainCam.position) {
-      const dir = [
-        mainCam.position[0] - mainCam.focal_point[0],
-        mainCam.position[1] - mainCam.focal_point[1],
-        mainCam.position[2] - mainCam.focal_point[2],
-      ];
-      const dirLen = Math.hypot(...dir);
-      if (dirLen > 0) {
-        const distance = camera.getDistance();
-        const normDir = dir.map((component) => component / dirLen);
-        camera.setFocalPoint(...center);
-        camera.setPosition(
-          center[0] + normDir[0] * distance,
-          center[1] + normDir[1] * distance,
-          center[2] + normDir[2] * distance,
-        );
-        if (mainCam.view_up) {
-          camera.setViewUp(...mainCam.view_up);
-        }
-      }
-    }
-    limitCameraZoomOut(camera);
-    localRenderWindow.getRenderWindow().render();
-  }
-  function cleanupLocalWidget() {
-    maxDistance = 0;
-    isLimitingCameraZoom = false;
-    for (const entry of widgetEntries) {
-      entry.subscription.unsubscribe();
-      if (widgetManager) {
-        widgetManager.removeWidget(entry.planeWidget);
-      }
-      entry.planeWidget.delete();
-    }
-    widgetEntries = [];
-    if (localRenderWindow) {
-      localRenderWindow.delete();
-      localRenderWindow = undefined;
-      widgetManager = undefined;
-    }
-  }
-  function updateWidgetPlacement({ isReset = false } = {}) {
-    if (!widgetManager || !localRenderWindow) {
-      return;
-    }
-    if (isReset) {
-      maxDistance = 0;
-    }
-    const center = getSceneCenter();
-    for (const plane of planes.value) {
-      if (!plane.origin || isReset) {
-        plane.origin = [...center];
-      }
-    }
-    syncWidgets();
-    syncLocalCamera();
-    if (maxDistance <= 0) {
-      maxDistance = localRenderWindow.getRenderer().getActiveCamera().getDistance();
-    }
-  }
-
-  function initLocalWidget(container) {
-    cleanupLocalWidget();
-    container.addEventListener("wheel", (event) => 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().getCanvas();
-    Object.assign(canvas.style, { width: "100%", height: "100%", background: "transparent" });
-    localRenderWindow.resize();
-    widgetManager = vtkWidgetManager();
-    widgetManager.setRenderer(localRenderWindow.getRenderer());
-    updateWidgetPlacement();
-  }
-
-  function isFromWidget() {
-    return fromWidget;
-  }
-  function setFromWidget(value) {
-    fromWidget = value;
-  }
-  return {
-    getSceneCenter,
-    syncWidgets,
-    syncLocalCamera,
-    cleanupLocalWidget,
-    initLocalWidget,
-    updateWidgetPlacement,
-    isFromWidget,
-    setFromWidget,
-  };
-}
-export { useClippingPlanesWidget };

package/app/composables/global_attribute_style.js

@@ -1,181 +0,0 @@
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
-import { computed } from "vue";
-
-import { getAttributeRange } from "@ogw_front/utils/attributes";
-import { useBackStore } from "@ogw_front/stores/back";
-import { useDataStyleStore } from "@ogw_front/stores/data_style";
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
-
-export function useGlobalAttributeStyle(dataIdRef) {
-  const dataStyleStore = useDataStyleStore();
-  const hybridViewerStore = useHybridViewerStore();
-  const backStore = useBackStore();
-
-  const componentNames = [
-    { getterKey: "meshPoints", setterKey: "MeshPoints", key: "points" },
-    { getterKey: "meshEdges", setterKey: "MeshEdges", key: "edges" },
-    { getterKey: "meshPolygons", setterKey: "MeshPolygons", key: "polygons" },
-    { getterKey: "meshCells", setterKey: "MeshCells", key: "cells" },
-    { getterKey: "meshPolyhedra", setterKey: "MeshPolyhedra", key: "polyhedra" },
-  ];
-
-  function getActiveComponents(targetId) {
-    const style = dataStyleStore.getStyle(targetId);
-    const activeComponents = [];
-    if (!style) {
-      return activeComponents;
-    }
-    for (const { key, getterKey, setterKey } of componentNames) {
-      if (!style[key] || !style[key].coloring) {
-        continue;
-      }
-
-      const activeColoring = style[key].coloring.active;
-      if (!["vertex", "edge", "polygon", "cell", "polyhedron"].includes(activeColoring)) {
-        continue;
-      }
-
-      const attributeType = `${activeColoring.charAt(0).toUpperCase()}${activeColoring.slice(1)}Attribute`;
-      activeComponents.push({ activeColoring, attributeType, getterKey, setterKey });
-    }
-    return activeComponents;
-  }
-
-  const currentColormap = computed(() => {
-    const targetId = dataIdRef.value;
-    if (!targetId) {
-      return "batlow";
-    }
-
-    for (const comp of getActiveComponents(targetId)) {
-      const getterName = `${comp.getterKey}${comp.attributeType}ColorMap`;
-      const getter = dataStyleStore[getterName];
-      if (getter) {
-        const colorMap = getter(targetId);
-        if (colorMap) {
-          return colorMap;
-        }
-      }
-    }
-
-    return "batlow";
-  });
-
-  const currentRange = computed({
-    get() {
-      const targetId = dataIdRef.value;
-      if (!targetId) {
-        return [0, 1];
-      }
-
-      for (const comp of getActiveComponents(targetId)) {
-        const getterName = `${comp.getterKey}${comp.attributeType}Range`;
-        const getter = dataStyleStore[getterName];
-        if (getter) {
-          const range = getter(targetId);
-          if (range && range.length === 2) {
-            return range;
-          }
-        }
-      }
-      return [0, 1];
-    },
-    set(newValue) {
-      const targetId = dataIdRef.value;
-      if (!targetId) {
-        return;
-      }
-
-      let updated = false;
-      for (const comp of getActiveComponents(targetId)) {
-        const setterName = `set${comp.setterKey}${comp.attributeType}Range`;
-        const setter = dataStyleStore[setterName];
-        if (setter) {
-          setter(targetId, newValue[0], newValue[1]);
-          updated = true;
-        }
-      }
-      if (updated) {
-        hybridViewerStore.remoteRender();
-      }
-    },
-  });
-
-  async function applyGlobalColormap(newMap) {
-    const targetId = dataIdRef.value;
-    if (!targetId) {
-      return;
-    }
-
-    const promises = [];
-
-    for (const comp of getActiveComponents(targetId)) {
-      const setterName = `set${comp.setterKey}${comp.attributeType}ColorMap`;
-      const setter = dataStyleStore[setterName];
-
-      if (setter) {
-        promises.push(setter(targetId, newMap));
-      }
-    }
-
-    await Promise.all(promises);
-    hybridViewerStore.remoteRender();
-  }
-
-  function resetGlobalRange() {
-    const targetId = dataIdRef.value;
-    if (!targetId) {
-      return;
-    }
-
-    for (const comp of getActiveComponents(targetId)) {
-      const { activeColoring, attributeType, getterKey, setterKey } = comp;
-
-      const nameGetter = dataStyleStore[`${getterKey}${attributeType}Name`];
-      const itemGetter = dataStyleStore[`${getterKey}${attributeType}Item`];
-      if (!nameGetter || !itemGetter) {
-        continue;
-      }
-
-      const attrName = nameGetter(targetId);
-      const attrItem = itemGetter(targetId) ?? 0;
-
-      if (!attrName) {
-        continue;
-      }
-
-      const schemaName = `${activeColoring}_attribute_names`;
-      const schema = back_schemas.opengeodeweb_back[schemaName];
-      if (!schema) {
-        continue;
-      }
-
-      backStore.request(
-        { schema, params: { id: targetId } },
-        {
-          response_function: (response) => {
-            const attributes = response.attributes || [];
-            const currentAttribute = attributes.find((attr) => attr.attribute_name === attrName);
-            if (currentAttribute) {
-              const { min, max } = getAttributeRange(currentAttribute, attrItem);
-
-              const setterName = `set${setterKey}${attributeType}Range`;
-              const setter = dataStyleStore[setterName];
-              if (setter) {
-                setter(targetId, min, max);
-                hybridViewerStore.remoteRender();
-              }
-            }
-          },
-        },
-      );
-    }
-  }
-
-  return {
-    currentColormap,
-    currentRange,
-    applyGlobalColormap,
-    resetGlobalRange,
-  };
-}

package/app/composables/hover_highlight.js

@@ -1,91 +0,0 @@
-import { useDataStore } from "@ogw_front/stores/data";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-import vtk_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-const HOVER_DELAY = 200;
-
-export function useHoverhighlight() {
-  const viewerStore = useViewerStore();
-  const dataStore = useDataStore();
-  let timer = undefined;
-  let currentId = undefined;
-  let currentType = undefined;
-
-  function onHoverEnter(id, block_ids_provider = [], type = "model", immediate = false) {
-    if (timer) {
-      clearTimeout(timer);
-      timer = undefined;
-    }
-    const schema = vtk_schemas.opengeodeweb_viewer[type].highlight;
-
-    async function highlightAction() {
-      currentId = id;
-      currentType = type;
-
-      if (!(await dataStore.isItemViewable(id))) {
-        return;
-      }
-
-      let block_ids = [];
-      if (typeof block_ids_provider === "function") {
-        block_ids = await block_ids_provider();
-      } else {
-        block_ids = block_ids_provider;
-      }
-
-      block_ids = (Array.isArray(block_ids) ? block_ids : [])
-        .map((blockId) => Math.trunc(Number(blockId)))
-        .filter((blockId) => !Number.isNaN(blockId));
-
-      if (currentId !== id) {
-        return;
-      }
-
-      const params = {
-        id,
-        visibility: true,
-        ...(type === "model" && { block_ids }),
-      };
-      try {
-        await viewerStore.request({ schema, params });
-      } catch (error) {
-        console.error(`Highlight failed for ${type} ${id}:`, error);
-      }
-    }
-
-    if (immediate) {
-      highlightAction();
-    } else {
-      timer = setTimeout(highlightAction, HOVER_DELAY);
-    }
-  }
-
-  function onHoverLeave(id) {
-    if (timer) {
-      clearTimeout(timer);
-      timer = undefined;
-    }
-    if (currentId === id) {
-      const schema = vtk_schemas.opengeodeweb_viewer[currentType].highlight;
-      const params = {
-        id,
-        visibility: false,
-        ...(currentType === "model" && { block_ids: [] }),
-      };
-      try {
-        viewerStore.request({ schema, params });
-      } catch (error) {
-        console.error(`Unhighlight failed for ${currentType} ${id}:`, error);
-      }
-      currentId = undefined;
-      currentType = undefined;
-    }
-
-    if (!currentId) {
-      currentId = undefined;
-      currentType = undefined;
-    }
-  }
-
-  return { onHoverEnter, onHoverLeave };
-}

package/app/composables/responsive_middle_truncate.js

@@ -1,34 +0,0 @@
-import { middleTruncate } from "@ogw_front/utils/string";
-
-const UUID_END_CHARS = 12;
-const ELLIPSIS_LENGTH = 3;
-const MIN_START_CHARS = 4;
-const DEFAULT_ESTIMATED_CHAR_WIDTH = 8.5;
-
-export function useResponsiveMiddleTruncate(textRef, containerWidthRef, options = {}) {
-  const {
-    estimatedCharWidth = DEFAULT_ESTIMATED_CHAR_WIDTH,
-    uuidEndChars = UUID_END_CHARS,
-    ellipsisLength = ELLIPSIS_LENGTH,
-    minStartChars = MIN_START_CHARS,
-  } = options;
-
-  return computed(() => {
-    const text = toValue(textRef);
-    if (!text) {
-      return "";
-    }
-
-    const width = toValue(containerWidthRef) || 0;
-    const maxChars = Math.floor(width / estimatedCharWidth);
-
-    if (maxChars <= 0 || text.length <= maxChars) {
-      return text;
-    }
-
-    const endChars = Math.min(uuidEndChars, Math.floor(maxChars / ellipsisLength));
-    const startChars = Math.max(minStartChars, maxChars - endChars - ellipsisLength);
-
-    return middleTruncate(text, maxChars, startChars, endChars);
-  });
-}

package/app/composables/stepper_tree.js

@@ -1,56 +0,0 @@
-export function useStepperTree(steps, initial_state = {}) {
-  const initial_state_unref = {};
-  for (const [key, value] of Object.entries(initial_state)) {
-    const unref_val = unref(value);
-    if (Array.isArray(unref_val)) {
-      initial_state_unref[key] = [...unref_val];
-    } else {
-      initial_state_unref[key] = unref_val;
-    }
-  }
-  const state = reactive({
-    current_step_index: 0,
-    navigating_back: false,
-    steps,
-    ...initial_state,
-  });
-
-  watch(
-    () => state.current_step_index,
-    (newVal, oldVal) => {
-      if (newVal < oldVal) {
-        state.navigating_back = true;
-      }
-    },
-  );
-
-  function update_values(keys_values_object) {
-    for (const [key, value] of Object.entries(keys_values_object)) {
-      state[key] = value;
-    }
-  }
-
-  function increment_step() {
-    state.current_step_index += 1;
-  }
-
-  function decrement_step() {
-    state.current_step_index -= 1;
-  }
-
-  function reset_values() {
-    state.current_step_index = 0;
-    state.navigating_back = false;
-    for (const [key, initial_val] of Object.entries(initial_state_unref)) {
-      state[key] = Array.isArray(initial_val) ? [...initial_val] : initial_val;
-    }
-  }
-
-  return {
-    state,
-    update_values,
-    increment_step,
-    decrement_step,
-    reset_values,
-  };
-}