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

package/app/utils/default_styles/meshes.ts

@@ -0,0 +1,264 @@
+import {
+  type AttributeConfig,
+  CELLS_DEFAULT_COLOR,
+  CELLS_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_COLOR,
+  EDGES_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_WIDTH,
+  MESH_DEFAULT_ACTIVE_COLORING,
+  POINTS_DEFAULT_COLOR,
+  POINTS_DEFAULT_SIZE,
+  POINTS_DEFAULT_VISIBILITY,
+  POLYGONS_DEFAULT_COLOR,
+  POLYGONS_DEFAULT_VISIBILITY,
+  POLYHEDRA_DEFAULT_COLOR,
+  POLYHEDRA_DEFAULT_VISIBILITY,
+  type RGBAColor,
+} from "./constants";
+
+function emptyAttributeConfig(): AttributeConfig {
+  return { name: undefined, storedConfigs: {} };
+}
+
+interface MeshComponentColoring {
+  active: string;
+  constant: RGBAColor;
+  vertex: AttributeConfig;
+}
+
+interface MeshEdgesColoring extends MeshComponentColoring {
+  edge: AttributeConfig;
+}
+
+interface MeshCellsColoring extends MeshComponentColoring {
+  cell: AttributeConfig;
+  // oxlint-disable-next-line unicorn/no-null
+  textures: null;
+}
+
+interface MeshPolygonsColoring extends MeshComponentColoring {
+  // oxlint-disable-next-line unicorn/no-null
+  textures: null;
+  polygon: AttributeConfig;
+}
+
+interface MeshPolyhedraColoring extends MeshComponentColoring {
+  polyhedron: AttributeConfig;
+}
+
+interface MeshPointsStyle {
+  visibility: boolean;
+  coloring: MeshComponentColoring;
+  size: number;
+}
+
+interface MeshEdgesStyle {
+  visibility: boolean;
+  coloring: MeshEdgesColoring;
+  width: number;
+}
+
+interface MeshCellsStyle {
+  visibility: boolean;
+  coloring: MeshCellsColoring;
+}
+
+interface MeshPolygonsStyle {
+  visibility: boolean;
+  coloring: MeshPolygonsColoring;
+}
+
+interface MeshPolyhedraStyle {
+  visibility: boolean;
+  coloring: MeshPolyhedraColoring;
+}
+
+interface PointSetStyle {
+  visibility: boolean;
+  points: MeshPointsStyle;
+}
+
+interface EdgedCurveStyle {
+  visibility: boolean;
+  points: MeshPointsStyle;
+  edges: MeshEdgesStyle;
+}
+
+interface Grid2dStyle {
+  visibility: boolean;
+  points: MeshPointsStyle;
+  edges: MeshEdgesStyle;
+  cells: MeshCellsStyle;
+}
+
+interface Grid3dStyle {
+  visibility: boolean;
+  points: MeshPointsStyle;
+  edges: MeshEdgesStyle;
+  cells: MeshCellsStyle;
+  polyhedra: MeshPolyhedraStyle;
+}
+
+interface SurfaceStyle {
+  visibility: boolean;
+  points: MeshPointsStyle;
+  edges: MeshEdgesStyle;
+  polygons: MeshPolygonsStyle;
+}
+
+interface SolidStyle {
+  visibility: boolean;
+  points: MeshPointsStyle;
+  edges: MeshEdgesStyle;
+  polygons: MeshPolygonsStyle;
+  polyhedra: MeshPolyhedraStyle;
+}
+
+function meshPointsDefaultStyle(
+  visibility: boolean = POINTS_DEFAULT_VISIBILITY,
+  size: number = POINTS_DEFAULT_SIZE,
+  constant: RGBAColor = POINTS_DEFAULT_COLOR,
+): MeshPointsStyle {
+  return {
+    visibility,
+    coloring: {
+      active: MESH_DEFAULT_ACTIVE_COLORING,
+      constant,
+      vertex: emptyAttributeConfig(),
+    },
+    size,
+  };
+}
+
+function meshEdgesDefaultStyle(
+  visibility: boolean = EDGES_DEFAULT_VISIBILITY,
+  width: number = EDGES_DEFAULT_WIDTH,
+  constant: RGBAColor = EDGES_DEFAULT_COLOR,
+): MeshEdgesStyle {
+  return {
+    visibility,
+    coloring: {
+      active: MESH_DEFAULT_ACTIVE_COLORING,
+      constant,
+      edge: emptyAttributeConfig(),
+      vertex: emptyAttributeConfig(),
+    },
+    width,
+  };
+}
+
+function meshCellsDefaultStyle(
+  visibility: boolean = CELLS_DEFAULT_VISIBILITY,
+  constant: RGBAColor = CELLS_DEFAULT_COLOR,
+): MeshCellsStyle {
+  return {
+    visibility,
+    coloring: {
+      active: MESH_DEFAULT_ACTIVE_COLORING,
+      cell: emptyAttributeConfig(),
+      constant,
+      // oxlint-disable-next-line unicorn/no-null
+      textures: null,
+      vertex: emptyAttributeConfig(),
+    },
+  };
+}
+
+function meshPolygonsDefaultStyle(
+  visibility: boolean = POLYGONS_DEFAULT_VISIBILITY,
+  constant: RGBAColor = POLYGONS_DEFAULT_COLOR,
+): MeshPolygonsStyle {
+  return {
+    visibility,
+    coloring: {
+      active: MESH_DEFAULT_ACTIVE_COLORING,
+      constant,
+      // oxlint-disable-next-line unicorn/no-null
+      textures: null,
+      polygon: emptyAttributeConfig(),
+      vertex: emptyAttributeConfig(),
+    },
+  };
+}
+
+function meshPolyhedraDefaultStyle(
+  visibility: boolean = POLYHEDRA_DEFAULT_VISIBILITY,
+  constant: RGBAColor = POLYHEDRA_DEFAULT_COLOR,
+): MeshPolyhedraStyle {
+  return {
+    visibility,
+    coloring: {
+      active: MESH_DEFAULT_ACTIVE_COLORING,
+      constant,
+      polyhedron: emptyAttributeConfig(),
+      vertex: emptyAttributeConfig(),
+    },
+  };
+}
+
+function pointSetDefaultStyle(): PointSetStyle {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(),
+  };
+}
+
+function edgedCurveDefaultStyle(): EdgedCurveStyle {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(),
+    edges: meshEdgesDefaultStyle(),
+  };
+}
+
+function grid2dDefaultStyle(): Grid2dStyle {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    cells: meshCellsDefaultStyle(),
+  };
+}
+
+function grid3dDefaultStyle(): Grid3dStyle {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    cells: meshCellsDefaultStyle(),
+    polyhedra: meshPolyhedraDefaultStyle(),
+  };
+}
+
+function surfaceDefaultStyle(): SurfaceStyle {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    polygons: meshPolygonsDefaultStyle(),
+  };
+}
+
+function solidDefaultStyle(): SolidStyle {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    polygons: meshPolygonsDefaultStyle(),
+    polyhedra: meshPolyhedraDefaultStyle(),
+  };
+}
+
+export {
+  meshPointsDefaultStyle,
+  meshEdgesDefaultStyle,
+  meshCellsDefaultStyle,
+  meshPolygonsDefaultStyle,
+  meshPolyhedraDefaultStyle,
+  pointSetDefaultStyle,
+  edgedCurveDefaultStyle,
+  grid2dDefaultStyle,
+  grid3dDefaultStyle,
+  surfaceDefaultStyle,
+  solidDefaultStyle,
+};

