@geode/opengeodeweb-front 10.37.0 → 10.38.0-rc.1

package/app/composables/viewer_context_menu.ts

@@ -0,0 +1,123 @@
+import { type MenuMetaData, useMenuStore } from "@ogw_front/stores/menu";
+import type { Ref, ShallowRef } from "vue";
+import type { TreeMenuPayload } from "@ogw_front/utils/treeview";
+import type { ViewerIdResult } from "@ogw_front/composables/use_overlapping_picker";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useElementSize } from "@vueuse/core";
+
+interface ViewerUIExposed {
+  get_viewer_id: (x: number, y: number) => Promise<ViewerIdResult>;
+}
+
+interface MenuTarget {
+  id: string;
+  meta_data: MenuMetaData;
+}
+
+async function treeMenuTarget(
+  dataStore: ReturnType<typeof useDataStore>,
+  payload: TreeMenuPayload,
+): Promise<MenuTarget | undefined> {
+  if (payload.context_type === "geode_object_type") {
+    const [referenceId] = payload.targetIds;
+    if (referenceId === undefined) {
+      return undefined;
+    }
+    const referenceItem = await dataStore.item(referenceId);
+    return { id: referenceId, meta_data: { ...referenceItem, targetIds: payload.targetIds } };
+  }
+  if (payload.context_type === "model_component") {
+    return {
+      id: payload.itemId,
+      meta_data: {
+        viewer_type: "model_component",
+        geode_object_type: "component",
+        modelId: payload.modelId,
+        pickedComponentId: payload.itemId,
+      },
+    };
+  }
+  if (payload.context_type === "model_component_type") {
+    return {
+      id: payload.itemId,
+      meta_data: {
+        viewer_type: "model_component_type",
+        geode_object_type: "type",
+        modelId: payload.modelId,
+        modelComponentType: payload.modelComponentType,
+        targetComponentIds: payload.targetComponentIds,
+      },
+    };
+  }
+  return { id: payload.itemId, meta_data: { ...(await dataStore.item(payload.itemId)) } };
+}
+
+async function viewerMenuTarget(
+  dataStore: ReturnType<typeof useDataStore>,
+  pickedId: string,
+  viewer_id: number | undefined,
+): Promise<MenuTarget> {
+  const item = await dataStore.item(pickedId);
+  const meta_data: MenuMetaData = { ...item };
+  if (item.viewer_type === "model" && viewer_id !== undefined) {
+    const component = await dataStore.getComponentByViewerId(pickedId, viewer_id);
+    if (component) {
+      meta_data.pickedComponentId = component.geode_id;
+    }
+  }
+  return { id: pickedId, meta_data };
+}
+
+export function useViewerContextMenu(
+  container: Readonly<ShallowRef<HTMLElement | null>>,
+  viewerUI: Readonly<ShallowRef<ViewerUIExposed | null>>,
+): {
+  containerWidth: Ref<number>;
+  containerHeight: Ref<number>;
+  openTreeMenu: (payload: TreeMenuPayload) => Promise<void>;
+  openViewerMenu: (event: MouseEvent) => Promise<void>;
+} {
+  const menuStore = useMenuStore();
+  const dataStore = useDataStore();
+  const { width: containerWidth, height: containerHeight } = useElementSize(container);
+
+  function openMenuAt(event: MouseEvent, element: HTMLElement, target: MenuTarget): void {
+    const rect = element.getBoundingClientRect();
+    menuStore.openMenu({
+      id: target.id,
+      x: event.clientX - rect.left,
+      y: event.clientY - rect.top,
+      width: containerWidth.value,
+      height: containerHeight.value,
+      top: rect.top,
+      left: rect.left,
+      meta_data: target.meta_data,
+    });
+  }
+
+  async function openTreeMenu(payload: TreeMenuPayload): Promise<void> {
+    const element = container.value;
+    const target = await treeMenuTarget(dataStore, payload);
+    if (element && target) {
+      openMenuAt(payload.event, element, target);
+    }
+  }
+
+  async function openViewerMenu(event: MouseEvent): Promise<void> {
+    const element = container.value;
+    const viewerComponent = viewerUI.value;
+    if (!element || !viewerComponent) {
+      return;
+    }
+    const rect = element.getBoundingClientRect();
+    const x = event.clientX - rect.left;
+    const yPicking = containerHeight.value - (event.clientY - rect.top);
+    const { id: pickedId, viewer_id } = await viewerComponent.get_viewer_id(x, yPicking);
+    if (pickedId === undefined) {
+      return;
+    }
+    openMenuAt(event, element, await viewerMenuTarget(dataStore, pickedId, viewer_id));
+  }
+
+  return { containerWidth, containerHeight, openTreeMenu, openViewerMenu };
+}

package/app/stores/menu.ts

@@ -45,6 +45,7 @@ type MenuItems = Component[];
 interface MenuMetaData {
   viewer_type?: string;
   geode_object_type?: string;
+  targetIds?: string[];
   [key: string]: unknown;
 }
 
@@ -246,3 +247,5 @@ export const useMenuStore = defineStore("menu", () => {
     toggleItemOptions,
   };
 });
