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

package/app/composables/use_adaptive_styles.ts

@@ -1,3 +1,4 @@
+import type { MaybeComputedElementRef } from "@vueuse/core";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useTreeviewStore } from "@ogw_front/stores/treeview";
 
@@ -29,45 +30,72 @@ interface CoordinatesLike {
   height?: unknown;
 }
 
+interface RefLike {
+  value?: unknown;
+  x?: unknown;
+}
+
+function isRefLike(value: unknown): value is RefLike {
+  return typeof value === "object" && value !== null;
+}
+
+function isCoordinatesGetter(value: unknown): value is () => CoordinatesLike | undefined {
+  return typeof value === "function";
+}
+
+function isCoordinatesLike(value: unknown): value is CoordinatesLike {
+  return typeof value === "object" && value !== null;
+}
+
 function getValue(val: unknown): number {
   if (typeof val === "object" && val !== null && "value" in val) {
     const wrapped = (val as { value?: unknown }).value;
-    if (wrapped !== undefined) {
-      return wrapped as number;
+    if (typeof wrapped === "number") {
+      return wrapped;
     }
   }
-  return (val as number | undefined) ?? 0;
+  return typeof val === "number" ? val : 0;
 }
 
 // oxlint-disable max-lines-per-function
 export function useAdaptiveStyles(
   target: AdaptiveStylesTarget,
   options: AdaptiveStylesOptions = {},
-) {
+): {
+  adaptiveStyles: ComputedRef<{
+    "--adaptive-blur": string;
+    "--adaptive-opacity": number;
+    "--adaptive-brightness": number;
+  }>;
+  brightness: Ref<number>;
+} {
   const hybridViewerStore = useHybridViewerStore();
   const treeviewStore = useTreeviewStore();
 
-  const targetAsRefLike = target as { value?: unknown; x?: unknown } | undefined;
-  const isCoordinates = Boolean(
-    target &&
+  const targetAsRefLike = isRefLike(target) ? target : undefined;
+  const isCoordinates =
+    target !== undefined &&
+    target !== null &&
     (typeof target === "function" ||
       (targetAsRefLike?.value !== undefined &&
         targetAsRefLike.value !== null &&
         (targetAsRefLike.value as { x?: unknown }).x !== undefined) ||
-      (targetAsRefLike?.x !== undefined && targetAsRefLike.value === undefined)),
-  );
+      (targetAsRefLike?.x !== undefined && targetAsRefLike.value === undefined));
 
-  const bounding = useElementBounding(isCoordinates ? undefined : (target as never));
+  const bounding = useElementBounding(
+    // oxlint-disable-next-line no-unsafe-type-assertion -- duck-typed target; see comment above.
+    isCoordinates ? undefined : (target as MaybeComputedElementRef),
+  );
 
   const unwrapped = computed(() => {
     if (isCoordinates) {
       let val: CoordinatesLike | undefined = undefined;
-      if (typeof target === "function") {
-        val = (target as () => CoordinatesLike | undefined)();
+      if (isCoordinatesGetter(target)) {
+        val = target();
       } else if (targetAsRefLike?.value === undefined) {
         val = targetAsRefLike;
-      } else {
-        val = targetAsRefLike.value as CoordinatesLike | undefined;
+      } else if (isCoordinatesLike(targetAsRefLike.value)) {
+        val = targetAsRefLike.value;
       }
       return {
         x: getValue(val?.x),
@@ -91,7 +119,7 @@ export function useAdaptiveStyles(
 
   const brightness = ref(LUMINANCE_THRESHOLD);
 
-  function calculateBrightness() {
+  function calculateBrightness(): void {
     brightness.value = hybridViewerStore.getAverageBrightness({
       x: x.value,
       y: y.value,
@@ -100,21 +128,36 @@ export function useAdaptiveStyles(
     });
   }
 
-  const updateBrightness = useThrottleFn(calculateBrightness, ADAPTIVE_REFRESH_RATE);
-
-  watch([x, y, width, height, () => hybridViewerStore.latestImage], updateBrightness, {
-    immediate: true,
-  });
+  // Trailing call so the last image of a burst is always sampled; otherwise the final opacity depends on image timing
+  const updateBrightness = useThrottleFn(calculateBrightness, ADAPTIVE_REFRESH_RATE, true);
+
+  watch(
+    [
+      x,
+      y,
+      width,
+      height,
+      (): typeof hybridViewerStore.latestImage => hybridViewerStore.latestImage,
+    ],
+    updateBrightness,
+    {
+      immediate: true,
+    },
+  );
 
-  async function forceRefresh() {
+  async function forceRefresh(): Promise<void> {
     await nextTick();
     bounding.update?.();
     calculateBrightness();
   }
 
   if (getCurrentInstance()) {
-    onMounted(() => {
-      forceRefresh();
+    onMounted(async () => {
+      try {
+        await forceRefresh();
+      } catch (error) {
+        console.error("forceRefresh failed:", error);
+      }
     });
   }
 

package/app/composables/use_overlapping_picker.ts

@@ -1,17 +1,18 @@
 import { ref } from "vue";
-import { useDataStore } from "@ogw_front/stores/data";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+import { type DataItem, useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 interface PickedItem {
   id: string;
-  viewer_id: number;
+  viewer_id: number | undefined;
 }
 
 interface ProposedItem {
   id: string;
-  viewer_id: number;
+  viewer_id: number | undefined;
   name: string;
   viewer_type: string | undefined;
   geode_object_type: string | undefined;
@@ -19,7 +20,7 @@ interface ProposedItem {
 
 interface PickedResponse {
   array_ids: string[];
-  viewer_id: number;
+  viewer_id: number | null;
   picked_data?: PickedItem[];
 }
 
@@ -36,7 +37,55 @@ interface GetViewerIdParams {
   containerRect: { left: number; top: number };
 }
 
-export function useOverlappingPicker() {
+interface UseOverlappingPickerReturn {
+  displayIntermediate: Ref<boolean>;
+  intermediateItems: Ref<ProposedItem[]>;
+  intermediateMenuX: Ref<number>;
+  intermediateMenuY: Ref<number>;
+  getIntermediateMenuStyle: () => { position: string; left: string; top: string };
+  selectIntermediateItem: (item: ProposedItem | undefined) => void;
+  handleIntermediateMenuUpdate: (val: boolean) => void;
+  get_viewer_id: (params: GetViewerIdParams) => Promise<ViewerIdResult>;
+}
+
+function isPickedItem(entry: unknown): entry is PickedItem {
+  return (
+    typeof entry === "object" &&
+    entry !== null &&
+    "id" in entry &&
+    typeof entry.id === "string" &&
+    (!("viewer_id" in entry) ||
+      entry.viewer_id === undefined ||
+      typeof entry.viewer_id === "number")
+  );
+}
+
+function isPickedItemArray(value: unknown): value is PickedItem[] {
+  return Array.isArray(value) && value.every((entry) => isPickedItem(entry));
+}
+
+function isPickedResponse(value: unknown): value is PickedResponse {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("array_ids" in value) || !("viewer_id" in value)) {
+    return false;
+  }
+  const { array_ids, viewer_id } = value;
+  if (
+    !Array.isArray(array_ids) ||
+    !array_ids.every((entry) => typeof entry === "string") ||
+    (typeof viewer_id !== "number" && viewer_id !== null)
+  ) {
+    return false;
+  }
+  if ("picked_data" in value) {
+    return value.picked_data === undefined || isPickedItemArray(value.picked_data);
+  }
+  return true;
+}
+
+export function useOverlappingPicker(): UseOverlappingPickerReturn {
   const dataStore = useDataStore();
   const dataStyleStore = useDataStyleStore();
   const viewerStore = useViewerStore();
@@ -48,9 +97,9 @@ export function useOverlappingPicker() {
   const intermediateMenuY = ref(0);
   let resolveIntermediate: ((item: ProposedItem | undefined) => void) | undefined = undefined;
 
-  function fetchProposedItems(pickedList: PickedItem[]): Promise<ProposedItem[]> {
-    return Promise.all(
-      pickedList.map(async (pick) => {
+  async function fetchProposedItems(pickedList: readonly PickedItem[]): Promise<ProposedItem[]> {
+    const proposedItems = await Promise.all(
+      pickedList.map(async (pick: PickedItem) => {
         try {
           const item = await dataStore.item(pick.id);
           return {
@@ -71,9 +120,10 @@ export function useOverlappingPicker() {
         }
       }),
     );
+    return proposedItems;
   }
 
-  function getIntermediateMenuStyle() {
+  function getIntermediateMenuStyle(): { position: string; left: string; top: string } {
     return {
       position: "fixed",
       left: `${intermediateMenuX.value}px`,
@@ -102,9 +152,9 @@ export function useOverlappingPicker() {
     containerHeight,
     containerRect,
   }: GetViewerIdParams): Promise<ViewerIdResult> {
-    const activeIds = new Set(dataItems.value.map((i) => i.id));
+    const activeIds = new Set(dataItems.value.map((i: DataItem) => i.id));
     const visibleStyleIds = Object.keys(dataStyleStore.styles).filter(
-      (styleId) => activeIds.has(styleId) && dataStyleStore.objectVisibility(styleId),
+      (styleId) => activeIds.has(styleId) && dataStyleStore.objectVisibility(styleId) === true,
     );
 
     const viewableChecks = await Promise.all(
@@ -134,13 +184,13 @@ export function useOverlappingPicker() {
       },
       {
         response_function: (response: unknown) => {
-          responseHolder.pickedResponse = response as PickedResponse;
+          responseHolder.pickedResponse = isPickedResponse(response) ? response : undefined;
         },
       },
     );
     const { pickedResponse } = responseHolder;
 
-    if (!pickedResponse || !pickedResponse.array_ids || pickedResponse.array_ids.length === 0) {
+    if (!pickedResponse || pickedResponse.array_ids.length === 0) {
       return result;
     }
 
@@ -151,7 +201,7 @@ export function useOverlappingPicker() {
       pickedList.push(...picked_data);
     } else {
       for (const pickId of array_ids) {
-        pickedList.push({ id: pickId, viewer_id });
+        pickedList.push({ id: pickId, viewer_id: viewer_id ?? undefined });
       }
     }
 
@@ -189,7 +239,7 @@ export function useOverlappingPicker() {
 
     /* eslint-disable-next-line promise/avoid-new */
     return new Promise<ViewerIdResult>((resolve) => {
-      resolveIntermediate = (chosenResult) => {
+      resolveIntermediate = (chosenResult: ProposedItem | undefined): void => {
         displayIntermediate.value = false;
         resolve(
           chosenResult

package/app/composables/use_quick_colormap.ts

@@ -1,7 +1,20 @@
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-export function useQuickColormap() {
+// Runtime guard for the unknown response of viewerStore.request(), used instead of an
+// `as` cast so the shape is actually verified (data_id, when present, must be a string).
+function isPickColormapResult(value: unknown): value is { data_id?: string } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (!("data_id" in value) || typeof value.data_id === "string")
+  );
+}
+
+export function useQuickColormap(): {
+  pickColormap: typeof pickColormap;
+  quickColormap: typeof quickColormap;
+} {
   const viewerStore = useViewerStore();
   const quickColormap = reactive<{
     data_id: string | undefined;
@@ -24,10 +37,8 @@ export function useQuickColormap() {
     try {
       const schema = viewer_schemas.opengeodeweb_viewer.viewer.pick_colormap;
       const params = { x: offsetX, y: offsetY };
-      const result = (await viewerStore.request({ schema, params })) as
-        | { data_id?: string }
-        | undefined;
-      if (result && result.data_id) {
+      const result = await viewerStore.request({ schema, params });
+      if (isPickColormapResult(result) && result.data_id !== undefined && result.data_id !== "") {
         quickColormap.data_id = result.data_id;
         quickColormap.x = clientX;
         quickColormap.y = clientY;

package/app/composables/virtual_tree.ts

@@ -1,4 +1,7 @@
-import type { MaybeRefOrGetter } from "vue";
+import type { Ref } from "vue";
+
+// Same shape as Vue's MaybeRefOrGetter<T>, kept as a local alias for readability at call sites.
+type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
 
 type TreeItem = Record<string, unknown>;
 
@@ -17,14 +20,14 @@ interface SelectionConfig {
 }
 
 interface VirtualTreeProps {
-  items?: TreeItem[];
-  opened?: unknown[];
-  selected?: unknown[];
-  active?: unknown[];
-  itemProps?: Partial<ItemPropsConfig>;
-  selection?: Partial<SelectionConfig>;
-  search?: string;
-  customFilter?: (id: unknown, search: string, context: { raw: TreeItem }) => boolean;
+  readonly items?: readonly TreeItem[];
+  readonly opened?: readonly unknown[];
+  readonly selected?: readonly unknown[];
+  readonly active?: readonly unknown[];
+  readonly itemProps?: Partial<ItemPropsConfig>;
+  readonly selection?: Partial<SelectionConfig>;
+  readonly search?: string;
+  readonly customFilter?: (id: unknown, search: string, context: { raw: TreeItem }) => boolean;
 }
 
 interface DisplayItem {
@@ -36,9 +39,39 @@ interface DisplayItem {
   isLeaf: boolean;
 }
 
-type EmitFn = (event: string, ...args: unknown[]) => void;
+type EmitFn = (event: string, ...args: readonly unknown[]) => void;
+
+interface UseVirtualTreeReturn {
+  actualItemProps: ComputedRef<ItemPropsConfig>;
+  actualSelection: ComputedRef<SelectionConfig>;
+  displayItems: ComputedRef<DisplayItem[]>;
+  toggleOpen: (item: TreeItem) => void;
+  toggleSelect: (item: TreeItem) => void;
+  isSelected: (item: TreeItem) => boolean;
+  getIndeterminate: (item: TreeItem) => boolean;
+}
+
+// Real runtime check (rather than an `as TreeItem[]` cast) for the duck-typed "children" field:
+// Item shapes vary across callers (treeview groups, model component/collection groups, ...), so
+// This only verifies it is actually an array, same as the assumption the old cast silently made.
+function isTreeItemArray(value: unknown): value is TreeItem[] {
+  return Array.isArray(value);
+}
+
+// Extracted so we never call String() directly on a value typed as `unknown` (ids and titles can
+// Be anything at runtime): only stringify primitives that have a sane toString, and fall back to
+// "" for anything else instead of risking "[object Object]".
+function toDisplayString(value: unknown): string {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
 
-function useVirtualTree(propsIn: MaybeRefOrGetter<VirtualTreeProps>, emit: EmitFn) {
+function useVirtualTree(
+  propsIn: ReadonlyMaybeRefOrGetter<VirtualTreeProps>,
+  emit: EmitFn,
+): UseVirtualTreeReturn {
   const props = toRef(propsIn);
 
   const actualItemProps = computed<ItemPropsConfig>(() => ({
@@ -57,7 +90,7 @@ function useVirtualTree(propsIn: MaybeRefOrGetter<VirtualTreeProps>, emit: EmitF
 
   const openedSet = computed(() => new Set(props.value.opened));
   const selectedSet = computed(() => new Set(props.value.selected));
-  const activeSet = computed(() => new Set(props.value.active || []));
+  const activeSet = computed(() => new Set(props.value.active));
 
   function toggleOpen(item: TreeItem): void {
     const id = item[actualItemProps.value.value];
@@ -71,16 +104,17 @@ function useVirtualTree(propsIn: MaybeRefOrGetter<VirtualTreeProps>, emit: EmitF
     emit("update:opened", [...newOpened]);
   }
 
-  function getLeafChildrenIds(item: TreeItem, ids: unknown[] = []): unknown[] {
-    const children = item[actualItemProps.value.children] as TreeItem[] | undefined;
+  function getChildrenOf(item: TreeItem): TreeItem[] | undefined {
+    const rawChildren = item[actualItemProps.value.children];
+    return isTreeItemArray(rawChildren) ? rawChildren : undefined;
+  }
+
+  function getLeafChildrenIds(item: TreeItem): unknown[] {
+    const children = getChildrenOf(item);
     if (children) {
-      for (const child of children) {
-        getLeafChildrenIds(child, ids);
-      }
-    } else {
-      ids.push(item[actualItemProps.value.value]);
+      return children.flatMap((child) => getLeafChildrenIds(child));
     }
-    return ids;
+    return [item[actualItemProps.value.value]];
   }
 
   function isSelected(item: TreeItem): boolean {
@@ -137,32 +171,28 @@ function useVirtualTree(propsIn: MaybeRefOrGetter<VirtualTreeProps>, emit: EmitF
     emit("update:selected", [...newSelected]);
   }
 
-  function flattenTree(
-    itemsList: TreeItem[],
-    depth = 0,
-    result: DisplayItem[] = [],
-  ): DisplayItem[] {
+  function flattenTree(itemsList: readonly TreeItem[], depth = 0): DisplayItem[] {
     const { search, customFilter } = props.value;
-    const lowerSearch = search ? search.toLowerCase() : "";
+    const result: DisplayItem[] = [];
 
     for (const item of itemsList) {
       const id = item[actualItemProps.value.value];
-      const children = item[actualItemProps.value.children] as TreeItem[] | undefined;
+      const children = getChildrenOf(item);
       const hasChildren = Boolean(children && children.length > 0);
 
       const isOpen = openedSet.value.has(id);
       const isActive = activeSet.value.has(id);
 
-      if (lowerSearch) {
+      if (search !== undefined && search !== "") {
+        const lowerSearch = search.toLowerCase();
         const matches = customFilter
-          ? customFilter(id, search as string, { raw: item })
-          : String(item[actualItemProps.value.title] ?? "")
+          ? customFilter(id, search, { raw: item })
+          : toDisplayString(item[actualItemProps.value.title])
               .toLowerCase()
-              .includes(lowerSearch) || String(id).toLowerCase().includes(lowerSearch);
+              .includes(lowerSearch) || toDisplayString(id).toLowerCase().includes(lowerSearch);
 
         if (hasChildren) {
-          const subtree: DisplayItem[] = [];
-          flattenTree(children ?? [], depth + 1, subtree);
+          const subtree = flattenTree(children ?? [], depth + 1);
           if (subtree.length === 0 && !matches) {
             continue;
           }
@@ -195,31 +225,33 @@ function useVirtualTree(propsIn: MaybeRefOrGetter<VirtualTreeProps>, emit: EmitF
       });
 
       if (isOpen && hasChildren) {
-        flattenTree(children ?? [], depth + 1, result);
+        result.push(...flattenTree(children ?? [], depth + 1));
       }
     }
     return result;
   }
 
-  function traverse(itemsList: TreeItem[], allIds: unknown[]): void {
+  function collectNonLeafIds(itemsList: readonly TreeItem[]): unknown[] {
+    const allIds: unknown[] = [];
     for (const item of itemsList) {
-      const children = item[actualItemProps.value.children] as TreeItem[] | undefined;
+      const children = getChildrenOf(item);
       if (children && children.length > 0) {
-        allIds.push(item[actualItemProps.value.value]);
-        traverse(children, allIds);
+        allIds.push(item[actualItemProps.value.value], ...collectNonLeafIds(children));
       }
     }
+    return allIds;
   }
 
-  const displayItems = computed(() => flattenTree(props.value.items || []));
+  const displayItems = computed(() => flattenTree(props.value.items ?? []));
 
   watch(
     () => props.value.search,
     (newSearch, oldSearch) => {
-      if (newSearch && !oldSearch) {
-        const allIds: unknown[] = [];
-        traverse(props.value.items || [], allIds);
-        emit("update:opened", [...new Set([...(props.value.opened || []), ...allIds])]);
+      const hasNewSearch = newSearch !== undefined && newSearch !== "";
+      const hadOldSearch = oldSearch !== undefined && oldSearch !== "";
+      if (hasNewSearch && !hadOldSearch) {
+        const allIds = collectNonLeafIds(props.value.items ?? []);
+        emit("update:opened", [...new Set([...(props.value.opened ?? []), ...allIds])]);
       }
     },
   );

package/app/composables/vtk_implicit_plane_widget.d.ts

@@ -0,0 +1,2 @@
+// Vtk.js does not ship type declarations for this widget module.
+declare module "@kitware/vtk.js/Widgets/Widgets3D/ImplicitPlaneWidget";

package/app/plugins/auto_store_register.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 { useAppStore } from "@ogw_front/stores/app";
 import type { PiniaPluginContext } from "pinia";
+import { useAppStore } from "@ogw_front/stores/app";
 
 function autoStoreRegister({ store }: PiniaPluginContext): void {
   if (store.$id === "app") {
@@ -10,7 +8,6 @@ function autoStoreRegister({ store }: PiniaPluginContext): void {
 
   const appStore = useAppStore();
   appStore.registerStore(store);
-  console.log(`[AutoRegister] Store "${store.$id}" processed`);
 }
 
 export default defineNuxtPlugin({
@@ -18,12 +15,10 @@ export default defineNuxtPlugin({
   dependsOn: ["pinia"],
   setup(nuxtApp) {
     const { $pinia } = nuxtApp;
-    if (!$pinia) {
-      console.warn("Pinia instance not available.");
+    if ($pinia === undefined) {
       return;
     }
 
     $pinia.use(autoStoreRegister);
-    console.log("[AUTOREGISTER PLUGIN] Loaded automatically from OpenGeodeWeb-Front");
   },
 });

package/app/plugins/click_outside_ignore_snackbars.client.ts

@@ -0,0 +1,39 @@
+import { ClickOutside } from "vuetify/directives/click-outside";
+import type { DirectiveBinding } from "vue";
+
+type ClickOutsideValue =
+  | ((event: MouseEvent) => void)
+  | {
+      handler: (event: MouseEvent) => void;
+      closeConditional?: (event: Event) => boolean;
+      include?: () => HTMLElement[];
+    };
+
+function snackbarElements(): HTMLElement[] {
+  return [...document.querySelectorAll<HTMLElement>(".v-snackbar")];
+}
+
+export default defineNuxtPlugin({
+  name: "click-outside-ignore-snackbars",
+  setup() {
+    const originalMounted = ClickOutside.mounted.bind(ClickOutside);
+
+    ClickOutside.mounted = (
+      element: HTMLElement,
+      binding: DirectiveBinding<ClickOutsideValue>,
+    ): void => {
+      const { value } = binding;
+      const handler = typeof value === "function" ? value : value.handler;
+      const closeConditional = typeof value === "function" ? undefined : value.closeConditional;
+      const include = typeof value === "function" ? undefined : value.include;
+
+      binding.value = {
+        handler,
+        closeConditional,
+        include: (): HTMLElement[] => [...(include?.() ?? []), ...snackbarElements()],
+      };
+
+      originalMounted(element, binding);
+    };
+  },
+});