package/app/utils/default_styles/{models.js → models.ts}

@@ -1,4 +1,5 @@
 import {
+  type AttributeConfig,
   BLOCKS_DEFAULT_ACTIVE_COLORING,
   BLOCKS_DEFAULT_COLOR,
   BLOCKS_DEFAULT_VISIBILITY,
@@ -14,102 +15,155 @@ import {
   MODEL_DEFAULT_COLOR,
   POINTS_DEFAULT_SIZE,
   POINTS_DEFAULT_VISIBILITY,
+  type RGBAColor,
   SURFACES_DEFAULT_ACTIVE_COLORING,
   SURFACES_DEFAULT_COLOR,
   SURFACES_DEFAULT_VISIBILITY,
 } from "./constants";
 
+function emptyAttributeConfig(): AttributeConfig {
+  return { name: undefined, storedConfigs: {} };
+}
+
+interface ModelComponentColoring {
+  active: string;
+  constant: RGBAColor;
+  vertex: AttributeConfig;
+}
+
+interface ModelLinesColoring extends ModelComponentColoring {
+  edge: AttributeConfig;
+}
+
+interface ModelSurfacesColoring extends ModelComponentColoring {
+  polygon: AttributeConfig;
+}
+
+interface ModelBlocksColoring extends ModelComponentColoring {
+  polyhedron: AttributeConfig;
+}
+
+interface ModelCornersStyle {
+  visibility: boolean;
+  coloring: ModelComponentColoring;
+}
+
+interface ModelLinesStyle {
+  visibility: boolean;
+  coloring: ModelLinesColoring;
+}
+
+interface ModelSurfacesStyle {
+  visibility: boolean;
+  coloring: ModelSurfacesColoring;
+}
+
+interface ModelBlocksStyle {
+  visibility: boolean;
+  coloring: ModelBlocksColoring;
+}
+
+interface ModelPointsStyle {
+  visibility: boolean;
+  size: number;
+}
+
+interface ModelEdgesStyle {
+  visibility: boolean;
+  width: number;
+}
+
+interface ModelWithBlocksStyle {
+  visibility: boolean;
+  coloring: { active: string; constant: RGBAColor };
+  corners: ModelCornersStyle;
+  lines: ModelLinesStyle;
+  surfaces: ModelSurfacesStyle;
+  blocks: ModelBlocksStyle;
+  points: ModelPointsStyle;
+  edges: ModelEdgesStyle;
+}
+
+interface ModelWithoutBlocksStyle {
+  visibility: boolean;
+  coloring: { active: string; constant: RGBAColor };
+  corners: ModelCornersStyle;
+  lines: ModelLinesStyle;
+  surfaces: ModelSurfacesStyle;
+  points: ModelPointsStyle;
+  edges: ModelEdgesStyle;
+}
+
 function modelCornersDefaultStyle(
-  visibility = CORNERS_DEFAULT_VISIBILITY,
-  constant = CORNERS_DEFAULT_COLOR,
-) {
+  visibility: boolean = CORNERS_DEFAULT_VISIBILITY,
+  constant: RGBAColor = CORNERS_DEFAULT_COLOR,
+): ModelCornersStyle {
   return {
     visibility,
     coloring: {
       active: CORNERS_DEFAULT_ACTIVE_COLORING,
       constant,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
+      vertex: emptyAttributeConfig(),
     },
   };
 }
 
 function modelLinesDefaultStyle(
-  visibility = LINES_DEFAULT_VISIBILITY,
-  constant = LINES_DEFAULT_COLOR,
-) {
+  visibility: boolean = LINES_DEFAULT_VISIBILITY,
+  constant: RGBAColor = LINES_DEFAULT_COLOR,
+): ModelLinesStyle {
   return {
     visibility,
     coloring: {
       active: LINES_DEFAULT_ACTIVE_COLORING,
       constant,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      edge: {
-        name: undefined,
-        storedConfigs: {},
-      },
+      vertex: emptyAttributeConfig(),
+      edge: emptyAttributeConfig(),
     },
   };
 }
 
 function modelSurfacesDefaultStyle(
-  visibility = SURFACES_DEFAULT_VISIBILITY,
-  constant = SURFACES_DEFAULT_COLOR,
-) {
+  visibility: boolean = SURFACES_DEFAULT_VISIBILITY,
+  constant: RGBAColor = SURFACES_DEFAULT_COLOR,
+): ModelSurfacesStyle {
   return {
     visibility,
     coloring: {
       active: SURFACES_DEFAULT_ACTIVE_COLORING,
       constant,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      polygon: {
-        name: undefined,
-        storedConfigs: {},
-      },
+      vertex: emptyAttributeConfig(),
+      polygon: emptyAttributeConfig(),
     },
   };
 }
 
 function modelBlocksDefaultStyle(
-  visibility = BLOCKS_DEFAULT_VISIBILITY,
-  constant = BLOCKS_DEFAULT_COLOR,
-) {
+  visibility: boolean = BLOCKS_DEFAULT_VISIBILITY,
+  constant: RGBAColor = BLOCKS_DEFAULT_COLOR,
+): ModelBlocksStyle {
   return {
     visibility,
     coloring: {
       active: BLOCKS_DEFAULT_ACTIVE_COLORING,
       constant,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      polyhedron: {
-        name: undefined,
-        storedConfigs: {},
-      },
+      vertex: emptyAttributeConfig(),
+      polyhedron: emptyAttributeConfig(),
     },
   };
 }
 
 function modelPointsDefaultStyle(
-  visibility = POINTS_DEFAULT_VISIBILITY,
-  size = POINTS_DEFAULT_SIZE,
-) {
+  visibility: boolean = POINTS_DEFAULT_VISIBILITY,
+  size: number = POINTS_DEFAULT_SIZE,
+): ModelPointsStyle {
   return { visibility, size };
 }
 
 function modelEdgesDefaultStyle(
-  visibility = EDGES_DEFAULT_VISIBILITY,
-  width = EDGES_DEFAULT_WIDTH,
-) {
+  visibility: boolean = EDGES_DEFAULT_VISIBILITY,
+  width: number = EDGES_DEFAULT_WIDTH,
+): ModelEdgesStyle {
   return { visibility, width };
 }
 
@@ -120,7 +174,7 @@ const DEFAULT_MODEL_COMPONENT_TYPE_STYLES = {
   Block: modelBlocksDefaultStyle(),
 };
 
-function brepDefaultStyle() {
+function brepDefaultStyle(): ModelWithBlocksStyle {
   return {
     visibility: true,
     coloring: {
@@ -136,7 +190,7 @@ function brepDefaultStyle() {
   };
 }
 
-function crossSectionDefaultStyle() {
+function crossSectionDefaultStyle(): ModelWithoutBlocksStyle {
   return {
     visibility: true,
     coloring: {
@@ -151,7 +205,7 @@ function crossSectionDefaultStyle() {
   };
 }
 
-function structuralModelDefaultStyle() {
+function structuralModelDefaultStyle(): ModelWithBlocksStyle {
   return {
     visibility: true,
     coloring: {
@@ -167,7 +221,7 @@ function structuralModelDefaultStyle() {
   };
 }
 
-function sectionDefaultStyle() {
+function sectionDefaultStyle(): ModelWithoutBlocksStyle {
   return {
     visibility: true,
     coloring: {
@@ -182,7 +236,7 @@ function sectionDefaultStyle() {
   };
 }
 
-function implicitCrossSectionDefaultStyle() {
+function implicitCrossSectionDefaultStyle(): ModelWithoutBlocksStyle {
   return {
     visibility: true,
     coloring: {
@@ -197,7 +251,7 @@ function implicitCrossSectionDefaultStyle() {
   };
 }
 
-function implicitStructuralModelDefaultStyle() {
+function implicitStructuralModelDefaultStyle(): ModelWithBlocksStyle {
   return {
     visibility: true,
     coloring: {

package/app/utils/{extension.js → extension.ts}

@@ -1,20 +1,42 @@
 // Node.js imports
 
 // Third party imports
-import _ from "lodash";
 
 // Local imports
+import type { RegisterableStore, useAppStore } from "@ogw_front/stores/app";
+import type { Microservice } from "@ogw_front/stores/infra";
 import { isCloudMode } from "@ogw_front/utils/stores";
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
-import { useAppStore } from "@ogw_front/stores/app";
-import { useInfraStore } from "@ogw_front/stores/infra";
 
-async function uploadExtension(file) {
+interface ExtensionDescriptor {
+  id: string;
+  name: string;
+  version: string;
+  frontendContent: string;
+  port: string;
+}
+
+interface DownloadExtensionParams {
+  url: string;
+  extensionFileName: string;
+}
+
+type AppStoreInstance = ReturnType<typeof useAppStore>;
+type ExtensionModuleType = Awaited<ReturnType<AppStoreInstance["loadExtension"]>>;
+interface RegisteredExtension {
+  name: string;
+  version: string;
+  extensionModule: ExtensionModuleType;
+}
+
+async function uploadExtension(file: File): Promise<void> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   await appStore.upload(file);
 }
 
-function runExtensions() {
+async function runExtensions(): Promise<{ extensionsArray: ExtensionDescriptor[] }> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { projectFolderPath } = appStore;
   const { PROJECT: projectName } = useRuntimeConfig().public;
@@ -25,13 +47,18 @@ function runExtensions() {
     projectFolderPath,
     projectName,
   };
-  return appStore.request({
+  const result = await appStore.request<{ extensionsArray: ExtensionDescriptor[] }>({
     schema,
     params,
   });
+  return result;
 }
 
-function downloadExtension({ url, extensionFileName }) {
+async function downloadExtension({
+  url,
+  extensionFileName,
+}: DownloadExtensionParams): Promise<unknown> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { PROJECT: projectName } = useRuntimeConfig().public;
   const schema = opengeodeweb_front_schemas.api.microservice.extensions.download;
@@ -40,18 +67,25 @@ function downloadExtension({ url, extensionFileName }) {
     url,
     extensionFileName,
   };
-  return appStore.request({
+  const result = await appStore.request({
     schema,
     params,
   });
+  return result;
+}
+
+function isMicroservice(store: RegisterableStore): store is RegisterableStore & Microservice {
+  return typeof store.connect === "function";
 }
 
-async function registerRunningExtensions() {
+async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
+  const { useInfraStore } = await import("@ogw_front/stores/infra");
   const appStore = useAppStore();
   const infraStore = useInfraStore();
   const { extensionsArray } = await runExtensions();
   return Promise.all(
-    extensionsArray.map(async (extension) => {
+    extensionsArray.map(async (extension: ExtensionDescriptor) => {
       const { id, name, version, frontendContent, port } = extension;
       const blob = new Blob([frontendContent], {
         type: "application/javascript",
@@ -63,7 +97,14 @@ async function registerRunningExtensions() {
       const store = storeFactory();
       appStore.registerStore(store);
       console.log("[ExtensionManager] Store registered:", store.$id);
-      infraStore.register_microservice(store);
+      // Extension-provided stores are expected to satisfy the fuller
+      // Microservice contract (connect, etc.) even though the loader's own
+      // RegisterableStore type only models what app.ts itself needs.
+      if (isMicroservice(store)) {
+        infraStore.register_microservice(store);
+      } else {
+        console.warn("[ExtensionManager] Store does not implement Microservice:", store.$id);
+      }
       return {
         name,
         version,
@@ -73,17 +114,18 @@ async function registerRunningExtensions() {
   );
 }
 
-async function importExtensionFile(file) {
+async function importExtensionFile(file: File): Promise<RegisteredExtension[]> {
   await uploadExtension(file);
   return registerRunningExtensions();
 }
 
-async function importExtensionURL(url) {
+async function importExtensionURL(url: DownloadExtensionParams): Promise<RegisteredExtension[]> {
   await downloadExtension(url);
   return registerRunningExtensions();
 }
 
-async function unloadExtension(extensionId) {
+async function unloadExtension(extensionId: string): Promise<boolean> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   console.log("[ExtensionManager] Unloading extension:", extensionId);
   const extensionData = appStore.getExtension(extensionId);
@@ -94,21 +136,22 @@ async function unloadExtension(extensionId) {
 
   // Get the store if it exists
   const storeFactory = extensionData.metadata?.store;
-  if (storeFactory) {
+  if (storeFactory !== undefined) {
     const store = storeFactory();
     // Stop the microservice if possible
-    if (typeof store.kill === "function") {
+    if (store.kill) {
       await store.kill();
     }
   }
 
   // Unload from AppStore
-  appStore.unloadExtension(extensionId);
+  await appStore.unloadExtension(extensionId);
   console.log("[ExtensionManager] Extension unloaded:", extensionId);
   return true;
 }
 
-function killExtension(extensionId) {
+async function killExtension(extensionId: string): Promise<unknown> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { projectFolderPath } = appStore;
   const { PROJECT: projectName } = useRuntimeConfig().public;
@@ -118,10 +161,11 @@ function killExtension(extensionId) {
     projectFolderPath,
     projectName,
   };
-  return appStore.request({
+  const result = await appStore.request({
     schema,
     params,
   });
+  return result;
 }
 export {
   importExtensionFile,