@geode/opengeodeweb-front 10.36.0 → 10.37.0

package/internal/stores/hybrid_viewer/camera.ts

@@ -9,7 +9,7 @@ import { requireRenderWindow, useHybridViewerCore } from "./core";
 import { dot } from "@kitware/vtk.js/Common/Core/Math";
 import { useHybridViewerScene } from "./scene";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 const BUMP_MULTIPLIER = 0.2;
 const ALIGNMENT_THRESHOLD = 0.9;
@@ -210,25 +210,24 @@ const useHybridViewerCamera = createSharedComposable(() => {
     syncRemoteCamera();
   }
 
-  async function performFocusCameraOnObject(id: string, block_ids: string[] = []): Promise<void> {
+  async function performFocusCameraOnObject(id: string, block_ids: number[] = []): 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();
+    let bounds: [number, number, number, number, number, number] = hybridDb[id].actor.getBounds();
+    if (block_ids.length > 0) {
+      const response = await viewerStore.request({
+        schema: viewer_schemas.opengeodeweb_viewer.model.get_blocks_bounds,
+        params: {
+          id,
+          block_ids,
+        },
+      });
+      bounds = toBounds(response.bounds);
+    }
     const renderer = requireRenderWindow(genericRenderWindow).getRenderer();
     const camera = renderer.getActiveCamera();
     const startOptions = getCameraOptions(camera);
@@ -238,7 +237,7 @@ const useHybridViewerCamera = createSharedComposable(() => {
     performSetCamera(targetOptions);
   }
 
-  async function focusCameraOnObject(id: string, block_ids: string[] = []): Promise<void> {
+  async function focusCameraOnObject(id: string, block_ids: number[] = []): Promise<void> {
     await performFocusCameraOnObject(id, block_ids);
   }
 

package/internal/stores/hybrid_viewer/core.ts

@@ -2,7 +2,7 @@ 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";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
 interface GenericRenderWindowHolder {
   value?: VtkGenericRenderWindow;

package/internal/stores/hybrid_viewer/filters.ts

@@ -1,9 +1,14 @@
+import viewer_schemas, {
+  type ViewerClippingPlanesParams,
+} from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 import type { SliceAxis } from "@ogw_front/utils/slice";
 import { useHybridViewerCore } from "./core";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-async function setClippingPlanes(ids: string[], planes: unknown): Promise<void> {
+async function setClippingPlanes(
+  ids: string[],
+  planes: ViewerClippingPlanesParams["planes"],
+): Promise<void> {
   const viewerStore = useViewerStore();
   const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.clipping_planes;
@@ -42,13 +47,14 @@ async function setSlice(
     ids,
     slices,
   };
-  const response = await viewerStore.request({
+  const {
+    max_indices: [max_i = 0, max_j = 0, max_k = 0],
+  } = await viewerStore.request({
     schema,
     params,
   });
   await remoteRender();
-  // oxlint-disable-next-line no-unsafe-type-assertion -- response shape is defined by the slice schema.
-  return (response as { max_indices: [number, number, number] }).max_indices;
+  return [max_i, max_j, max_k];
 }
 interface ThresholdAttribute {
   name: string;
@@ -72,7 +78,7 @@ async function setThreshold(ids: string[], attribute?: ThresholdAttribute): Prom
   await remoteRender();
 }
 function useHybridViewerFilters(): {
-  setClippingPlanes: (ids: string[], planes: unknown) => Promise<void>;
+  setClippingPlanes: (ids: string[], planes: ViewerClippingPlanesParams["planes"]) => Promise<void>;
   setShrink: (ids: string[], shrink_factor: number) => Promise<void>;
   setSlice: (
     ids: string[],

package/internal/stores/hybrid_viewer/highlight.ts

@@ -1,25 +1,19 @@
 import { HOVER_DEBOUNCE_MS, HOVER_TIMEOUT_MS } from "./constants";
 import type { HoverComponentInfo, HoverData } from "./vtk_types";
+import viewer_schemas, {
+  type PickedFieldType,
+  type ViewerHighlightResponse,
+} from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 import type { IndexableType } from "dexie";
 import { database } from "@ogw_internal/database/database.js";
 import { useHybridViewerCore } from "./core";
 import { useHybridViewerScene } from "./scene";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-// The dynamic/RPC-shaped payload of the viewer's "highlight" schema response.
-interface HighlightResponse {
-  id?: string;
-  picked_id?: number;
-  field_type?: string;
-  geode_id?: string | null;
-  attributes?: Record<string, unknown>;
-}
 
 // Shared via createSharedComposable (rather than merged into the parent hybridViewer store) so sibling slices, e.g. ruler.ts and viewport.ts, can read hover state/clearHoverHighlight/hoverHighlight 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 useHybridViewerHighlight = createSharedComposable(() => {
   const is_hover_highlight = ref(false);
-  const hover_highlight_field_type = ref("CELL");
+  const hover_highlight_field_type = ref<PickedFieldType>("CELL");
   const hoverData = ref<HoverData | undefined>(undefined);
   const hoverPosition = ref({
     x: 0,
@@ -39,7 +33,7 @@ const useHybridViewerHighlight = createSharedComposable(() => {
 
   function requestHoverHighlight(
     event: MouseEvent,
-    onResponse: (response: unknown) => void | Promise<void>,
+    onResponse: (response: ViewerHighlightResponse) => void | Promise<void>,
   ): void {
     if (!is_hover_highlight.value) {
       return;
@@ -85,12 +79,9 @@ const useHybridViewerHighlight = createSharedComposable(() => {
           x: event.clientX,
           y: event.clientY,
         };
-    requestHoverHighlight(event, async (rawResponse: unknown) => {
-      // oxlint-disable-next-line no-unsafe-type-assertion -- trusted viewer RPC response boundary.
-      const response = rawResponse as HighlightResponse | undefined;
+    requestHoverHighlight(event, async (response) => {
       if (
         !is_hover_highlight.value ||
-        response === undefined ||
         response.id === undefined ||
         response.picked_id === undefined ||
         response.picked_id === -1
@@ -115,7 +106,7 @@ const useHybridViewerHighlight = createSharedComposable(() => {
         modelName = modelRecord.name;
       }
       const modelComponentsTable = database.model_components;
-      if (response.geode_id !== undefined && response.geode_id !== null && modelComponentsTable) {
+      if (response.geode_id !== undefined && modelComponentsTable) {
         const components = modelComponentsTable.where("[id+geode_id]");
         const query = components.equals([response.id, response.geode_id] as IndexableType);
         const component = (await query.first()) as
@@ -132,7 +123,7 @@ const useHybridViewerHighlight = createSharedComposable(() => {
       const newHoverData: HoverData = {
         modelId: response.id,
         modelName,
-        blockName: response.geode_id ?? undefined,
+        blockName: response.geode_id,
         pickedId: response.picked_id,
         fieldType: response.field_type,
         component: componentInfo,

package/internal/stores/hybrid_viewer/ruler.ts

@@ -1,12 +1,14 @@
+import viewer_schemas, {
+  type PickedFieldType,
+} from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 import { useHybridViewerCore } from "./core";
 import { useHybridViewerHighlight } from "./highlight";
 import { useHybridViewerScene } from "./scene";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 interface RulerHoverState {
   active: boolean;
-  fieldType: string;
+  fieldType: PickedFieldType;
 }
 
 function useHybridViewerRuler(): {
@@ -63,11 +65,8 @@ function useHybridViewerRuler(): {
     const { remoteRender } = useHybridViewerCore();
     const viewerStore = useViewerStore();
     const schema = viewer_schemas.opengeodeweb_viewer.viewer.ruler;
-    // oxlint-disable-next-line no-unsafe-type-assertion -- response shape is defined by the ruler schema.
-    const response = (await viewerStore.request({ schema, params: { points } })) as {
-      distance?: number;
-    };
-    ruler_distance.value = response.distance;
+    const { distance } = await viewerStore.request({ schema, params: { points } });
+    ruler_distance.value = distance;
     await remoteRender();
   }
 
@@ -80,14 +79,12 @@ function useHybridViewerRuler(): {
       const params = {
         x: Math.round(x),
         y: Math.round(y),
-        field_type: "POINT",
+        field_type: "POINT" as const,
         ids: Object.keys(hybridDb),
       };
-      // oxlint-disable-next-line no-unsafe-type-assertion -- response shape is defined by the highlight schema.
-      const response = (await viewerStore.request({ schema, params })) as {
-        attributes?: { coordinates?: number[] };
-      };
-      coords = response.attributes?.coordinates;
+      const { attributes } = await viewerStore.request({ schema, params });
+      const coordinates = attributes?.coordinates;
+      coords = Array.isArray(coordinates) ? coordinates : undefined;
     } else {
       coords = await viewerStore.pick_world_position(x, y);
     }

package/internal/stores/hybrid_viewer/scene.ts

@@ -4,7 +4,7 @@ import { ACTOR_COLOR } from "./constants";
 import { base64ToArrayBuffer } from "./base64";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 import { newInstance as vtkActor } from "@kitware/vtk.js/Rendering/Core/Actor";
 import { newInstance as vtkMapper } from "@kitware/vtk.js/Rendering/Core/Mapper";
 import type vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData";

package/internal/utils/viewer_call.ts

@@ -11,7 +11,7 @@ interface ViewerMicroservice extends Microservice {
 
 interface ViewerCallParams {
   schema: JsonRpcSchema;
-  params?: Record<string, unknown>;
+  params?: object;
   timeout?: number;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.36.0",
+  "version": "10.37.0",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {

package/server/utils/ws_client.ts

@@ -34,11 +34,11 @@ function rawDataToString(raw: WebSocket.RawData): string {
 }
 
 interface ServerWsRpcClient {
-  call: (rpc: string, params?: Record<string, unknown>) => Promise<unknown>;
+  call: (rpc: string, params?: object) => Promise<unknown>;
   close: () => void;
   getConnection: () => {
     getSession: () => {
-      call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
+      call: (rpc: string, params: readonly [object]) => Promise<unknown>;
     };
   };
   isOpen: () => boolean;
@@ -114,7 +114,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     });
   });
 
-  async function call(rpc: string, params: Record<string, unknown> = {}): Promise<unknown> {
+  async function call(rpc: string, params: object = {}): Promise<unknown> {
     await ready;
     const id = uuidv4();
     //oxlint-disable-next-line promise/avoid-new
@@ -139,7 +139,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
   function getConnection(): ReturnType<ServerWsRpcClient["getConnection"]> {
     return {
       getSession: () => ({
-        call: async (rpc: string, [params]: readonly [Record<string, unknown>]) => {
+        call: async (rpc: string, [params]: readonly [object]) => {
           const result = await call(rpc, params);
           return result;
         },

package/shared/utils/call_raw.ts

@@ -6,19 +6,19 @@ import pTimeout from "p-timeout";
 import type { RequestHandlers } from "./types.js";
 
 interface RpcSession {
-  readonly call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
+  readonly call: (rpc: string, params: readonly [object]) => Promise<unknown>;
 }
 interface RpcConnection {
   readonly getSession: () => RpcSession;
 }
 interface RpcClient {
-  readonly call: (rpc: string, params: Record<string, unknown>) => Promise<unknown>;
+  readonly call: (rpc: string, params: object) => Promise<unknown>;
   readonly getConnection: () => RpcConnection;
 }
 
 interface CallClientOptions {
   rpc: string;
-  params?: Record<string, unknown>;
+  params?: object;
   client: RpcClient;
 }
 

package/shared/utils/call_schema.ts

@@ -1,29 +1,29 @@
 // Third party imports
 
 // Local imports
-import type { JsonRpcSchema, RequestHandlersWithValidation } from "./types.js";
+import type { JsonRpcSchema, RequestHandlersWithValidation, ResponseOf } from "./types.js";
 import { type RpcClient, callRaw } from "./call_raw.js";
 import { consola } from "consola";
 import { validateSchema } from "./validate_schema.js";
 
 const ERROR_400 = 400;
 
-interface CallSchemaOptions {
-  schema: JsonRpcSchema;
-  params?: Record<string, unknown>;
+interface CallSchemaOptions<Schema extends JsonRpcSchema> {
+  schema: Schema;
+  params?: object;
   client: RpcClient;
   timeout?: number;
 }
 
-async function callSchema(
-  { schema, params = {}, client, timeout }: CallSchemaOptions,
+async function callSchema<Schema extends JsonRpcSchema>(
+  { schema, params = {}, client, timeout }: CallSchemaOptions<Schema>,
   {
     request_error_function,
     response_function,
     response_error_function,
     validation_error_function,
   }: RequestHandlersWithValidation = {},
-): Promise<unknown> {
+): Promise<ResponseOf<Schema>> {
   const { valid, error: schema_error } = validateSchema(schema, params);
 
   if (!valid) {
@@ -49,7 +49,9 @@ async function callSchema(
       response_error_function,
     },
   );
-  return result;
+  // The microservice validates its responses against the schema `response` it was generated from.
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return result as ResponseOf<Schema>;
 }
 
 export { callSchema };

package/shared/utils/types.ts

@@ -21,6 +21,11 @@ type ParamsOf<Schema> = Schema extends { readonly __params?: infer Params }
   ? Params
   : Record<string, unknown>;
 
+// Any microservice's `microservice_version` schema, whatever the package that generated it.
+type MicroserviceVersionSchema = JsonRpcSchema & {
+  readonly __response?: { microservice_version: string };
+};
+
 interface RequestHandlers<Response = unknown> {
   readonly request_error_function?: (error: unknown) => void | Promise<void>;
   // Return value is intentionally untyped: callers commonly return the Promise of a downstream call (e.g. a Dexie `.put()`, which resolves to a primary key) that this code chains/awaits but never inspects the resolved value of.
@@ -34,6 +39,7 @@ interface RequestHandlersWithValidation extends RequestHandlers {
 
 export type {
   JsonRpcSchema,
+  MicroserviceVersionSchema,
   ParamsOf,
   RequestHandlers,
   RequestHandlersWithValidation,