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

package/app/stores/data.ts

@@ -65,7 +65,7 @@ const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic;
 type DatabaseTables = Record<string, unknown>;
 // oxlint-disable-next-line no-unsafe-type-assertion -- see comment above.
 const typedDatabase = database as unknown as DatabaseTables;
-function checkItemViewable(item: Readonly<ViewableItemLike> | undefined | null): boolean {
+function checkItemViewable(item: ViewableItemLike | undefined | null): boolean {
   if (!item || typeof item !== "object") {
     return false;
   }
@@ -84,7 +84,7 @@ function checkItemViewable(item: Readonly<ViewableItemLike> | undefined | null):
   }
   return true;
 }
-function isItemViewable(itemOrId: string | Readonly<ViewableItemLike>): boolean | Promise<boolean> {
+function isItemViewable(itemOrId: string | ViewableItemLike): boolean | Promise<boolean> {
   if (typeof itemOrId === "string") {
     // oxlint-disable-next-line no-unsafe-type-assertion -- database's table map is dynamically typed at runtime; see comment above.
     return (typedDatabase.data as Table<DataItem, string>).get(itemOrId).then(checkItemViewable);
@@ -134,7 +134,7 @@ export const useDataStore = defineStore("data", () => {
     const items = await data_db.toArray();
     return items;
   }
-  function refItem(id: string): Readonly<Ref<DataItem | undefined>> {
+  function refItem(id: string): Ref<DataItem | undefined> {
     // Dexie's liveQuery() returns Dexie's own minimal Observable shape, not an
     // Actual rxjs Observable instance (useObservable's declared parameter type);
     // The two are structurally close enough at runtime (vueuse only calls
@@ -151,7 +151,7 @@ export const useDataStore = defineStore("data", () => {
       },
     );
   }
-  function refAllItems(): Readonly<Ref<DataItem[]>> {
+  function refAllItems(): Ref<DataItem[]> {
     return useObservable(
       liveQuery(async () => {
         const items = await data_db.toArray();
@@ -194,9 +194,9 @@ export const useDataStore = defineStore("data", () => {
     });
     return result;
   }
-  // NewDataItem has mutable array fields (mesh_components, collection_components), so Readonly<>
-  // Can't satisfy prefer-readonly-parameter-types deeply; same pattern as app/utils/import_workflow.ts.
-  async function addItem(new_item: Readonly<NewDataItem>): Promise<string> {
+  // NewDataItem has mutable array fields (mesh_components, collection_components), so it can't
+  // Satisfy prefer-readonly-parameter-types deeply; same pattern as app/utils/import_workflow.ts.
+  async function addItem(new_item: NewDataItem): Promise<string> {
     const itemData: DataItem = {
       id: new_item.id,
       name: new_item.name ?? new_item.id,
@@ -212,9 +212,9 @@ export const useDataStore = defineStore("data", () => {
     const id = await data_db.put(itemData);
     return id;
   }
-  // NewDataItem has mutable array fields (mesh_components, collection_components), so Readonly<>
-  // Can't satisfy prefer-readonly-parameter-types deeply; same pattern as app/utils/import_workflow.ts.
-  async function addComponents(new_item: Readonly<NewDataItem>): Promise<string> {
+  // NewDataItem has mutable array fields (mesh_components, collection_components), so it can't
+  // Satisfy prefer-readonly-parameter-types deeply; same pattern as app/utils/import_workflow.ts.
+  async function addComponents(new_item: NewDataItem): Promise<string> {
     const allComponents: ModelComponentRecord[] = [];
     // ModelComponentInput has mutable array fields (boundaries, internals, items), so a readonly
     // Array of it can't satisfy prefer-readonly-parameter-types deeply; same limitation as above.
@@ -239,9 +239,9 @@ export const useDataStore = defineStore("data", () => {
     const lastKey = await model_components_db.bulkPut(allComponents);
     return lastKey;
   }
-  // NewDataItem has mutable array fields (mesh_components, collection_components), so Readonly<>
-  // Can't satisfy prefer-readonly-parameter-types deeply; same pattern as app/utils/import_workflow.ts.
-  async function addComponentRelations(new_item: Readonly<NewDataItem>): Promise<string> {
+  // NewDataItem has mutable array fields (mesh_components, collection_components), so it can't
+  // Satisfy prefer-readonly-parameter-types deeply; same pattern as app/utils/import_workflow.ts.
+  async function addComponentRelations(new_item: NewDataItem): Promise<string> {
     const relations: ModelComponentRelationRecord[] = [];
     function addModelComponentRelations(
       components: readonly string[],
@@ -284,7 +284,7 @@ export const useDataStore = defineStore("data", () => {
     const component = await model_components_db
       .where("viewer_id")
       .equals(Number(viewer_id))
-      .and((model_component: Readonly<ModelComponentRecord>) => model_component.id === modelId)
+      .and((model_component: ModelComponentRecord) => model_component.id === modelId)
       .first();
     return component;
   }
@@ -304,7 +304,7 @@ export const useDataStore = defineStore("data", () => {
 
   async function getAllModelComponentsViewerIds(modelId: string): Promise<number[]> {
     const components = await model_components_db.where("id").equals(modelId).toArray();
-    return components.map((component: Readonly<ModelComponentRecord>) =>
+    return components.map((component: ModelComponentRecord) =>
       Math.trunc(Number(component.viewer_id)),
     );
   }
@@ -316,7 +316,7 @@ export const useDataStore = defineStore("data", () => {
       .where("[id+geode_id]")
       .anyOf(meshComponentGeodeIds.map((geode_id) => [modelId, geode_id]))
       .toArray();
-    return components.map((component: Readonly<ModelComponentRecord>) =>
+    return components.map((component: ModelComponentRecord) =>
       Math.trunc(Number(component.viewer_id)),
     );
   }

package/app/stores/data_helpers/collections.ts

@@ -48,10 +48,7 @@ export function useDataCollections(): {
     const count = await model_components_db
       .where("id")
       .equals(modelId)
-      .and(
-        (component: Readonly<ModelComponentRecord>) =>
-          !MESH_COMPONENT_TYPES.includes(component.type),
-      )
+      .and((component: ModelComponentRecord) => !MESH_COMPONENT_TYPES.includes(component.type))
       .count();
     return count > 0;
   }
@@ -59,11 +56,8 @@ export function useDataCollections(): {
   async function getAllCollectionComponents(modelId: string): Promise<FormattedComponent[]> {
     const items = await model_components_db.where("id").equals(modelId).toArray();
     return items
-      .filter(
-        (component: Readonly<ModelComponentRecord>) =>
-          !MESH_COMPONENT_TYPES.includes(component.type),
-      )
-      .map((component: Readonly<ModelComponentRecord>) => ({
+      .filter((component: ModelComponentRecord) => !MESH_COMPONENT_TYPES.includes(component.type))
+      .map((component: ModelComponentRecord) => ({
         id: component.geode_id,
         title: component.name,
         category: component.type,
@@ -87,13 +81,11 @@ export function useDataCollections(): {
     for (const component of components) {
       byType[component.category] ??= [];
       const itemRelations = relations.filter(
-        (relation: Readonly<ModelComponentRelationRecord>) =>
+        (relation: ModelComponentRelationRecord) =>
           relation.parent === component.id && relation.type === "collection",
       );
       const children = itemRelations
-        .map(
-          (relation: Readonly<ModelComponentRelationRecord>) => meshComponentsById[relation.child],
-        )
+        .map((relation: ModelComponentRelationRecord) => meshComponentsById[relation.child])
         .filter((child): child is FormattedComponent => Boolean(child));
       byType[component.category]?.push({
         ...component,
@@ -120,7 +112,7 @@ export function useDataCollections(): {
 
   function refFormatedCollectionComponents(
     modelId: string,
-  ): Readonly<Ref<CollectionComponentGroup[] | undefined>> {
+  ): Ref<CollectionComponentGroup[] | undefined> {
     return useObservable(
       // Dexie's liveQuery returns its own Observable-like type, not rxjs's Observable, so bridging needs a cast.
       liveQuery(async () => {

package/app/stores/data_helpers/mesh.ts

@@ -26,7 +26,7 @@ interface FormattedComponentGroup {
   readonly children: readonly FormattedComponent[];
 }
 
-function toFormattedComponent(meshComponent: Readonly<ModelComponentRecord>): FormattedComponent {
+function toFormattedComponent(meshComponent: ModelComponentRecord): FormattedComponent {
   return {
     id: meshComponent.geode_id,
     title: meshComponent.name,
@@ -77,15 +77,13 @@ export function useDataMesh(): {
       .map((type) => ({
         id: type,
         title: componentTitles[type] ?? type,
-        children: (componentsByType[type] ?? []).map((item: Readonly<ModelComponentRecord>) =>
+        children: (componentsByType[type] ?? []).map((item: ModelComponentRecord) =>
           toFormattedComponent(item),
         ),
       }));
   }
 
-  function refFormatedMeshComponents(
-    modelId: string,
-  ): Readonly<Ref<FormattedComponentGroup[] | undefined>> {
+  function refFormatedMeshComponents(modelId: string): Ref<FormattedComponentGroup[] | undefined> {
     return useObservable(
       liveQuery(async () => {
         const components = await formatedMeshComponents(modelId);
@@ -106,12 +104,12 @@ export function useDataMesh(): {
       .where("[id+type]")
       .equals([modelId, type])
       .toArray();
-    return components.map((item: Readonly<ModelComponentRecord>) => toFormattedComponent(item));
+    return components.map((item: ModelComponentRecord) => toFormattedComponent(item));
   }
 
   async function getAllMeshComponents(modelId: string): Promise<FormattedComponent[]> {
     const items = await model_components_db.where("id").equals(modelId).toArray();
-    return items.map((item: Readonly<ModelComponentRecord>) => toFormattedComponent(item));
+    return items.map((item: ModelComponentRecord) => toFormattedComponent(item));
   }
 
   async function fetchAllMeshComponents(
@@ -131,7 +129,7 @@ export function useDataMesh(): {
       .where("[id+type]")
       .equals([modelId, type])
       .toArray();
-    return components.map((component: Readonly<ModelComponentRecord>) => component.geode_id);
+    return components.map((component: ModelComponentRecord) => component.geode_id);
   }
 
   async function getCornersGeodeIds(modelId: string): Promise<string[]> {

package/app/stores/data_style.ts

@@ -12,9 +12,9 @@ import { useMeshStyle } from "@ogw_internal/stores/data_style/mesh/index";
 import { useModelStyle } from "@ogw_internal/stores/data_style/model/index";
 
 interface DataStyleSnapshot {
-  readonly styles: Readonly<Record<string, Readonly<ObjectStyle>>>;
-  readonly componentStyles: Readonly<Record<string, Readonly<ModelComponentStyle>>>;
-  readonly modelComponentTypeStyles: Readonly<Record<string, Readonly<ModelComponentTypeStyle>>>;
+  readonly styles: Record<string, ObjectStyle>;
+  readonly componentStyles: Record<string, ModelComponentStyle>;
+  readonly modelComponentTypeStyles: Record<string, ModelComponentTypeStyle>;
 }
 
 // The database's table map is dynamically assembled at runtime (see internal/database/database.ts), so its exported type is a loose `{}`; cast it to the shape it actually has at runtime rather than widening every call site.
@@ -100,7 +100,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   }
 
   // oxlint-disable-next-line prefer-readonly-parameter-types -- ObjectStyle (external type) has a mutable index signature and mutable nested StyleValues fields that can't be marked readonly from here.
-  async function importStores(snapshot: Readonly<DataStyleSnapshot>): Promise<void> {
+  async function importStores(snapshot: DataStyleSnapshot): Promise<void> {
     const stylesSnapshot = snapshot.styles;
     const componentStylesSnapshot = snapshot.componentStyles;
     const modelComponentTypeStylesSnapshot = snapshot.modelComponentTypeStyles;
@@ -109,19 +109,19 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
 
     const style_promises = Object.entries(stylesSnapshot).map(
       // oxlint-disable-next-line prefer-readonly-parameter-types -- same external ObjectStyle limitation as above.
-      async ([id, style]: readonly [string, Readonly<ObjectStyle>]) => {
+      async ([id, style]: readonly [string, ObjectStyle]) => {
         const key = await data_style_db.put(structuredClone({ ...style, id }));
         return key;
       },
     );
     const component_style_promises = Object.values(componentStylesSnapshot).map(
-      async (style: Readonly<ModelComponentStyle>) => {
+      async (style: ModelComponentStyle) => {
         const key = await component_datastyle_db.put(structuredClone(style));
         return key;
       },
     );
     const model_component_type_style_promises = Object.values(modelComponentTypeStylesSnapshot).map(
-      async (style: Readonly<ModelComponentTypeStyle>) => {
+      async (style: ModelComponentTypeStyle) => {
         const key = await model_component_type_datastyle_db.put(structuredClone(style));
         return key;
       },

package/app/stores/hybrid_viewer.ts

@@ -82,7 +82,7 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     };
     const imageStream = clientApi.getImageStream();
     viewportStore.viewStream.value = imageStream.createViewStream("-1");
-    viewportStore.viewStream.value?.onImageReady((event: Readonly<{ image: unknown }>) => {
+    viewportStore.viewStream.value?.onImageReady((event: { image: unknown }) => {
       if (is_moving.value) {
         return;
       }

package/app/stores/infra.ts

@@ -5,7 +5,7 @@ import { useCloudStore } from "@ogw_front/stores/cloud";
 
 interface ElectronApi {
   electronAPI: {
-    project_folder_path: (args: Readonly<{ projectFolderPath: string }>) => void;
+    project_folder_path: (args: { projectFolderPath: string }) => void;
   };
 }
 
@@ -23,29 +23,25 @@ export const useInfraStore = defineStore("infra", {
   }),
   getters: {
     microservices_connected(): boolean {
-      return this.microservices.every(
-        (store: Readonly<Microservice>) => store.status === Status.CONNECTED,
-      );
+      return this.microservices.every((store: Microservice) => store.status === Status.CONNECTED);
     },
     microservices_busy(): boolean {
-      return this.microservices.some((store: Readonly<Microservice>) => store.is_busy === true);
+      return this.microservices.some((store: Microservice) => store.is_busy === true);
     },
   },
   actions: {
-    register_microservice(store: Readonly<Microservice>) {
+    register_microservice(store: Microservice) {
       const store_name = store.$id;
 
       if (
-        !this.microservices.some(
-          (microservice: Readonly<Microservice>) => microservice.$id === store_name,
-        )
+        !this.microservices.some((microservice: Microservice) => microservice.$id === store_name)
       ) {
         this.microservices.push(store);
       }
     },
     unregister_microservice(microserviceId: string) {
       this.microservices = this.microservices.filter(
-        (microservice: Readonly<Microservice>) => microservice.$id !== microserviceId,
+        (microservice: Microservice) => microservice.$id !== microserviceId,
       );
     },
     async create_backend(email?: string) {
@@ -71,16 +67,14 @@ export const useInfraStore = defineStore("infra", {
           }
           await setAppBaseUrl(appStore.base_url);
           const microservices_with_launch = this.microservices.filter(
-            (store: Readonly<Microservice>) => store.launch,
-          );
-          const launch_promises = microservices_with_launch.map(
-            async (store: Readonly<Microservice>) => {
-              const result = await store.launch?.({
-                projectFolderPath: appStore.projectFolderPath,
-              });
-              return result;
-            },
+            (store: Microservice) => store.launch,
           );
+          const launch_promises = microservices_with_launch.map(async (store: Microservice) => {
+            const result = await store.launch?.({
+              projectFolderPath: appStore.projectFolderPath,
+            });
+            return result;
+          });
           const { registerRunningExtensions } = await import("@ogw_front/utils/extension");
           launch_promises.push(registerRunningExtensions());
           await Promise.all(launch_promises);
@@ -92,7 +86,7 @@ export const useInfraStore = defineStore("infra", {
     },
     async create_connection() {
       await Promise.all(
-        this.microservices.map(async (store: Readonly<Microservice>) => {
+        this.microservices.map(async (store: Microservice) => {
           await store.connect();
         }),
       );
@@ -107,6 +101,6 @@ export interface Microservice {
   $id: string;
   status?: string;
   is_busy?: boolean;
-  launch?: (params: Readonly<Record<string, unknown>>) => Promise<unknown>;
+  launch?: (params: Record<string, unknown>) => Promise<unknown>;
   connect: () => Promise<void>;
 }

package/app/stores/menu.ts

@@ -56,7 +56,7 @@ interface OpenMenuOptions {
   readonly height: number;
   readonly top: number;
   readonly left: number;
-  readonly meta_data: Readonly<MenuMetaData> | undefined;
+  readonly meta_data: MenuMetaData | undefined;
 }
 
 const PointSet_menu = [PointSetPointsOptions];

package/app/stores/treeview.ts

@@ -55,20 +55,20 @@ function defaultOpenedViews(): OpenedView[] {
   return [{ type: "object", id: "main", title: "Objects", scrollTop: 0, opened: [] }];
 }
 
-type ReadonlyOpenedView = Readonly<Omit<OpenedView, "opened">> & {
+type ReadonlyOpenedView = Omit<OpenedView, "opened"> & {
   readonly opened: readonly string[];
 };
-type ReadonlyTreeviewGroup = Readonly<Omit<TreeviewGroup, "children">> & {
-  readonly children: readonly Readonly<TreeviewChild>[];
+type ReadonlyTreeviewGroup = Omit<TreeviewGroup, "children"> & {
+  readonly children: readonly TreeviewChild[];
 };
-type ReadonlyTreeviewSnapshot = Readonly<{
+type ReadonlyTreeviewSnapshot = {
   opened_views?: readonly ReadonlyOpenedView[];
   panelWidth?: number;
   additionalPanelWidth?: number;
   rowHeights?: readonly number[];
   selectionIds?: readonly string[];
-  selection?: readonly (string | Readonly<{ id: string }>)[];
-}>;
+  selection?: readonly (string | { id: string })[];
+};
 
 // oxlint-disable-next-line max-lines-per-function, max-statements
 export const useTreeviewStore = defineStore("treeview", () => {
@@ -260,7 +260,7 @@ export const useTreeviewStore = defineStore("treeview", () => {
     rowHeights.value = snapshot?.rowHeights ? [...snapshot.rowHeights] : [];
     pendingSelectionIds.value = snapshot?.selectionIds
       ? [...snapshot.selectionIds]
-      : (snapshot?.selection ?? []).map((selectionItem: Readonly<string | { id: string }>) =>
+      : (snapshot?.selection ?? []).map((selectionItem: string | { id: string }) =>
           typeof selectionItem === "string" ? selectionItem : selectionItem.id,
         );
   }

package/app/stores/viewer.ts

@@ -68,11 +68,11 @@ export const useViewerStore = defineStore(
         schema,
         params = {},
         timeout = request_timeout,
-      }: Readonly<{
+      }: {
         schema: JsonRpcSchema;
-        params?: Readonly<Record<string, unknown>>;
+        params?: Record<string, unknown>;
         timeout?: number;
-      }>,
+      },
       callbacks: RequestHandlers = {},
     ): Promise<unknown> {
       const store = useViewerStore();
@@ -154,7 +154,7 @@ export const useViewerStore = defineStore(
     function stop_request(): void {
       request_counter.value -= 1;
     }
-    async function launch(args: Readonly<{ projectFolderPath?: string }> = {}): Promise<unknown> {
+    async function launch(args: { projectFolderPath?: string } = {}): Promise<unknown> {
       const appStore = useAppStore();
       const { COMMAND_VIEWER, NUXT_ROOT_PATH } = useRuntimeConfig().public;
       const schema = opengeodeweb_front_schemas.api.local.app.run_viewer;

package/app/utils/attributes.ts

@@ -11,7 +11,7 @@ interface AttributeRange {
 }
 
 export function getAttributeRange(
-  currentAttribute: Readonly<AttributeRangeSource> | undefined | null,
+  currentAttribute: AttributeRangeSource | undefined | null,
   compIndex = 0,
 ): AttributeRange {
   if (!currentAttribute) {

package/app/utils/clipping_planes.ts

@@ -79,7 +79,7 @@ function getPlaneStyle(rgb: readonly number[]): PlaneStyle {
   };
 }
 
-function computeSceneBounds(actors: readonly Readonly<vtkActor>[]): Bounds {
+function computeSceneBounds(actors: readonly vtkActor[]): Bounds {
   let bounds: Bounds = [Infinity, -Infinity, Infinity, -Infinity, Infinity, -Infinity];
   for (const actor of actors) {
     const boundsOfActor = actor.getBounds();
@@ -100,7 +100,7 @@ interface SceneBoundsInfo {
   readonly cubicBounds: readonly number[];
 }
 
-function computeSceneBoundsInfo(actors: readonly Readonly<vtkActor>[]): SceneBoundsInfo {
+function computeSceneBoundsInfo(actors: readonly vtkActor[]): SceneBoundsInfo {
   if (actors.length === 0) {
     return { center: [0, 0, 0], cubicBounds: [-1, 1, -1, 1, -1, 1] };
   }
@@ -112,7 +112,7 @@ function computeSceneBoundsInfo(actors: readonly Readonly<vtkActor>[]): SceneBou
   ];
 
   const maxActorExtent = Math.max(
-    ...actors.map((actor: Readonly<vtkActor>) => {
+    ...actors.map((actor: vtkActor) => {
       const bounds = actor.getBounds();
       return Math.max(bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4]);
     }),
@@ -131,7 +131,7 @@ function computeSceneBoundsInfo(actors: readonly Readonly<vtkActor>[]): SceneBou
 }
 
 interface ActorEntry {
-  readonly actor: Readonly<vtkActor>;
+  readonly actor: vtkActor;
 }
 
 interface MainCameraOptions {
@@ -144,25 +144,20 @@ function resolveActiveActors(
   targetAllVisible: boolean,
   allItems: readonly { readonly id: string }[],
   selectedDatasetIds: readonly string[],
-  hybridDb: Readonly<Record<string, ActorEntry | undefined>>,
-): Readonly<vtkActor>[] {
+  hybridDb: Record<string, ActorEntry | undefined>,
+): vtkActor[] {
   const targetIds = targetAllVisible
-    ? allItems.map((item: Readonly<{ id: string }>) => item.id)
+    ? allItems.map((item: { id: string }) => item.id)
     : selectedDatasetIds;
   const targeted = targetIds
     .map((id) => hybridDb[id]?.actor)
-    .filter(
-      (actor: Readonly<vtkActor> | undefined): actor is Readonly<vtkActor> => actor !== undefined,
-    );
+    .filter((actor: vtkActor | undefined): actor is vtkActor => actor !== undefined);
   if (targeted.length > 0) {
     return targeted;
   }
   return Object.values(hybridDb)
-    .filter(
-      (entry: Readonly<ActorEntry> | undefined): entry is Readonly<ActorEntry> =>
-        entry !== undefined,
-    )
-    .map((entry: Readonly<ActorEntry>) => entry.actor);
+    .filter((entry: ActorEntry | undefined): entry is ActorEntry => entry !== undefined)
+    .map((entry: ActorEntry) => entry.actor);
 }
 
 function computeNormalizedViewDirection(
@@ -184,8 +179,8 @@ function computeNormalizedViewDirection(
 // Aligns the local clipping-plane preview camera onto the same viewing direction as the
 // Main viewer camera, re-centered on the clipped scene's bounds.
 function alignCameraToMainCamera(
-  camera: Readonly<vtkCamera>,
-  mainCam: Readonly<MainCameraOptions>,
+  camera: vtkCamera,
+  mainCam: MainCameraOptions,
   center: readonly number[],
 ): void {
   if (!mainCam.focal_point || !mainCam.position) {

package/app/utils/colormap.ts

@@ -55,7 +55,7 @@ function fillImageDataFromTable(
   // ImageData can't satisfy prefer-readonly-parameter-types since lib.dom.d.ts types are inherently mutable, so this finding is left unfixed (same pattern as app/plugins/auto_store_register.ts).
   imageData: ImageData,
   // Float32Array's numeric index signature is inherently mutable and can't satisfy prefer-readonly-parameter-types, so this finding is left unfixed (same pattern as app/plugins/auto_store_register.ts).
-  table: Readonly<Float32Array>,
+  table: Float32Array,
   width: number,
   height: number,
 ): void {

package/app/utils/default_styles/meshes.ts

@@ -117,7 +117,7 @@ interface SolidStyle {
 function meshPointsDefaultStyle(
   visibility: boolean = POINTS_DEFAULT_VISIBILITY,
   size: number = POINTS_DEFAULT_SIZE,
-  constant: Readonly<RGBAColor> = POINTS_DEFAULT_COLOR,
+  constant: RGBAColor = POINTS_DEFAULT_COLOR,
 ): MeshPointsStyle {
   return {
     visibility,
@@ -133,7 +133,7 @@ function meshPointsDefaultStyle(
 function meshEdgesDefaultStyle(
   visibility: boolean = EDGES_DEFAULT_VISIBILITY,
   width: number = EDGES_DEFAULT_WIDTH,
-  constant: Readonly<RGBAColor> = EDGES_DEFAULT_COLOR,
+  constant: RGBAColor = EDGES_DEFAULT_COLOR,
 ): MeshEdgesStyle {
   return {
     visibility,
@@ -149,7 +149,7 @@ function meshEdgesDefaultStyle(
 
 function meshCellsDefaultStyle(
   visibility: boolean = CELLS_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = CELLS_DEFAULT_COLOR,
+  constant: RGBAColor = CELLS_DEFAULT_COLOR,
 ): MeshCellsStyle {
   return {
     visibility,
@@ -166,7 +166,7 @@ function meshCellsDefaultStyle(
 
 function meshPolygonsDefaultStyle(
   visibility: boolean = POLYGONS_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = POLYGONS_DEFAULT_COLOR,
+  constant: RGBAColor = POLYGONS_DEFAULT_COLOR,
 ): MeshPolygonsStyle {
   return {
     visibility,
@@ -183,7 +183,7 @@ function meshPolygonsDefaultStyle(
 
 function meshPolyhedraDefaultStyle(
   visibility: boolean = POLYHEDRA_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = POLYHEDRA_DEFAULT_COLOR,
+  constant: RGBAColor = POLYHEDRA_DEFAULT_COLOR,
 ): MeshPolyhedraStyle {
   return {
     visibility,

package/app/utils/default_styles/models.ts

@@ -96,7 +96,7 @@ interface ModelWithoutBlocksStyle {
 
 function modelCornersDefaultStyle(
   visibility: boolean = CORNERS_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = CORNERS_DEFAULT_COLOR,
+  constant: RGBAColor = CORNERS_DEFAULT_COLOR,
 ): ModelCornersStyle {
   return {
     visibility,
@@ -110,7 +110,7 @@ function modelCornersDefaultStyle(
 
 function modelLinesDefaultStyle(
   visibility: boolean = LINES_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = LINES_DEFAULT_COLOR,
+  constant: RGBAColor = LINES_DEFAULT_COLOR,
 ): ModelLinesStyle {
   return {
     visibility,
@@ -125,7 +125,7 @@ function modelLinesDefaultStyle(
 
 function modelSurfacesDefaultStyle(
   visibility: boolean = SURFACES_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = SURFACES_DEFAULT_COLOR,
+  constant: RGBAColor = SURFACES_DEFAULT_COLOR,
 ): ModelSurfacesStyle {
   return {
     visibility,
@@ -140,7 +140,7 @@ function modelSurfacesDefaultStyle(
 
 function modelBlocksDefaultStyle(
   visibility: boolean = BLOCKS_DEFAULT_VISIBILITY,
-  constant: Readonly<RGBAColor> = BLOCKS_DEFAULT_COLOR,
+  constant: RGBAColor = BLOCKS_DEFAULT_COLOR,
 ): ModelBlocksStyle {
   return {
     visibility,

package/app/utils/extension.ts

@@ -29,7 +29,7 @@ interface RegisteredExtension {
   extensionModule: ExtensionModuleType;
 }
 
-async function uploadExtension(file: Readonly<File>): Promise<void> {
+async function uploadExtension(file: File): Promise<void> {
   const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   await appStore.upload(file);
@@ -57,7 +57,7 @@ async function runExtensions(): Promise<{ extensionsArray: ExtensionDescriptor[]
 async function downloadExtension({
   url,
   extensionFileName,
-}: Readonly<DownloadExtensionParams>): Promise<unknown> {
+}: DownloadExtensionParams): Promise<unknown> {
   const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { PROJECT: projectName } = useRuntimeConfig().public;
@@ -74,9 +74,7 @@ async function downloadExtension({
   return result;
 }
 
-function isMicroservice(
-  store: Readonly<RegisterableStore>,
-): store is RegisterableStore & Microservice {
+function isMicroservice(store: RegisterableStore): store is RegisterableStore & Microservice {
   return typeof store.connect === "function";
 }
 
@@ -87,7 +85,7 @@ async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
   const infraStore = useInfraStore();
   const { extensionsArray } = await runExtensions();
   return Promise.all(
-    extensionsArray.map(async (extension: Readonly<ExtensionDescriptor>) => {
+    extensionsArray.map(async (extension: ExtensionDescriptor) => {
       const { id, name, version, frontendContent, port } = extension;
       const blob = new Blob([frontendContent], {
         type: "application/javascript",
@@ -116,14 +114,12 @@ async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
   );
 }
 
-async function importExtensionFile(file: Readonly<File>): Promise<RegisteredExtension[]> {
+async function importExtensionFile(file: File): Promise<RegisteredExtension[]> {
   await uploadExtension(file);
   return registerRunningExtensions();
 }
 
-async function importExtensionURL(
-  url: Readonly<DownloadExtensionParams>,
-): Promise<RegisteredExtension[]> {
+async function importExtensionURL(url: DownloadExtensionParams): Promise<RegisteredExtension[]> {
   await downloadExtension(url);
   return registerRunningExtensions();
 }

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();