@geode/opengeodeweb-front 10.36.0-rc.2 → 10.36.0-rc.4

package/.build/opengeodeweb_front_schemas.js

@@ -181,7 +181,8 @@ var api = {
 									"name": { "type": "string" },
 									"version": { "type": "string" },
 									"frontendContent": { "type": "string" },
-									"port": { "type": "integer" }
+									"port": { "type": "integer" },
+									"serverPort": { "type": "integer" }
 								},
 								"required": [
 									"id",

package/.build/server/utils/microservices.js

@@ -9,9 +9,10 @@ import child_process from "node:child_process";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
 //#region server/utils/microservices.ts
 const MILLISECONDS_PER_SECOND = 1e3;
-const DEFAULT_TIMEOUT_SECONDS = 45;
+const DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS = { projectFolderPath: "" };
+const LISTENING_LOG_PATTERN = /^Listening on https?:\/\/.+:\d+\/?\s*$/mu;
 async function runScript(execPath, execName, args, expectedResponse, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS) {
 	const command = executablePath(execPath, execName);
 	consola.debug("runScript", command, args);
@@ -132,6 +133,47 @@ async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_
 	}
 	throw new Error(`runExtension failed to run ${extensionId}`);
 }
+async function waitUntilListening(child) {
+	child.stderr.on("data", (data) => {
+		consola.info(`[${child.spawnfile}] STDERR:`, data.toString().trim());
+	});
+	child.on("close", (code) => {
+		consola.info(`[${child.spawnfile}] exited with code ${code}`);
+	});
+	for await (const chunk of child.stdout) {
+		const output = String(chunk);
+		consola.info(`[${child.spawnfile}] STDOUT:`, output.trim());
+		if (LISTENING_LOG_PATTERN.test(output)) {
+			child.stdout.on("data", (data) => {
+				consola.info(`[${child.spawnfile}] STDOUT:`, data.toString().trim());
+			});
+			return;
+		}
+	}
+	throw new Error(`${child.spawnfile} exited before becoming ready`);
+}
+async function runExtensionServer(entryPath, attempts = 0) {
+	let port = void 0;
+	try {
+		port = await getAvailablePort();
+		consola.info("runExtensionServer", entryPath, port);
+		await waitUntilListening(child_process.spawn("node", [entryPath], { env: {
+			...process.env,
+			PORT: String(port)
+		} }));
+		return port;
+	} catch (error) {
+		if (!isPortInUseError(error)) {
+			consola.error("runExtensionServer error", error);
+			throw error;
+		}
+		if (attempts <= MAX_PORT_RETRIES) {
+			consola.warn("Retrying runExtensionServer on conflicting port", port);
+			return await runExtensionServer(entryPath, attempts + 1);
+		}
+	}
+	throw new Error(`runExtensionServer failed to run ${entryPath}`);
+}
 function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	const microservices = projectMicroservices(projectFolderPath);
 	let enriched = { ...serviceObj };
@@ -151,4 +193,4 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	fs.writeFileSync(microservicesMetadatasPath(projectFolderPath), JSON.stringify({ microservices }, void 0, 2));
 }
 //#endregion
-export { addMicroserviceMetadatas, runBack, runExtension, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runExtensionServer, runViewer };

package/.build/server/utils/path.js

@@ -105,5 +105,8 @@ function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
 	consola.debug("runExtensions", { backendExecutablePath });
 	return backendExecutablePath;
 }
+function extensionServerEntryPath(unzippedExtensionPath, entry) {
+	return path.join(unzippedExtensionPath, entry);
+}
 //#endregion
-export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, generateProjectFolderPath };
+export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, extensionServerEntryPath, generateProjectFolderPath };

package/.build/server/utils/server_config.js

@@ -3,6 +3,7 @@ import { createServerWsRpcClient } from "./ws_client.js";
 const stringStorage = /* @__PURE__ */ new Map();
 const booleanStorage = /* @__PURE__ */ new Map();
 const clientStorage = /* @__PURE__ */ new Map();
