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

package/app/utils/import_workflow.ts

@@ -15,9 +15,9 @@ interface FileToImport {
   readonly geode_object_type: string;
 }
 
-// NewDataItem has mutable array fields (mesh_components, collection_components), so Readonly<>
-// Can't satisfy prefer-readonly-parameter-types deeply; left unfixed (same pattern as app/plugins/auto_store_register.ts).
-async function importItem(item: Readonly<NewDataItem>): Promise<string> {
+// NewDataItem has mutable array fields (mesh_components, collection_components), so it can't
+// Satisfy prefer-readonly-parameter-types deeply; left unfixed (same pattern as app/plugins/auto_store_register.ts).
+async function importItem(item: NewDataItem): Promise<string> {
   const dataStore = useDataStore();
   const dataStyleStore = useDataStyleStore();
   const hybridViewerStore = useHybridViewerStore();

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/camera.ts

@@ -110,13 +110,21 @@ function centerCameraOnPosition(
   if (!camera || !pickedPosition) {
     return;
   }
-  const focalPoint = camera.getFocalPoint();
   const position = camera.getPosition();
+  const directionOfProjection = camera.getDirectionOfProjection();
+  const distance = dot(
+    [
+      pickedPosition[0] - position[0],
+      pickedPosition[1] - position[1],
+      pickedPosition[2] - position[2],
+    ],
+    directionOfProjection,
+  );
   camera.setFocalPoint(...pickedPosition);
   camera.setPosition(
-    position[0] + pickedPosition[0] - focalPoint[0],
-    position[1] + pickedPosition[1] - focalPoint[1],
-    position[2] + pickedPosition[2] - focalPoint[2],
+    pickedPosition[0] - distance * directionOfProjection[0],
+    pickedPosition[1] - distance * directionOfProjection[1],
+    pickedPosition[2] - distance * directionOfProjection[2],
   );
 }
 

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/internal/stores/hybrid_viewer/filters.ts

@@ -2,7 +2,7 @@ import { useHybridViewerCore } from "./core";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
-async function performSetClippingPlanes(ids: string[], planes: unknown): Promise<void> {
+async function setClippingPlanes(ids: string[], planes: unknown): Promise<void> {
   const viewerStore = useViewerStore();
   const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.clipping_planes;
@@ -16,7 +16,7 @@ async function performSetClippingPlanes(ids: string[], planes: unknown): Promise
   });
   await remoteRender();
 }
-async function performSetShrink(ids: string[], shrink_factor: number): Promise<void> {
+async function setShrink(ids: string[], shrink_factor: number): Promise<void> {
   const viewerStore = useViewerStore();
   const { remoteRender } = useHybridViewerCore();
   const schema = viewer_schemas.opengeodeweb_viewer.viewer.shrink;
@@ -34,15 +34,9 @@ function useHybridViewerFilters(): {
   setClippingPlanes: (ids: string[], planes: unknown) => Promise<void>;
   setShrink: (ids: string[], shrink_factor: number) => Promise<void>;
 } {
-  async function setClippingPlanes(ids: string[], planes: unknown): Promise<void> {
-    await performSetClippingPlanes(ids, planes);
-  }
-  async function setShrink(ids: string[], shrink_factor: number): Promise<void> {
-    await performSetShrink(ids, shrink_factor);
-  }
   return {
     setClippingPlanes,
     setShrink,
   };
 }
-export { performSetClippingPlanes, performSetShrink, useHybridViewerFilters };
+export { useHybridViewerFilters };

package/internal/stores/hybrid_viewer/viewport.ts

@@ -15,7 +15,7 @@ interface HybridViewerViewport {
   viewStream: Ref<ViewStreamLike | undefined>;
 }
 
-async function performResize(width: number, height: number): Promise<void> {
+async function resize(width: number, height: number): Promise<void> {
   const { genericRenderWindow, remoteRender, status, viewStream } = useHybridViewerCore();
   const viewerStore = useViewerStore();
   if (viewerStore.status !== Status.CONNECTED || status.value !== Status.CREATED) {
@@ -77,7 +77,7 @@ function performClickPicking(event: MouseEvent, containerElement: HTMLElement):
   );
 }
 
-function performSetContainer(container: ContainerRef | undefined): void {
+function setContainer(container: ContainerRef | undefined): void {
   if (!container || !container.value) {
     return;
   }
@@ -102,7 +102,7 @@ function performSetContainer(container: ContainerRef | undefined): void {
     transition: "opacity 0.1s ease-in",
     zIndex: 1,
   });
-  void performResize(containerElement.offsetWidth, containerElement.offsetHeight);
+  void resize(containerElement.offsetWidth, containerElement.offsetHeight);
   let has_dragged = false;
   useMousePressed({
     target: containerElement,
@@ -167,17 +167,11 @@ function performSetContainer(container: ContainerRef | undefined): void {
 }
 function useHybridViewerViewport(): HybridViewerViewport {
   const { viewStream } = useHybridViewerCore();
-  function setContainer(container: ContainerRef | undefined): void {
-    performSetContainer(container);
-  }
-  async function resize(width: number, height: number): Promise<void> {
-    await performResize(width, height);
-  }
   return {
     setContainer,
     resize,
     viewStream,
   };
 }
-export { performClickPicking, performResize, performSetContainer, useHybridViewerViewport };
+export { performClickPicking, useHybridViewerViewport };
 export type { ViewStreamLike } from "./vtk_types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.34.0-rc.11",
+  "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);