+
+export type { MenuMetaData };

package/app/utils/attributes.ts

@@ -62,4 +62,41 @@ const MODEL_COMPONENT_KINDS: Record<string, string[]> = {
   Block: ["vertex", "polyhedron"],
 };
 
-export { MESH_ELEMENT_KINDS, MODEL_COMPONENT_KINDS, getAttributeRange };
+function intersectBy<TItem>(
+  lists: readonly (readonly TItem[])[],
+  key: (item: TItem) => string,
+): TItem[] {
+  const [first = [], ...others] = lists;
+  return first.filter((item) =>
+    others.every((list) => list.some((other) => key(other) === key(item))),
+  );
+}
+
+interface NamedAttribute {
+  attribute_name: string;
+  nb_items: number;
+}
+
+function intersectAttributes<TAttribute extends NamedAttribute>(
+  attributesPerData: readonly (readonly TAttribute[])[],
+): TAttribute[] {
+  const allAttributes = attributesPerData.flat();
+  const common: TAttribute[] = [];
+  for (const attribute of intersectBy(attributesPerData, (item) => item.attribute_name)) {
+    const nb_items = Math.min(
+      ...allAttributes
+        .filter((other) => other.attribute_name === attribute.attribute_name)
+        .map((other) => other.nb_items),
+    );
+    common.push({ ...attribute, nb_items });
+  }
+  return common;
+}
+
+export {
+  MESH_ELEMENT_KINDS,
+  MODEL_COMPONENT_KINDS,
+  getAttributeRange,
+  intersectAttributes,
+  intersectBy,
+};

package/app/utils/request_for_targets.ts

@@ -0,0 +1,24 @@
+import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
+import { useBackStore } from "@ogw_front/stores/back";
+
+async function requestForTargets<TResponse>(
+  schema: JsonRpcSchema,
+  targetIds: readonly string[],
+  fallback: TResponse,
+): Promise<[string, TResponse][]> {
+  const backStore = useBackStore();
+  const responses = await Promise.all(
+    targetIds.map(async (targetId): Promise<[string, TResponse]> => {
+      try {
+        const response = await backStore.request({ schema, params: { id: targetId } });
+        // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary.
+        return [targetId, response as TResponse];
+      } catch {
+        return [targetId, fallback];
+      }
+    }),
+  );
+  return responses;
+}
+
+export { requestForTargets };

package/app/utils/treeview.ts

@@ -7,4 +7,34 @@ function compareSelections<Item>(
   return { added, removed };
 }
 
+interface DataMenuPayload {
+  event: MouseEvent;
+  itemId: string;
+  context_type?: undefined;
+}
+
+interface GeodeObjectTypeMenuPayload {
+  event: MouseEvent;
+  itemId: string;
+  context_type: "geode_object_type";
+  targetIds: string[];
+}
+
+interface ModelComponentMenuPayload {
+  event: MouseEvent;
+  itemId: string;
+  context_type: "model_component" | "model_component_type";
+  modelId: string;
+  modelComponentType?: string;
+  targetComponentIds?: string[];
+}
+
+type TreeMenuPayload = DataMenuPayload | GeodeObjectTypeMenuPayload | ModelComponentMenuPayload;
+
 export { compareSelections };
+export type {
+  DataMenuPayload,
+  GeodeObjectTypeMenuPayload,
+  ModelComponentMenuPayload,
+  TreeMenuPayload,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.37.0",
+  "version": "10.38.0-rc.1",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -51,7 +51,6 @@
   "scripts": {
     "lint": "oxlint --fix .",
     "prepare:types": "cross-env MODE=BROWSER nuxi prepare",
-    "typecheck": "nuxt typecheck && tsc -p tsconfig.tests.json --noEmit",
     "build:back": "npx opengeodeweb-microservice-pyinstaller ../OpenGeodeWeb-Back",
     "build:viewer": "npx opengeodeweb-microservice-pyinstaller ../OpenGeodeWeb-Viewer",
     "build:microservices": "concurrently \"npm run build:back\" \"npm run build:viewer\"",
@@ -65,9 +64,9 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@geode/cloud-api": "latest",
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/cloud-api": "next",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
     "@pinia/nuxt": "1.0.1",
@@ -114,20 +113,19 @@
     "cross-env": "10.0.0",
     "happy-dom": "20.0.11",
     "msw": "2.11.1",
-    "oxlint": "1.82.0",
+    "oxlint": "latest",
+    "oxlint-tsgolint": "latest",
     "playwright-core": "1.52.0",
     "prettier": "3.8.1",
     "resize-observer-polyfill": "1.5.1",
     "rolldown": "1.2.8",
     "tsx": "4.23.13",
-    "typescript": "5.9.3",
     "unplugin-auto-import": "20.0.0",
     "vite": "8.2.0",
     "vite-plugin-vuetify": "2.1.3",
     "vitest": "4.1.10",
     "vitest-environment-nuxt": "2.0.0",
-    "vitest-indexeddb": "0.0.1",
-    "vue-tsc": "3.3.11"
+    "vitest-indexeddb": "0.0.1"
   },
   "overrides": {
     "vue": "3.5.40"