+const extensionServerPorts = /* @__PURE__ */ new Map();
 function getAppBaseUrl() {
 	const value = stringStorage.get("APP_BASE_URL");
 	if (value === void 0) throw new Error("APP_BASE_URL is not set");
@@ -47,5 +48,14 @@ async function getViewerWebSocketClient() {
 	if (viewerClient !== void 0 && viewerClient.isOpen()) return viewerClient;
 	return await setViewerWebSocketClient(getViewerBaseUrl());
 }
+function setExtensionServerPort(extensionId, port) {
+	extensionServerPorts.set(extensionId, port);
+}
+function getExtensionServerPort(extensionId) {
+	return extensionServerPorts.get(extensionId);
+}
+function getExtensionServerPorts() {
+	return extensionServerPorts;
+}
 //#endregion
-export { getAppBaseUrl, getBackBaseUrl, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };
+export { getAppBaseUrl, getBackBaseUrl, getExtensionServerPort, getExtensionServerPorts, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setExtensionServerPort, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };

package/app/components/ClippingPlanes.vue

@@ -1,6 +1,14 @@
 <script setup lang="ts">
 import { DEBOUNCE_DELAY, DEFAULT_NORMALS } from "@ogw_front/utils/clipping_planes";
+import {
+  DEFAULT_SLICE_AXIS,
+  SLICE_AXES,
+  type SliceAxis,
+  areAllGrids,
+} from "@ogw_front/utils/slice";
+import type { ClippingPlane } from "@ogw_front/composables/clipping_planes_widget_entries";
 import ClippingPlaneCard from "@ogw_front/components/ClippingPlaneCard.vue";
+import SliceCard from "@ogw_front/components/SliceCard.vue";
 import ToolPanel from "@ogw_front/components/ToolPanel.vue";
 import { useClippingPlanesWidget } from "@ogw_front/composables/clipping_planes_widget";
 import { useDataStore } from "@ogw_front/stores/data";
@@ -18,10 +26,23 @@ const dataStore = useDataStore();
 const hybridViewerStore = useHybridViewerStore();
 const targetAllVisible = ref<boolean>(true);
 const selectedDatasetIds = ref<string[]>([]);
-const planes = ref<{ origin?: number[]; normal: number[] }[]>([
-  { origin: undefined, normal: [1, 0, 0] },
-]);
+let lastItemId = 0;
+function newItemId(): number {
+  lastItemId += 1;
+  return lastItemId;
+}
+const planes = ref<ClippingPlane[]>([{ id: newItemId(), origin: undefined, normal: [1, 0, 0] }]);
 const allItems = dataStore.refAllItems();
+const sliceEnabled = ref<boolean>(false);
+const slices = ref<{ id: number; axis: SliceAxis; index: number }[]>([
+  { id: newItemId(), axis: DEFAULT_SLICE_AXIS, index: 0 },
+]);
+const sliceMaxIndices = ref<[number, number, number]>([0, 0, 0]);
+const targetIds = computed<string[]>(() =>
+  targetAllVisible.value ? allItems.value.map((item) => item.id) : selectedDatasetIds.value,
+);
+const isAllGrid = computed<boolean>(() => areAllGrids(allItems.value, targetIds.value));
+const isSliceActive = computed<boolean>(() => isAllGrid.value && sliceEnabled.value);
 const availableDatasets = computed<{ title: string; value: string }[]>(() =>
   allItems.value.map((item) => ({
     title: item.name || item.id,
@@ -30,6 +51,8 @@ const availableDatasets = computed<{ title: string; value: string }[]>(() =>
 );
 const widgetContainer = useTemplateRef("widgetContainer");
 let debouncedApply: ((...args: unknown[]) => void) | undefined = undefined;
+let areSlicesApplied = false;
+let pendingSlices: Promise<void> = Promise.resolve();
 
 const {
   getSceneCenter,
@@ -49,41 +72,103 @@ const {
   debouncedApply: (...args: unknown[]) => debouncedApply?.(...args),
 });
 
+function getUntargetedIds(): string[] {
+  return allItems.value.map((item) => item.id).filter((id) => !targetIds.value.includes(id));
+}
+
 async function applyClippingPlanes(): Promise<void> {
-  const allIds = allItems.value.map((item) => item.id);
-  if (allIds.length === 0) {
+  if (allItems.value.length === 0) {
     return;
   }
   const center = getSceneCenter();
-  const targetIds = targetAllVisible.value ? allIds : selectedDatasetIds.value;
-  const untargetedIds = allIds.filter((id) => !targetIds.includes(id));
+  const untargetedIds = getUntargetedIds();
   const planesData = planes.value.map((plane) => ({
     origin: (plane.origin || center).map(Number),
     normal: plane.normal.map(Number),
   }));
-
-  if (targetIds.length > 0) {
-    await hybridViewerStore.setClippingPlanes(targetIds, planesData);
+  if (targetIds.value.length > 0) {
+    await hybridViewerStore.setClippingPlanes(
+      targetIds.value,
+      isSliceActive.value ? [] : planesData,
+    );
   }
   if (untargetedIds.length > 0) {
     await hybridViewerStore.setClippingPlanes(untargetedIds, []);
   }
 }
 
+async function sendSlices(): Promise<void> {
+  if (!isAllGrid.value && !areSlicesApplied) {
+    return;
+  }
+  const isActive = isSliceActive.value;
+  const untargetedIds = getUntargetedIds();
+  if (targetIds.value.length > 0) {
+    const maxIndices = await hybridViewerStore.setSlice(
+      targetIds.value,
+      isActive ? slices.value.map(({ axis, index }) => ({ axis, index })) : [],
+    );
+    if (isAllGrid.value) {
+      sliceMaxIndices.value = maxIndices;
+    }
+    if (isActive) {
+      for (const slice of slices.value) {
+        slice.index = Math.min(slice.index, maxIndices[slice.axis]);
+      }
+    }
+  }
+  if (areSlicesApplied && untargetedIds.length > 0) {
+    await hybridViewerStore.setSlice(untargetedIds, []);
+  }
+  areSlicesApplied = isActive;
+}
+
+function queueSliceTask(task: () => Promise<void>): Promise<void> {
+  const previous = pendingSlices;
+  pendingSlices = (async (): Promise<void> => {
+    await Promise.allSettled([previous]);
+    await task();
+  })();
+  return pendingSlices;
+}
+
+function applySlices(): Promise<void> {
+  return queueSliceTask(sendSlices);
+}
+
+async function applyAll(): Promise<void> {
+  await applyClippingPlanes();
+  await applySlices();
+}
+
 debouncedApply = useDebounceFn(() => applyClippingPlanes(), DEBOUNCE_DELAY);
+const debouncedApplySlices = useDebounceFn(() => applySlices(), DEBOUNCE_DELAY);
 
 function addPlane(): void {
   // Index is always in-bounds (modulo the fixed-size list); the fallbacks only
   // Satisfy noUncheckedIndexedAccess and are never hit at runtime.
   const normal = DEFAULT_NORMALS[planes.value.length % DEFAULT_NORMALS.length] ??
     DEFAULT_NORMALS[0] ?? [1, 0, 0];
-  planes.value.push({ origin: getSceneCenter(), normal });
+  planes.value.push({ id: newItemId(), origin: getSceneCenter(), normal });
 }
 
 function removePlane(index: number): void {
   planes.value.splice(index, 1);
 }
 
+function addSlice(): void {
+  const lastSlice = slices.value.at(-1);
+  slices.value.push({
+    id: newItemId(),
+    axis: lastSlice ? SLICE_AXES[lastSlice.axis].next : DEFAULT_SLICE_AXIS,
+    index: 0,
+  });
+}
+
+function removeSlice(index: number): void {
+  slices.value.splice(index, 1);
+}
+
 function flipNormal(plane: { normal: number[] }): void {
   plane.normal = plane.normal.map((component) => -component);
   syncWidgets();
@@ -92,15 +177,23 @@ function flipNormal(plane: { normal: number[] }): void {
 
 async function resetClippingPlanes(): Promise<void> {
   setFromWidget(true);
-  planes.value = [{ origin: undefined, normal: [1, 0, 0] }];
+  planes.value = [{ id: newItemId(), origin: undefined, normal: [1, 0, 0] }];
+  sliceEnabled.value = false;
+  slices.value = [{ id: newItemId(), axis: DEFAULT_SLICE_AXIS, index: 0 }];
   updateWidgetPlacement({ isReset: true });
   setFromWidget(false);
-  await applyClippingPlanes();
+  await applyAll();
 }
 
 async function removeClippingPlanes(): Promise<void> {
   const allIds = allItems.value.map((item) => item.id);
   await hybridViewerStore.setClippingPlanes(allIds, []);
+  await queueSliceTask(async () => {
+    if (areSlicesApplied) {
+      await hybridViewerStore.setSlice(allIds, []);
+      areSlicesApplied = false;
+    }
+  });
 }
 
 watch(widgetContainer, (container) => {
@@ -124,7 +217,7 @@ watch(
 watch(show, (visible) => {
   if (visible) {
     updateWidgetPlacement({ isReset: true });
-    applyClippingPlanes();
+    applyAll();
   }
 });
 
@@ -133,7 +226,23 @@ watch(
   () => {
     if (show.value) {
       updateWidgetPlacement({ isReset: true });
-      applyClippingPlanes();
+      applyAll();
+    }
+  },
+  { deep: true },
+);
+
+watch(sliceEnabled, () => {
+  if (show.value) {
+    applyAll();
+  }
+});
+
+watch(
+  slices,
+  () => {
+    if (show.value) {
+      debouncedApplySlices();
     }
   },
   { deep: true },
@@ -142,7 +251,7 @@ watch(
 watch(allItems, () => {
   if (show.value) {
     updateWidgetPlacement({ isReset: true });
-    applyClippingPlanes();
+    applyAll();
   }
 });
 
@@ -151,7 +260,7 @@ watch(
   (actorCount) => {
     if (show.value && actorCount > 0) {
       updateWidgetPlacement({ isReset: true });
-      applyClippingPlanes();
+      applyAll();
     }
   },
 );
@@ -171,6 +280,7 @@ onBeforeUnmount(cleanupLocalWidget);
   >
     <v-card-text class="pa-3 max-panel-height overflow-y-auto">
       <v-sheet
+        v-show="!isSliceActive"
         ref="widgetContainer"
         height="180"
         color="transparent"
@@ -203,28 +313,66 @@ onBeforeUnmount(cleanupLocalWidget);
 
       <v-divider class="my-2" />
 
-      <v-row align="center" justify="space-between" no-gutters class="mb-2">
-        <v-col class="text-caption font-weight-bold">Planes ({{ planes.length }})</v-col>
-        <v-col cols="auto">
-          <v-btn
-            data-testid="addPlaneButton"
-            size="x-small"
-            variant="tonal"
-            color="primary"
-            icon="mdi-plus"
-            @click="addPlane"
+      <template v-if="isAllGrid">
+        <v-switch
+          v-model="sliceEnabled"
+          data-testid="sliceSwitch"
+          label="Slice"
+          color="primary"
+          density="compact"
+          hide-details
+          class="mb-2 text-caption"
+        />
+        <template v-if="sliceEnabled">
+          <v-row align="center" justify="space-between" no-gutters class="mb-2">
+            <v-col class="text-caption font-weight-bold">Slices ({{ slices.length }})</v-col>
+            <v-col cols="auto">
+              <v-btn
+                data-testid="addSliceButton"
+                size="x-small"
+                variant="tonal"
+                color="primary"
+                icon="mdi-plus"
+                @click="addSlice"
+              />
+            </v-col>
+          </v-row>
+          <SliceCard
+            v-for="(slice, idx) in slices"
+            :key="slice.id"
+            :slice="slice"
+            :index="idx"
+            :max-index="sliceMaxIndices[slice.axis]"
+            @remove="removeSlice(idx)"
           />
-        </v-col>
-      </v-row>
-
-      <ClippingPlaneCard
-        v-for="(plane, idx) in planes"
-        :key="idx"
-        :plane="plane"
-        :index="idx"
-        @remove="removePlane(idx)"
-        @flip-normal="flipNormal(plane)"
-      />
+        </template>
+        <v-divider class="my-2" />
+      </template>
+
+      <template v-if="!isSliceActive">
+        <v-row align="center" justify="space-between" no-gutters class="mb-2">
+          <v-col class="text-caption font-weight-bold">Planes ({{ planes.length }})</v-col>
+          <v-col cols="auto">
+            <v-btn
+              data-testid="addPlaneButton"
+              size="x-small"
+              variant="tonal"
+              color="primary"
+              icon="mdi-plus"
+              @click="addPlane"
+            />
+          </v-col>
+        </v-row>
+
+        <ClippingPlaneCard
+          v-for="(plane, idx) in planes"
+          :key="plane.id"
+          :plane="plane"
+          :index="idx"
+          @remove="removePlane(idx)"
+          @flip-normal="flipNormal(plane)"
+        />
+      </template>
     </v-card-text>
 
     <template #actions>

package/app/components/SliceCard.vue

@@ -0,0 +1,79 @@
+<script setup lang="ts">
+import { SLICE_AXES, type SliceAxis } from "@ogw_front/utils/slice";
+
+interface Props {
+  slice: { axis: SliceAxis; index: number };
+  index: number;
+  maxIndex: number;
+}
+
+const { slice, index, maxIndex } = defineProps<Props>();
+
+interface Emits {
+  remove: [];
+}
+
+const emit = defineEmits<Emits>();
+</script>
+
+<template>
+  <v-card data-testid="sliceCard" variant="outlined" class="pa-2 mb-3 rounded-lg border-opacity-50">
+    <v-row align="center" no-gutters class="mb-1">
+      <v-col cols="auto">
+        <v-chip size="x-small" variant="flat" color="primary" class="font-weight-bold">
+          Slice #{{ index + 1 }}
+        </v-chip>
+      </v-col>
+      <v-col class="px-2">
+        <v-slider
+          v-model="slice.index"
+          data-testid="sliceIndexSlider"
+          :min="0"
+          :max="maxIndex"
+          :step="1"
+          color="primary"
+          track-color="grey-lighten-2"
+          density="compact"
+          hide-details
+        />
+      </v-col>
+      <v-col cols="auto">
+        <v-btn
+          data-testid="removeSliceButton"
+          icon="mdi-trash-can-outline"
+          size="x-small"
+          variant="text"
+          color="error"
+          @click="emit('remove')"
+        />
+      </v-col>
+    </v-row>
+
+    <v-row align="center" justify="space-between" no-gutters>
+      <v-col cols="auto">
+        <v-btn-toggle
+          v-model="slice.axis"
+          data-testid="sliceAxisToggle"
+          mandatory
+          density="compact"
+          color="primary"
+          variant="outlined"
+          divided
+        >
+          <v-btn
+            v-for="axis in SLICE_AXES"
+            :key="axis.value"
+            :value="axis.value"
+            size="small"
+            class="text-caption"
+          >
+            {{ axis.title }}
+          </v-btn>
+        </v-btn-toggle>
+      </v-col>
+      <v-col cols="auto" class="text-caption text-primary font-weight-bold">
+        {{ slice.index }} / {{ maxIndex }}
+      </v-col>
+    </v-row>
+  </v-card>
+</template>

package/app/composables/clipping_planes_widget_entries.ts

@@ -11,6 +11,7 @@ import type vtkAbstractWidgetFactory from "@kitware/vtk.js/Widgets/Core/Abstract
 import { newInstance as vtkImplicitPlaneWidget } from "@kitware/vtk.js/Widgets/Widgets3D/ImplicitPlaneWidget";
 
 interface ClippingPlane {
+  id: number;
   origin?: number[];
   normal: number[];
 }

package/app/stores/app_helpers/extension.ts

@@ -59,6 +59,7 @@ export function useAppExtensions(): {
   async function loadExtension(
     path: string,
     extensionPort: string,
+    serverPort?: string,
     backendPath?: string,
   ): Promise<ExtensionModule> {
     try {
@@ -77,7 +78,10 @@ export function useAppExtensions(): {
       // oxlint-disable-next-line no-inline-comments, no-unsafe-assignment
       const extensionModule: ExtensionModule = await import(/* @vite-ignore */ finalURL);
       const store = extensionModule.metadata.store();
-      store.$patch?.({ default_local_port: extensionPort });
+      store.$patch?.({
+        default_local_port: extensionPort,
+        ...(serverPort === undefined ? {} : { nitro_port: serverPort }),
+      });
 
       if (finalURL !== path && finalURL.startsWith("blob:")) {
         URL.revokeObjectURL(finalURL);

package/app/utils/extension.ts

@@ -15,6 +15,7 @@ interface ExtensionDescriptor {
   version: string;
   frontendContent: string;
   port: number;
+  serverPort?: number;
 }
 
 interface DownloadExtensionParams {
@@ -87,12 +88,16 @@ async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
   const { extensionsArray } = await runExtensions();
   return Promise.all(
     extensionsArray.map(async (extension: ExtensionDescriptor) => {
-      const { id, name, version, frontendContent, port } = extension;
+      const { id, name, version, frontendContent, port, serverPort } = extension;
       const blob = new Blob([frontendContent], {
         type: "application/javascript",
       });
       const blobUrl = URL.createObjectURL(blob);
-      const extensionModule = await appStore.loadExtension(blobUrl, String(port));
+      const extensionModule = await appStore.loadExtension(
+        blobUrl,
+        String(port),
+        serverPort === undefined ? undefined : String(serverPort),
+      );
       consola.info("[ExtensionManager] Extension loaded:", id);
       const storeFactory = extensionModule.metadata.store;
       const store = storeFactory();

package/app/utils/import_workflow.ts

@@ -80,6 +80,9 @@ async function importFile(filename: string, geode_object_type: string): Promise<
 }
 
 async function importWorkflow(files: readonly FileToImport[]): Promise<string[]> {
+  const hybridViewerStore = useHybridViewerStore();
+  // Files are imported concurrently and the viewer only frames the first actor to arrive, so the camera is reset once everything is loaded
+  const wasSceneEmpty = Object.keys(hybridViewerStore.hybridDb).length === 0;
   const chunk_size = 5;
   const chunks: FileToImport[][] = [];
   for (let i = 0; i < files.length; i += chunk_size) {
@@ -102,7 +105,10 @@ async function importWorkflow(files: readonly FileToImport[]): Promise<string[]>
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
-  const hybridViewerStore = useHybridViewerStore();
+  const isSceneFilled = Object.keys(hybridViewerStore.hybridDb).length > 0;
+  if (wasSceneEmpty && isSceneFilled) {
+    hybridViewerStore.resetCamera();
+  }
   await hybridViewerStore.remoteRender();
   return results;
 }

package/app/utils/slice.ts

@@ -0,0 +1,24 @@
+const GRID_TYPES = new Set([
+  "RegularGrid2D",
+  "LightRegularGrid2D",
+  "RegularGrid3D",
+  "LightRegularGrid3D",
+]);
+type SliceAxis = 0 | 1 | 2;
+const SLICE_AXES = [
+  { title: "YZ", value: 0, next: 1 },
+  { title: "XZ", value: 1, next: 2 },
+  { title: "XY", value: 2, next: 0 },
+] as const satisfies readonly { title: string; value: SliceAxis; next: SliceAxis }[];
+const DEFAULT_SLICE_AXIS: SliceAxis = 2;
+
+function areAllGrids(items: { id: string; geode_object_type: string }[], ids: string[]): boolean {
+  const targetedItems = items.filter((item) => ids.includes(item.id));
+  return (
+    targetedItems.length > 0 &&
+    targetedItems.every((item) => GRID_TYPES.has(item.geode_object_type))
+  );
+}
+
+export { SLICE_AXES, DEFAULT_SLICE_AXIS, areAllGrids };
+export type { SliceAxis };

package/internal/stores/hybrid_viewer/filters.ts

@@ -1,3 +1,4 @@
+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";
@@ -30,6 +31,25 @@ async function setShrink(ids: string[], shrink_factor: number): Promise<void> {
   });
   await remoteRender();
 }
+async function setSlice(
+  ids: string[],
+  slices: { axis: SliceAxis; index: number }[],
+): Promise<[number, number, number]> {
+  const viewerStore = useViewerStore();
+  const { remoteRender } = useHybridViewerCore();
+  const schema = viewer_schemas.opengeodeweb_viewer.viewer.slice;
+  const params = {
+    ids,
+    slices,
+  };
+  const response = 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;
+}
 interface ThresholdAttribute {
   name: string;
   location: "point" | "cell";
@@ -54,11 +74,16 @@ async function setThreshold(ids: string[], attribute?: ThresholdAttribute): Prom
 function useHybridViewerFilters(): {
   setClippingPlanes: (ids: string[], planes: unknown) => Promise<void>;
   setShrink: (ids: string[], shrink_factor: number) => Promise<void>;
+  setSlice: (
+    ids: string[],
+    slices: { axis: SliceAxis; index: number }[],
+  ) => Promise<[number, number, number]>;
   setThreshold: (ids: string[], attribute?: ThresholdAttribute) => Promise<void>;
 } {
   return {
     setClippingPlanes,
     setShrink,
+    setSlice,
     setThreshold,
   };
 }

package/opengeodeweb_front_schemas.json

@@ -241,6 +241,9 @@
                     },
                     "port": {
                       "type": "integer"
+                    },
+                    "serverPort": {
+                      "type": "integer"
                     }
                   },
                   "required": ["id", "name", "version", "frontendContent", "port"],

package/opengeodeweb_front_typed_schemas.d.ts

@@ -90,6 +90,7 @@ export interface LocalExtensionsRunResponseExtensionsArray {
   id: string;
   name: string;
   port: number;
+  serverPort?: number;
   version: string;
 }
 

package/package.json

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

package/server/api/local/extensions/run.post.ts

@@ -7,54 +7,73 @@ import fs from "node:fs";
 import {
   addMicroserviceMetadatas,
   runBack,
+  runExtensionServer,
 } from "@geode/opengeodeweb-front/server/utils/microservices.ts";
 import {
   extensionBackendPath,
   extensionFolderPath,
+  extensionServerEntryPath,
 } from "@geode/opengeodeweb-front/server/utils/path.ts";
 import {
   readExtensionFrontend,
   readExtensionMetadata,
 } from "@geode/opengeodeweb-front/server/utils/extension.ts";
 import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.ts";
+import { setExtensionServerPort } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
 import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.ts";
 
 import { defineTypedEventHandler } from "@geode/opengeodeweb-front/server/utils/typed_handler.ts";
 import schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 
+async function runSingleExtension(
+  extensionPath: string,
+  extensionId: string,
+  projectFolderPath: string,
+): Promise<{
+  id: string;
+  name: string;
+  version: string;
+  frontendContent: string;
+  port: number;
+  serverPort: number | undefined;
+}> {
+  const unzippedExtensionPath = await unzipFile(
+    extensionPath,
+    extensionFolderPath(projectFolderPath, extensionId),
+  );
+  const { id, name, version, backendExecutable, server, frontendFile } =
+    await readExtensionMetadata(unzippedExtensionPath);
+  const frontendContent = await readExtensionFrontend(unzippedExtensionPath, frontendFile, id);
+
+  fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
+  const port = await runBack(backendExecutable, unzippedExtensionPath, {
+    projectFolderPath,
+  });
+  addMicroserviceMetadatas(projectFolderPath, {
+    type: "back",
+    name,
+    port,
+  });
+
+  const serverPort =
+    server === undefined
+      ? undefined
+      : await runExtensionServer(extensionServerEntryPath(unzippedExtensionPath, server.entry));
+  if (serverPort !== undefined) {
+    setExtensionServerPort(id, serverPort);
+  }
+
+  return { id, name, version, frontendContent, port, serverPort };
+}
+
 export default defineTypedEventHandler(
   schemas.api.local.extensions.run,
   async ({ projectFolderPath, projectName }) => {
     const extensionsConfig = extensionsConf(projectName);
     const extensionsArray = await Promise.all(
       Object.entries(extensionsConfig).map(async ([extensionId, { path: extensionPath }]) => {
-        const unzippedExtensionPath = await unzipFile(
-          extensionPath,
-          extensionFolderPath(projectFolderPath, extensionId),
-        );
-        const { id, name, version, backendExecutable, frontendFile } =
-          await readExtensionMetadata(unzippedExtensionPath);
-        const frontendContent = await readExtensionFrontend(
-          unzippedExtensionPath,
-          frontendFile,
-          id,
-        );
-        fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
-        const port = await runBack(backendExecutable, unzippedExtensionPath, {
-          projectFolderPath,
-        });
-        addMicroserviceMetadatas(projectFolderPath, {
-          type: "back",
-          name,
-          port,
-        });
-        return {
-          id,
-          name,
-          version,
-          frontendContent,
-          port,
-        };
+        const result = await runSingleExtension(extensionPath, extensionId, projectFolderPath);
+        return result;
       }),
     );
 

package/server/api/local/extensions/schemas/run.json

@@ -37,6 +37,9 @@
             },
             "port": {
               "type": "integer"
+            },
+            "serverPort": {
+              "type": "integer"
             }
           },
           "required": ["id", "name", "version", "frontendContent", "port"],

package/server/utils/extension.ts

@@ -10,6 +10,10 @@ import { createError } from "h3";
 // Local imports
 import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.ts";
 
+const extensionServerMetadataSchema = z.object({
+  entry: z.string(),
+});
+
 const extensionMetadataSchema = z
   .object({
     id: z.string(),
@@ -17,6 +21,7 @@ const extensionMetadataSchema = z
     version: z.string(),
     frontendFile: z.string(),
     backendExecutable: z.string(),
+    server: extensionServerMetadataSchema.optional(),
   })
   .loose();
 

package/server/utils/microservices.ts

@@ -20,9 +20,10 @@ interface RunArgs {
 }
 
 const MILLISECONDS_PER_SECOND = 1000;
-const DEFAULT_TIMEOUT_SECONDS = 45;
+const DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
+const LISTENING_LOG_PATTERN = /^Listening on https?:\/\/.+:\d+\/?\s*$/mu;
 
 async function runScript(
   execPath: string,
@@ -183,6 +184,56 @@ async function runExtension(
   }
   throw new Error(`runExtension failed to run ${extensionId}`);
 }
+async function waitUntilListening(
+  child: child_process.ChildProcessWithoutNullStreams,
+): Promise<void> {
+  child.stderr.on("data", (data: Buffer) => {
+    consola.info(`[${child.spawnfile}] STDERR:`, data.toString().trim());
+  });
+  child.on("close", (code) => {
+    consola.info(`[${child.spawnfile}] exited with code ${code}`);
+  });
+  // oxlint-disable-next-line typescript/no-unnecessary-condition
+  for await (const chunk of child.stdout) {
+    const output = String(chunk);
+    consola.info(`[${child.spawnfile}] STDOUT:`, output.trim());
+    if (LISTENING_LOG_PATTERN.test(output)) {
+      child.stdout.on("data", (data: Buffer) => {
+        consola.info(`[${child.spawnfile}] STDOUT:`, data.toString().trim());
+      });
+      return;
+    }
+  }
+  throw new Error(`${child.spawnfile} exited before becoming ready`);
+}
+
+async function runExtensionServer(entryPath: string, attempts = 0): Promise<number> {
+  let port: number | undefined = undefined;
+  try {
+    port = await getAvailablePort();
+    consola.info("runExtensionServer", entryPath, port);
+    const child = child_process.spawn("node", [entryPath], {
+      env: {
+        ...process.env,
+        PORT: String(port),
+      },
+    });
+    await waitUntilListening(child);
+    return port;
+  } catch (error) {
+    if (!isPortInUseError(error)) {
+      consola.error("runExtensionServer error", error);
+      throw error;
+    }
+    if (attempts <= MAX_PORT_RETRIES) {
+      consola.warn("Retrying runExtensionServer on conflicting port", port);
+      const newPort = await runExtensionServer(entryPath, attempts + 1);
+      return newPort;
+    }
+  }
+  throw new Error(`runExtensionServer failed to run ${entryPath}`);
+}
+
 function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
   let enriched: Microservice = { ...serviceObj };
@@ -213,4 +264,4 @@ function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microse
   );
 }
 
-export { addMicroserviceMetadatas, runBack, runExtension, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runExtensionServer, runViewer };

package/server/utils/path.ts

@@ -163,11 +163,15 @@ function extensionBackendPath(
   });
   return backendExecutablePath;
 }
+function extensionServerEntryPath(unzippedExtensionPath: string, entry: string): string {
+  return path.join(unzippedExtensionPath, entry);
+}
 export {
   createPath,
   extensionBackendPath,
   extensionFrontendPath,
   extensionFolderPath,
+  extensionServerEntryPath,
   executablePath,
   executableName,
   generateProjectFolderPath,

package/server/utils/server_config.ts

@@ -3,6 +3,7 @@ import { type ServerWsRpcClient, createServerWsRpcClient } from "./ws_client.js"
 const stringStorage = new Map<string, string>();
 const booleanStorage = new Map<string, boolean>();
 const clientStorage = new Map<string, ServerWsRpcClient>();
+const extensionServerPorts = new Map<string, number>();
 
 function getAppBaseUrl(): string {
   const value = stringStorage.get("APP_BASE_URL");
@@ -60,14 +61,27 @@ async function getViewerWebSocketClient(): Promise<ServerWsRpcClient> {
   const client = await setViewerWebSocketClient(viewerBaseUrl);
   return client;
 }
+function setExtensionServerPort(extensionId: string, port: number): void {
+  extensionServerPorts.set(extensionId, port);
+}
+function getExtensionServerPort(extensionId: string): number | undefined {
+  return extensionServerPorts.get(extensionId);
+}
+function getExtensionServerPorts(): ReadonlyMap<string, number> {
+  return extensionServerPorts;
+}
+
 export {
   getAppBaseUrl,
   getBackBaseUrl,
+  getExtensionServerPort,
+  getExtensionServerPorts,
   getIsAppReady,
   getViewerBaseUrl,
   getViewerWebSocketClient,
   setAppBaseUrl,
   setBackBaseUrl,
+  setExtensionServerPort,
   setIsAppReady,
   setViewerBaseUrl,
   setViewerWebSocketClient,