@geode/opengeodeweb-front 10.34.0-rc.12 → 10.34.0-rc.13

package/app/utils/log.ts

@@ -4,16 +4,16 @@ interface Loggable {
   $id: string;
 }
 
-function startRequestLog(microservice: Readonly<Loggable>, schema: Readonly<JsonRpcSchema>): Date {
+function startRequestLog(microservice: Loggable, schema: JsonRpcSchema): Date {
   console.log(`[${microservice.$id}] Request:`, schema.$id);
   const requestStartingTime = new Date(Date.now());
   return requestStartingTime;
 }
 
 function endRequestLog(
-  microservice: Readonly<Loggable>,
-  schema: Readonly<JsonRpcSchema>,
-  requestStartingTime: Readonly<Date>,
+  microservice: Loggable,
+  schema: JsonRpcSchema,
+  requestStartingTime: Date,
 ): void {
   const requestEndingTime = new Date(Date.now());
   console.log(

package/internal/stores/data_style/mesh/cells/index.ts

@@ -12,16 +12,16 @@ import { useMeshCellsVisibilityStyle } from "./visibility";
 // Local constants
 
 interface MeshCellsActiveColoringDeps {
-  readonly commonStyle: Readonly<ReturnType<typeof useMeshCellsCommonStyle>>;
-  readonly colorStyle: Readonly<ReturnType<typeof useMeshCellsColorStyle>>;
-  readonly texturesStyle: Readonly<ReturnType<typeof useMeshCellsTexturesStyle>>;
-  readonly vertexAttributeStyle: Readonly<ReturnType<typeof useMeshCellsVertexAttributeStyle>>;
-  readonly cellAttributeStyle: Readonly<ReturnType<typeof useMeshCellsCellAttributeStyle>>;
+  readonly commonStyle: ReturnType<typeof useMeshCellsCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshCellsColorStyle>;
+  readonly texturesStyle: ReturnType<typeof useMeshCellsTexturesStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshCellsVertexAttributeStyle>;
+  readonly cellAttributeStyle: ReturnType<typeof useMeshCellsCellAttributeStyle>;
 }
 
 function handleMeshCellsVertexColoring(
   id: string,
-  vertexAttributeStyle: Readonly<ReturnType<typeof useMeshCellsVertexAttributeStyle>>,
+  vertexAttributeStyle: ReturnType<typeof useMeshCellsVertexAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = vertexAttributeStyle.meshCellsVertexAttributeName(id);
   const item = vertexAttributeStyle.meshCellsVertexAttributeItem(id);
@@ -36,7 +36,7 @@ function handleMeshCellsVertexColoring(
 
 function handleMeshCellsCellColoring(
   id: string,
-  cellAttributeStyle: Readonly<ReturnType<typeof useMeshCellsCellAttributeStyle>>,
+  cellAttributeStyle: ReturnType<typeof useMeshCellsCellAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = cellAttributeStyle.meshCellsCellAttributeName(id);
   const item = cellAttributeStyle.meshCellsCellAttributeItem(id);
@@ -52,7 +52,7 @@ function handleMeshCellsCellColoring(
 async function setMeshCellsActiveColoring(
   id: string,
   type: string | undefined,
-  deps: Readonly<MeshCellsActiveColoringDeps>,
+  deps: MeshCellsActiveColoringDeps,
 ): Promise<unknown> {
   await deps.commonStyle.mutateMeshCellsStyle(id, {
     coloring: { active: type },
@@ -81,9 +81,9 @@ async function setMeshCellsActiveColoring(
 
 async function applyMeshCellsStyle(
   id: string,
-  visibilityStyle: Readonly<ReturnType<typeof useMeshCellsVisibilityStyle>>,
+  visibilityStyle: ReturnType<typeof useMeshCellsVisibilityStyle>,
   activeColoringType: string | undefined,
-  deps: Readonly<MeshCellsActiveColoringDeps>,
+  deps: MeshCellsActiveColoringDeps,
 ): Promise<unknown[]> {
   const result = await Promise.all([
     visibilityStyle.setMeshCellsVisibility(id, visibilityStyle.meshCellsVisibility(id)),

package/internal/stores/data_style/mesh/edges/index.ts

@@ -12,15 +12,15 @@ import { useMeshEdgesWidthStyle } from "./width";
 // Local constants
 
 interface MeshEdgesActiveColoringDeps {
-  readonly commonStyle: Readonly<ReturnType<typeof useMeshEdgesCommonStyle>>;
-  readonly colorStyle: Readonly<ReturnType<typeof useMeshEdgesColorStyle>>;
-  readonly vertexAttributeStyle: Readonly<ReturnType<typeof useMeshEdgesVertexAttributeStyle>>;
-  readonly edgeAttributeStyle: Readonly<ReturnType<typeof useMeshEdgesEdgeAttributeStyle>>;
+  readonly commonStyle: ReturnType<typeof useMeshEdgesCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshEdgesColorStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshEdgesVertexAttributeStyle>;
+  readonly edgeAttributeStyle: ReturnType<typeof useMeshEdgesEdgeAttributeStyle>;
 }
 
 function handleMeshEdgesVertexColoring(
   id: string,
-  vertexAttributeStyle: Readonly<ReturnType<typeof useMeshEdgesVertexAttributeStyle>>,
+  vertexAttributeStyle: ReturnType<typeof useMeshEdgesVertexAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = vertexAttributeStyle.meshEdgesVertexAttributeName(id);
   const item = vertexAttributeStyle.meshEdgesVertexAttributeItem(id);
@@ -35,7 +35,7 @@ function handleMeshEdgesVertexColoring(
 
 function handleMeshEdgesEdgeColoring(
   id: string,
-  edgeAttributeStyle: Readonly<ReturnType<typeof useMeshEdgesEdgeAttributeStyle>>,
+  edgeAttributeStyle: ReturnType<typeof useMeshEdgesEdgeAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = edgeAttributeStyle.meshEdgesEdgeAttributeName(id);
   const item = edgeAttributeStyle.meshEdgesEdgeAttributeItem(id);
@@ -51,7 +51,7 @@ function handleMeshEdgesEdgeColoring(
 async function setMeshEdgesActiveColoring(
   id: string,
   type: string | undefined,
-  deps: Readonly<MeshEdgesActiveColoringDeps>,
+  deps: MeshEdgesActiveColoringDeps,
 ): Promise<unknown> {
   await deps.commonStyle.mutateMeshEdgesStyle(id, {
     coloring: { active: type },
@@ -73,10 +73,10 @@ async function setMeshEdgesActiveColoring(
 
 async function applyMeshEdgesStyle(
   id: string,
-  visibilityStyle: Readonly<ReturnType<typeof useMeshEdgesVisibilityStyle>>,
-  widthStyle: Readonly<ReturnType<typeof useMeshEdgesWidthStyle>>,
+  visibilityStyle: ReturnType<typeof useMeshEdgesVisibilityStyle>,
+  widthStyle: ReturnType<typeof useMeshEdgesWidthStyle>,
   activeColoringType: string | undefined,
-  deps: Readonly<MeshEdgesActiveColoringDeps>,
+  deps: MeshEdgesActiveColoringDeps,
 ): Promise<unknown[]> {
   const result = await Promise.all([
     visibilityStyle.setMeshEdgesVisibility(id, visibilityStyle.meshEdgesVisibility(id)),

package/internal/stores/data_style/mesh/points/common.ts

@@ -6,9 +6,7 @@ export function useMeshPointsCommonStyle(): {
   meshPointsColoring: (id: string) => StyleValues;
   mutateMeshPointsColoring: (id: string, values: StyleValues) => Promise<string>;
   mutateMeshPointsStyle: (id: string, values: StyleValues) => Promise<string>;
-  mutateMeshPointsVisibility: (
-    response: Readonly<{ id: string; visibility: boolean }>,
-  ) => Promise<string>;
+  mutateMeshPointsVisibility: (response: { id: string; visibility: boolean }) => Promise<string>;
 } {
   const dataStyleState = useDataStyleState();
 
@@ -19,9 +17,10 @@ export function useMeshPointsCommonStyle(): {
     return result;
   }
 
-  async function mutateMeshPointsVisibility(
-    response: Readonly<{ id: string; visibility: boolean }>,
-  ): Promise<string> {
+  async function mutateMeshPointsVisibility(response: {
+    id: string;
+    visibility: boolean;
+  }): Promise<string> {
     const result = await mutateMeshPointsStyle(response.id, { visibility: response.visibility });
     return result;
   }

package/internal/stores/data_style/mesh/points/index.ts

@@ -11,14 +11,14 @@ import { useMeshPointsVisibilityStyle } from "./visibility";
 // Local constants
 
 interface MeshPointsActiveColoringDeps {
-  readonly commonStyle: Readonly<ReturnType<typeof useMeshPointsCommonStyle>>;
-  readonly colorStyle: Readonly<ReturnType<typeof useMeshPointsColorStyle>>;
-  readonly vertexAttributeStyle: Readonly<ReturnType<typeof useMeshPointsVertexAttributeStyle>>;
+  readonly commonStyle: ReturnType<typeof useMeshPointsCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshPointsColorStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshPointsVertexAttributeStyle>;
 }
 
 function handleMeshPointsVertexColoring(
   id: string,
-  vertexAttributeStyle: Readonly<ReturnType<typeof useMeshPointsVertexAttributeStyle>>,
+  vertexAttributeStyle: ReturnType<typeof useMeshPointsVertexAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = vertexAttributeStyle.meshPointsVertexAttributeName(id);
   const item = vertexAttributeStyle.meshPointsVertexAttributeItem(id);
@@ -34,7 +34,7 @@ function handleMeshPointsVertexColoring(
 async function setMeshPointsActiveColoring(
   id: string,
   type: string | undefined,
-  deps: Readonly<MeshPointsActiveColoringDeps>,
+  deps: MeshPointsActiveColoringDeps,
 ): Promise<unknown> {
   await deps.commonStyle.mutateMeshPointsStyle(id, {
     coloring: { active: type },
@@ -55,10 +55,10 @@ async function setMeshPointsActiveColoring(
 
 async function applyMeshPointsStyle(
   id: string,
-  visibilityStyle: Readonly<ReturnType<typeof useMeshPointsVisibilityStyle>>,
-  sizeStyle: Readonly<ReturnType<typeof useMeshPointsSizeStyle>>,
+  visibilityStyle: ReturnType<typeof useMeshPointsVisibilityStyle>,
+  sizeStyle: ReturnType<typeof useMeshPointsSizeStyle>,
   activeColoringType: string | undefined,
-  deps: Readonly<MeshPointsActiveColoringDeps>,
+  deps: MeshPointsActiveColoringDeps,
 ): Promise<unknown[]> {
   const result = await Promise.all([
     visibilityStyle.setMeshPointsVisibility(id, visibilityStyle.meshPointsVisibility(id)),

package/internal/stores/data_style/mesh/polygons/index.ts

@@ -15,16 +15,16 @@ import { useMeshPolygonsVisibilityStyle } from "./visibility";
 // Local constants
 
 interface MeshPolygonsActiveColoringDeps {
-  readonly commonStyle: Readonly<ReturnType<typeof useMeshPolygonsCommonStyle>>;
-  readonly colorStyle: Readonly<ReturnType<typeof useMeshPolygonsColorStyle>>;
-  readonly texturesStyle: Readonly<ReturnType<typeof useMeshPolygonsTexturesStyle>>;
-  readonly vertexAttributeStyle: Readonly<ReturnType<typeof useMeshPolygonsVertexAttributeStyle>>;
-  readonly polygonAttributeStyle: Readonly<ReturnType<typeof useMeshPolygonsPolygonAttributeStyle>>;
+  readonly commonStyle: ReturnType<typeof useMeshPolygonsCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshPolygonsColorStyle>;
+  readonly texturesStyle: ReturnType<typeof useMeshPolygonsTexturesStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshPolygonsVertexAttributeStyle>;
+  readonly polygonAttributeStyle: ReturnType<typeof useMeshPolygonsPolygonAttributeStyle>;
 }
 
 function handleMeshPolygonsVertexColoring(
   id: string,
-  vertexAttributeStyle: Readonly<ReturnType<typeof useMeshPolygonsVertexAttributeStyle>>,
+  vertexAttributeStyle: ReturnType<typeof useMeshPolygonsVertexAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = vertexAttributeStyle.meshPolygonsVertexAttributeName(id);
   const item = vertexAttributeStyle.meshPolygonsVertexAttributeItem(id);
@@ -39,7 +39,7 @@ function handleMeshPolygonsVertexColoring(
 
 function handleMeshPolygonsPolygonColoring(
   id: string,
-  polygonAttributeStyle: Readonly<ReturnType<typeof useMeshPolygonsPolygonAttributeStyle>>,
+  polygonAttributeStyle: ReturnType<typeof useMeshPolygonsPolygonAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = polygonAttributeStyle.meshPolygonsPolygonAttributeName(id);
   const item = polygonAttributeStyle.meshPolygonsPolygonAttributeItem(id);
@@ -55,7 +55,7 @@ function handleMeshPolygonsPolygonColoring(
 async function setMeshPolygonsActiveColoring(
   id: string,
   type: string | undefined,
-  deps: Readonly<MeshPolygonsActiveColoringDeps>,
+  deps: MeshPolygonsActiveColoringDeps,
 ): Promise<unknown> {
   await deps.commonStyle.mutateMeshPolygonsStyle(id, {
     coloring: { active: type },
@@ -87,9 +87,9 @@ async function setMeshPolygonsActiveColoring(
 
 async function applyMeshPolygonsStyle(
   id: string,
-  visibilityStyle: Readonly<ReturnType<typeof useMeshPolygonsVisibilityStyle>>,
+  visibilityStyle: ReturnType<typeof useMeshPolygonsVisibilityStyle>,
   activeColoringType: string | undefined,
-  deps: Readonly<MeshPolygonsActiveColoringDeps>,
+  deps: MeshPolygonsActiveColoringDeps,
 ): Promise<unknown[]> {
   const result = await Promise.all([
     visibilityStyle.setMeshPolygonsVisibility(id, visibilityStyle.meshPolygonsVisibility(id)),

package/internal/stores/data_style/mesh/polyhedra/index.ts

@@ -17,17 +17,15 @@ import { useMeshPolyhedraVisibilityStyle } from "./visibility";
 // Local constants
 
 interface MeshPolyhedraActiveColoringDeps {
-  readonly commonStyle: Readonly<ReturnType<typeof useMeshPolyhedraCommonStyle>>;
-  readonly colorStyle: Readonly<ReturnType<typeof useMeshPolyhedraColorStyle>>;
-  readonly vertexAttributeStyle: Readonly<ReturnType<typeof useMeshPolyhedraVertexAttributeStyle>>;
-  readonly polyhedronAttributeStyle: Readonly<
-    ReturnType<typeof useMeshPolyhedraPolyhedronAttributeStyle>
-  >;
+  readonly commonStyle: ReturnType<typeof useMeshPolyhedraCommonStyle>;
+  readonly colorStyle: ReturnType<typeof useMeshPolyhedraColorStyle>;
+  readonly vertexAttributeStyle: ReturnType<typeof useMeshPolyhedraVertexAttributeStyle>;
+  readonly polyhedronAttributeStyle: ReturnType<typeof useMeshPolyhedraPolyhedronAttributeStyle>;
 }
 
 function handleMeshPolyhedraVertexColoring(
   id: string,
-  vertexAttributeStyle: Readonly<ReturnType<typeof useMeshPolyhedraVertexAttributeStyle>>,
+  vertexAttributeStyle: ReturnType<typeof useMeshPolyhedraVertexAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = vertexAttributeStyle.meshPolyhedraVertexAttributeName(id);
   const item = vertexAttributeStyle.meshPolyhedraVertexAttributeItem(id);
@@ -42,7 +40,7 @@ function handleMeshPolyhedraVertexColoring(
 
 function handleMeshPolyhedraPolyhedronColoring(
   id: string,
-  polyhedronAttributeStyle: Readonly<ReturnType<typeof useMeshPolyhedraPolyhedronAttributeStyle>>,
+  polyhedronAttributeStyle: ReturnType<typeof useMeshPolyhedraPolyhedronAttributeStyle>,
 ): Promise<unknown> | undefined {
   const name = polyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeName(id);
   const item = polyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeItem(id);
@@ -58,7 +56,7 @@ function handleMeshPolyhedraPolyhedronColoring(
 async function setMeshPolyhedraActiveColoring(
   id: string,
   type: string | undefined,
-  deps: Readonly<MeshPolyhedraActiveColoringDeps>,
+  deps: MeshPolyhedraActiveColoringDeps,
 ): Promise<unknown> {
   await deps.commonStyle.mutateMeshPolyhedraStyle(id, {
     coloring: { active: type },
@@ -83,9 +81,9 @@ async function setMeshPolyhedraActiveColoring(
 
 async function applyMeshPolyhedraStyle(
   id: string,
-  visibilityStyle: Readonly<ReturnType<typeof useMeshPolyhedraVisibilityStyle>>,
+  visibilityStyle: ReturnType<typeof useMeshPolyhedraVisibilityStyle>,
   activeColoringType: string | undefined,
-  deps: Readonly<MeshPolyhedraActiveColoringDeps>,
+  deps: MeshPolyhedraActiveColoringDeps,
 ): Promise<unknown[]> {
   const result = await Promise.all([
     visibilityStyle.setMeshPolyhedraVisibility(id, visibilityStyle.meshPolyhedraVisibility(id)),

package/internal/stores/data_style/state.ts

@@ -18,26 +18,26 @@ interface SharedState {
   updateComponentStyleCache: (
     modelId: string,
     componentId: string,
-    styleValues: Readonly<StyleValues>,
+    styleValues: StyleValues,
   ) => void;
   bulkUpdateComponentStyleCache: (
     modelId: string,
     componentStyleUpdates: readonly {
       readonly id_component: string;
-      readonly values: Readonly<StyleValues>;
+      readonly values: StyleValues;
     }[],
   ) => void;
   bulkUpdateComponentStylesCache: (
     modelId: string,
     componentIds: readonly string[],
-    styleValues: Readonly<StyleValues>,
+    styleValues: StyleValues,
   ) => void;
   updateModelComponentTypeStyleCache: (
     modelId: string,
     componentType: string,
-    styleValues: Readonly<StyleValues>,
+    styleValues: StyleValues,
   ) => void;
-  updateStyleCache: (objectId: string, styleValues: Readonly<StyleValues>) => void;
+  updateStyleCache: (objectId: string, styleValues: StyleValues) => void;
 }
 
 let sharedState: SharedState | undefined = undefined;
@@ -100,7 +100,7 @@ function getSharedState(): SharedState {
   function updateComponentStyleCache(
     modelId: string,
     componentId: string,
-    styleValues: Readonly<StyleValues>,
+    styleValues: StyleValues,
   ): void {
     const cacheKey = `${modelId}_${componentId}`;
     const existingStyle = componentStyles.value[cacheKey];
@@ -118,7 +118,7 @@ function getSharedState(): SharedState {
     modelId: string,
     componentStyleUpdates: readonly {
       readonly id_component: string;
-      readonly values: Readonly<StyleValues>;
+      readonly values: StyleValues;
     }[],
   ): void {
     const updatedComponentStyles = { ...componentStyles.value };
@@ -140,7 +140,7 @@ function getSharedState(): SharedState {
   function bulkUpdateComponentStylesCache(
     modelId: string,
     componentIds: readonly string[],
-    styleValues: Readonly<StyleValues>,
+    styleValues: StyleValues,
   ): void {
     const updatedComponentStyles = { ...componentStyles.value };
     for (const componentId of componentIds) {
@@ -161,14 +161,14 @@ function getSharedState(): SharedState {
   function updateModelComponentTypeStyleCache(
     modelId: string,
     componentType: string,
-    styleValues: Readonly<StyleValues>,
+    styleValues: StyleValues,
   ): void {
     const cacheKey = `${modelId}_${componentType}`;
     modelComponentTypeStyles.value[cacheKey] ??= { id_model: modelId, type: componentType };
     merge(modelComponentTypeStyles.value[cacheKey], styleValues);
   }
 
-  function updateStyleCache(objectId: string, styleValues: Readonly<StyleValues>): void {
+  function updateStyleCache(objectId: string, styleValues: StyleValues): void {
     styles.value[objectId] ??= { id: objectId };
     merge(styles.value[objectId], styleValues);
   }
@@ -192,7 +192,7 @@ interface DataStyleStateApi extends SharedState {
   getStyle: (objectId: string) => ObjectStyle;
   getComponentStyle: (modelId: string, componentId: string) => ModelComponentStyle;
   getModelComponentTypeStyle: (modelId: string, componentType: string) => ModelComponentTypeStyle;
-  mutateStyle: (objectId: string, styleValues: Readonly<StyleValues>) => Promise<string>;
+  mutateStyle: (objectId: string, styleValues: StyleValues) => Promise<string>;
   objectVisibility: ComputedRef<(objectId: string) => boolean | undefined>;
   selectedObjects: ComputedRef<string[]>;
   clear: () => Promise<void>;
@@ -235,10 +235,7 @@ export function useDataStyleState(): DataStyleStateApi {
     return { ...toRaw(style) };
   }
 
-  async function mutateStyle(
-    objectId: string,
-    styleValues: Readonly<StyleValues>,
-  ): Promise<string> {
+  async function mutateStyle(objectId: string, styleValues: StyleValues): Promise<string> {
     state.updateStyleCache(objectId, styleValues);
     const currentStyle = getStyle(objectId);
     merge(currentStyle, styleValues);

package/internal/stores/hybrid_viewer/brightness.ts

@@ -28,11 +28,7 @@ interface RelativeRect {
   relH: number;
 }
 
-function mapRect(
-  rect: Readonly<Rect>,
-  latestImage: Readonly<DrawableImage>,
-  canvasRect: Readonly<DOMRect>,
-): RelativeRect {
+function mapRect(rect: Rect, latestImage: DrawableImage, canvasRect: DOMRect): RelativeRect {
   const scaleX = latestImage.width / canvasRect.width;
   const scaleY = latestImage.height / canvasRect.height;
   return {
@@ -45,8 +41,8 @@ function mapRect(
 
 function sampleMinBrightness(
   ctx: CanvasRenderingContext2D,
-  image: Readonly<DrawableImage>,
-  relRect: Readonly<RelativeRect>,
+  image: DrawableImage,
+  relRect: RelativeRect,
 ): number {
   ctx.drawImage(
     image,
@@ -70,10 +66,7 @@ function sampleMinBrightness(
   return minBrightness;
 }
 
-function computeAverageBrightness(
-  rect: Readonly<Rect>,
-  options: Readonly<BrightnessOptions>,
-): number {
+function computeAverageBrightness(rect: Rect, options: BrightnessOptions): number {
   const { latestImage, offscreenCtx, offscreenCanvas } = options;
   const { genericRenderWindow } = useHybridViewerCore();
   if (!latestImage || !offscreenCtx || !offscreenCanvas || !genericRenderWindow.value) {
@@ -106,7 +99,7 @@ function computeAverageBrightness(
 }
 function useHybridViewerBrightness(): {
   latestImage: Ref<DrawableImage | undefined>;
-  getAverageBrightness: (rect: Readonly<Rect>) => number;
+  getAverageBrightness: (rect: Rect) => number;
 } {
   const latestImage = ref<DrawableImage | undefined>(undefined);
   const offscreenCanvas: HTMLCanvasElement | undefined =
@@ -116,7 +109,7 @@ function useHybridViewerBrightness(): {
         willReadFrequently: true,
       }) ?? undefined)
     : undefined;
-  function getAverageBrightness(rect: Readonly<Rect>): number {
+  function getAverageBrightness(rect: Rect): number {
     return computeAverageBrightness(rect, {
       latestImage: latestImage.value,
       offscreenCtx,

package/internal/stores/hybrid_viewer/core.ts

@@ -9,7 +9,7 @@ interface GenericRenderWindowHolder {
 }
 
 // `genericRenderWindow.value` is only ever read from these functions after the viewer has been initialized (see app/stores/hybrid_viewer.ts's initHybridViewer), so requireRenderWindow throwing on that path would indicate a real bug rather than an expected state.
-function requireRenderWindow(holder: Readonly<GenericRenderWindowHolder>): VtkGenericRenderWindow {
+function requireRenderWindow(holder: GenericRenderWindowHolder): VtkGenericRenderWindow {
   if (!holder.value) {
     throw new Error("genericRenderWindow accessed before the viewer was initialized");
   }

package/package.json

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

package/server/api/microservice/extensions/download.post.ts

@@ -21,7 +21,7 @@ export default defineEventHandler(async (event: H3Event) => {
     const body = await readBody<DownloadExtensionBody>(event);
     const { projectName, url, extensionFileName } = body;
     console.log({ projectName, url, extensionFileName });
-    const response: Readonly<Response> = await fetch(url);
+    const response: Response = await fetch(url);
     const fileBuffer = await response.arrayBuffer();
     const filePath = targetExtensionFilePath(projectName, extensionFileName);
     await fs.writeFile(filePath, Buffer.from(fileBuffer));

package/server/utils/app_config.ts

@@ -45,7 +45,7 @@ function extensionsConf(projectName: string): ExtensionsConfigSchema["extensions
 
 function addExtensionToConf(
   projectName: string,
-  { extensionId, extensionPath }: Readonly<{ extensionId: string; extensionPath: string }>,
+  { extensionId, extensionPath }: { extensionId: string; extensionPath: string },
 ): void {
   const projectConfig = projectConf(projectName);
   projectConfig.set(`extensions.${extensionId}.path`, extensionPath);

package/server/utils/cleanup.ts

@@ -53,7 +53,7 @@ function isErrorWithMessage(error: unknown): error is { message: string } {
   );
 }
 
-async function killHttpMicroservice(microservice: Readonly<Microservice>): Promise<void> {
+async function killHttpMicroservice(microservice: Microservice): Promise<void> {
   console.log("killHttpMicroservice", {
     ...microservice,
   });
@@ -77,7 +77,7 @@ async function killHttpMicroservice(microservice: Readonly<Microservice>): Promi
   });
 }
 
-async function killWebsocketMicroservice(microservice: Readonly<Microservice>): Promise<void> {
+async function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
   console.log("killWebsocketMicroservice", {
     ...microservice,
   });
@@ -124,7 +124,7 @@ async function killWebsocketMicroservice(microservice: Readonly<Microservice>):
         console.log(successMessage);
         resolve();
       });
-      socket.on("error", (error: Readonly<Error>) => {
+      socket.on("error", (error: Error) => {
         console.error("WebSocket error:", error);
         socket.close();
         resolve();
@@ -137,7 +137,7 @@ async function killWebsocketMicroservice(microservice: Readonly<Microservice>):
   });
 }
 
-async function killMicroservice(microservice: Readonly<Microservice>): Promise<void> {
+async function killMicroservice(microservice: Microservice): Promise<void> {
   if (microservice.type === "back") {
     await killHttpMicroservice(microservice);
   } else if (microservice.type === "viewer") {
@@ -148,9 +148,7 @@ async function killMicroservice(microservice: Readonly<Microservice>): Promise<v
   }
 }
 
-async function killMicroservices(
-  microservices: readonly Readonly<Microservice>[],
-): Promise<Readonly<Microservice>[]> {
+async function killMicroservices(microservices: readonly Microservice[]): Promise<Microservice[]> {
   console.log("killMicroservices", {
     microservices,
   });
@@ -203,7 +201,7 @@ async function cleanupBackend(projectFolderPath: string): Promise<void> {
 }
 
 function getMicroserviceByName(
-  microservices: readonly Readonly<Microservice>[],
+  microservices: readonly Microservice[],
   name: string,
 ): Microservice | undefined {
   const found = microservices.find((microservice) => microservice.name === name);

package/server/utils/microservices.ts

@@ -21,7 +21,7 @@ interface RunArgs {
 const MILLISECONDS_PER_SECOND = 1000;
 const DEFAULT_TIMEOUT_SECONDS = 45;
 const MAX_PORT_RETRIES = 1;
-const DEFAULT_RUN_ARGS: Readonly<RunArgs> = { projectFolderPath: "" };
+const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
 
 async function runScript(
   execPath: string,
@@ -61,7 +61,7 @@ function isPortInUseError(error: unknown): boolean {
   return /EADDRINUSE|address already in use|port already in use/iu.test(String(error));
 }
 
-function backArgs(args: Readonly<RunArgs>, port: number): string[] {
+function backArgs(args: RunArgs, port: number): string[] {
   const { projectFolderPath } = args;
   if (!projectFolderPath) {
     throw new Error("projectFolderPath is required");
@@ -91,7 +91,7 @@ function backArgs(args: Readonly<RunArgs>, port: number): string[] {
 async function runBack(
   execName: string,
   execPath: string,
-  args: Readonly<RunArgs> = DEFAULT_RUN_ARGS,
+  args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
 ): Promise<number> {
   let port: number | undefined = undefined;
@@ -118,7 +118,7 @@ async function runBack(
 async function runViewer(
   execName: string,
   execPath: string,
-  args: Readonly<RunArgs> = DEFAULT_RUN_ARGS,
+  args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
 ): Promise<number> {
   const { projectFolderPath } = args;
@@ -157,7 +157,7 @@ async function runExtension(
   extensionId: string,
   execName: string,
   execPath: string,
-  args: Readonly<RunArgs> = DEFAULT_RUN_ARGS,
+  args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
 ): Promise<number> {
   let port: number | undefined = undefined;
@@ -182,10 +182,7 @@ async function runExtension(
   }
   throw new Error(`runExtension failed to run ${extensionId}`);
 }
-function addMicroserviceMetadatas(
-  projectFolderPath: string,
-  serviceObj: Readonly<Microservice>,
-): void {
+function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
   let enriched: Microservice = { ...serviceObj };
   if (serviceObj.type === "back") {

package/server/utils/scripts.ts

@@ -46,7 +46,7 @@ interface NamedChildProcess extends child_process.ChildProcessByStdio<null, Read
 async function waitForReady(
   child: NamedChildProcess,
   expectedResponse: string,
-  signal?: Readonly<AbortSignal>,
+  signal?: AbortSignal,
 ): Promise<NamedChildProcess> {
   // oxlint-disable-next-line promise/avoid-new
   return new Promise((resolve, reject) => {
@@ -74,7 +74,7 @@ async function waitForReady(
     }
     let onLine: ((line: string) => void) | undefined = undefined;
     let onErrLine: ((line: string) => void) | undefined = undefined;
-    let onError: ((err: Readonly<Error>) => void) | undefined = undefined;
+    let onError: ((err: Error) => void) | undefined = undefined;
     let onClose: ((code: number | null) => void) | undefined = undefined;
     let onAbort: (() => void) | undefined = undefined;