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

package/.build/shared/utils/fetch_raw.js

@@ -19,14 +19,14 @@ async function performFetch({ route, method, params, baseURL, headers, max_retry
 		headers,
 		...hasBody(params) ? { body: params } : {},
 		...max_retry === void 0 ? {} : { retry: max_retry },
-		onRequestError({ error }) {
-			if (request_error_function) request_error_function(error);
+		async onRequestError({ error }) {
+			if (request_error_function) await request_error_function(error);
 		},
-		onResponse({ response }) {
-			if (response.ok && response_function) response_function(response._data);
+		async onResponse({ response }) {
+			if (response.ok && response_function) await response_function(response._data);
 		},
-		onResponseError({ response }) {
-			if (response_error_function) response_error_function(response);
+		async onResponseError({ response }) {
+			if (response_error_function) await response_error_function(response);
 		}
 	});
 }

package/app/components/csv-preview/CsvPreviewer.vue

@@ -77,34 +77,33 @@ function autoDetectSeparator(content: string): string {
   return best;
 }
 
+function splitLine(line: string): string[] {
+  if (!separator.value) {
+    return [line];
+  }
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === separator.value && !inQuotes) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
 function parseContent(): string[] {
   if (!rawContent.value) {
     return [];
   }
 
   const allLines = rawContent.value.split(/\r?\n/u).filter((line) => line.trim() !== "");
-
-  function splitLine(line: string): string[] {
-    if (!separator.value) {
-      return [line];
-    }
-    const result = [];
-    let current = "";
-    let inQuotes = false;
-    for (const char of line) {
-      if (char === '"') {
-        inQuotes = !inQuotes;
-      } else if (char === separator.value && !inQuotes) {
-        result.push(current.trim());
-        current = "";
-      } else {
-        current += char;
-      }
-    }
-    result.push(current.trim());
-    return result;
-  }
-
   const headerLine = allLines[headerRow.value];
   const rawHeaders = headerLine ? splitLine(headerLine) : [];
 

package/app/composables/clipping_planes_widget.ts

@@ -40,7 +40,7 @@ function useClippingPlanesWidget({
   allItems,
   hybridViewerStore,
   debouncedApply,
-}: Readonly<ClippingPlanesWidgetParams>): {
+}: ClippingPlanesWidgetParams): {
   getSceneCenter: typeof getSceneCenter;
   syncWidgets: typeof syncWidgets;
   syncLocalCamera: typeof syncLocalCamera;
@@ -82,7 +82,7 @@ function useClippingPlanesWidget({
     localRenderWindow.getRenderWindow().render();
   }
 
-  function limitCameraZoomOut(camera: Readonly<vtkCamera>): void {
+  function limitCameraZoomOut(camera: vtkCamera): void {
     if (maxDistance <= 0 || isLimitingCameraZoom) {
       return;
     }
@@ -128,7 +128,7 @@ function useClippingPlanesWidget({
       widgetManager = undefined;
     }
   }
-  function updateWidgetPlacement({ isReset = false }: Readonly<{ isReset?: boolean }> = {}): void {
+  function updateWidgetPlacement({ isReset = false }: { isReset?: boolean } = {}): void {
     if (!widgetManager || !localRenderWindow) {
       return;
     }
@@ -148,11 +148,11 @@ function useClippingPlanesWidget({
     }
   }
 
-  function initLocalWidget(container: Readonly<HTMLElement>): void {
+  function initLocalWidget(container: HTMLElement): void {
     cleanupLocalWidget();
     container.addEventListener(
       "wheel",
-      (event: Readonly<WheelEvent>) => {
+      (event: WheelEvent) => {
         event.stopPropagation();
       },
       { passive: true },

package/app/composables/clipping_planes_widget_entries.ts

@@ -41,9 +41,7 @@ interface WidgetEntry {
   subscription: { unsubscribe: () => void };
 }
 
-function asWidgetFactory(
-  widget: Readonly<PlaneWidget>,
-): vtkAbstractWidgetFactory<vtkAbstractWidget> {
+function asWidgetFactory(widget: PlaneWidget): vtkAbstractWidgetFactory<vtkAbstractWidget> {
   // oxlint-disable-next-line no-unsafe-type-assertion -- vtk.js's WidgetManager APIs (addWidget/removeWidget) are untyped for our custom PlaneWidget shape; narrowed once here.
   return widget as unknown as vtkAbstractWidgetFactory<vtkAbstractWidget>;
 }
@@ -54,11 +52,11 @@ interface WidgetEntryManagerParams {
 }
 
 // oxlint-disable-next-line max-lines-per-function typescript/prefer-readonly-parameter-types -- Ref-backed params are inherently mutable through .value.
-function useWidgetEntryManager({ planes, debouncedApply }: Readonly<WidgetEntryManagerParams>): {
+function useWidgetEntryManager({ planes, debouncedApply }: WidgetEntryManagerParams): {
   removeExtraWidgets: (widgetManager: WidgetManagerInstance | undefined) => void;
   updateWidgetEntry: (
     idx: number,
-    plane: Readonly<ClippingPlane>,
+    plane: ClippingPlane,
     cubicBounds: readonly number[],
     widgetManager: WidgetManagerInstance,
   ) => void;
@@ -70,8 +68,8 @@ function useWidgetEntryManager({ planes, debouncedApply }: Readonly<WidgetEntryM
   let fromWidget = false;
 
   function createWidgetEntry(
-    planeWidget: Readonly<PlaneWidget>,
-    widgetHandle: Readonly<WidgetHandle>,
+    planeWidget: PlaneWidget,
+    widgetHandle: WidgetHandle,
     planeIndex: number,
   ): WidgetEntry {
     const widgetState = planeWidget.getWidgetState();
@@ -125,7 +123,7 @@ function useWidgetEntryManager({ planes, debouncedApply }: Readonly<WidgetEntryM
 
   function updateWidgetEntry(
     idx: number,
-    plane: Readonly<ClippingPlane>,
+    plane: ClippingPlane,
     cubicBounds: readonly number[],
     widgetManager: WidgetManagerInstance,
   ): void {

package/app/composables/global_attribute_style.ts

@@ -70,7 +70,7 @@ function isNumberOrUndefined(value: unknown): value is number | undefined {
   return value === undefined || typeof value === "number";
 }
 
-export function useGlobalAttributeStyle(dataIdRef: Readonly<Ref<string | undefined>>): {
+export function useGlobalAttributeStyle(dataIdRef: Ref<string | undefined>): {
   currentColormap: typeof currentColormap;
   currentRange: typeof currentRange;
   applyGlobalColormap: typeof applyGlobalColormap;

package/app/composables/hover_highlight.ts

@@ -86,11 +86,11 @@ export function useHoverhighlight(): {
   async function unhighlightAction(
     type: HighlightType,
     id: string,
-    request: Readonly<{
+    request: {
       schema: JsonRpcSchema;
-      params?: Readonly<Record<string, unknown>>;
+      params?: Record<string, unknown>;
       timeout?: number;
-    }>,
+    },
   ): Promise<void> {
     try {
       await viewerStore.request(request);

package/app/composables/project_manager.ts

@@ -93,7 +93,7 @@ async function importProjectToViewer(
   }
 }
 
-async function importProject(file: Readonly<File>): Promise<void> {
+async function importProject(file: File): Promise<void> {
   const backStore = useBackStore();
   const dataStyleStore = useDataStyleStore();
   const viewerStore = useViewerStore();

package/app/composables/responsive_middle_truncate.ts

@@ -12,13 +12,13 @@ interface ResponsiveMiddleTruncateOptions {
   readonly minStartChars?: number;
 }
 
-// Only the Ref member is wrapped in Readonly<>, so the callable getter member keeps a usable signature.
-type ReadonlyMaybeRefOrGetter<Value> = Value | Readonly<Ref<Value>> | (() => Value);
+// Same shape as Vue's MaybeRefOrGetter<T>, kept as a local alias for readability at call sites.
+type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
 
 export function useResponsiveMiddleTruncate(
   textRef: ReadonlyMaybeRefOrGetter<string | undefined | null>,
   containerWidthRef: ReadonlyMaybeRefOrGetter<number | undefined>,
-  options: Readonly<ResponsiveMiddleTruncateOptions> = {},
+  options: ResponsiveMiddleTruncateOptions = {},
 ): ComputedRef<string> {
   const {
     estimatedCharWidth = DEFAULT_ESTIMATED_CHAR_WIDTH,

package/app/composables/stepper_tree.ts

@@ -1,6 +1,6 @@
 interface StepperTreeApi {
   state: Record<string, unknown>;
-  update_values: (keys_values_object: Readonly<Record<string, unknown>>) => void;
+  update_values: (keys_values_object: Record<string, unknown>) => void;
   increment_step: () => void;
   decrement_step: () => void;
   reset_values: () => void;
@@ -10,13 +10,13 @@ function isUnknownArray(value: unknown): value is unknown[] {
   return Array.isArray(value);
 }
 
-function get_current_step_index(state: Readonly<Record<string, unknown>>): number {
+function get_current_step_index(state: Record<string, unknown>): number {
   const value = state.current_step_index;
   return typeof value === "number" ? value : 0;
 }
 
 function build_initial_state_unref(
-  initial_state: Readonly<Record<string, unknown>>,
+  initial_state: Record<string, unknown>,
 ): Record<string, unknown> {
   const initial_state_unref: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(initial_state)) {
@@ -28,7 +28,7 @@ function build_initial_state_unref(
 
 export function useStepperTree(
   steps: readonly unknown[],
-  initial_state: Readonly<Record<string, unknown>> = {},
+  initial_state: Record<string, unknown> = {},
 ): StepperTreeApi {
   const initial_state_unref = build_initial_state_unref(initial_state);
   const state = reactive<Record<string, unknown>>({
@@ -47,7 +47,7 @@ export function useStepperTree(
     },
   );
 
-  function update_values(keys_values_object: Readonly<Record<string, unknown>>): void {
+  function update_values(keys_values_object: Record<string, unknown>): void {
     for (const [key, value] of Object.entries(keys_values_object)) {
       state[key] = value;
     }

package/app/composables/tree_filter.ts

@@ -1,11 +1,7 @@
 import type { Ref } from "vue";
 
-// Like Vue's MaybeRefOrGetter<T>, but the Ref branch is narrowed to Readonly<Ref<T>>: a plain
-// Ref<T> always fails prefer-readonly-parameter-types (its `.value` is writable) no matter how
-// Deeply readonly T itself is, and wrapping the *whole* union in Readonly<> instead would collapse
-// The getter-function branch to an uncallable `{}` (Readonly<Fn> has no keys). Callers passing an
-// Ordinary Ref<T> still type-check fine here: a mutable Ref<T> is assignable to Readonly<Ref<T>>.
-type ReadonlyMaybeRefOrGetter<Value> = Value | Readonly<Ref<Value>> | (() => Value);
+// Same shape as Vue's MaybeRefOrGetter<T>, kept as a local alias for readability at call sites.
+type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
 
 // This composable filters/sorts different flavors of "category with children" trees (treeview groups, model component/collection groups, ...); this shape captures just the fields it reads/writes, generically, across all of them.
 interface FilterableItem {
@@ -21,7 +17,7 @@ interface FilterContext {
 interface TreeFilterOptions {
   readonly recursiveSort?: boolean;
   readonly defaultSort?: string;
-  readonly defaultFilters?: Readonly<Record<string, boolean>>;
+  readonly defaultFilters?: Record<string, boolean>;
 }
 
 interface UseTreeFilterReturn {

package/app/composables/tree_keyboard_nav.ts

@@ -11,8 +11,8 @@ interface ScrollInfo {
   itemHeight: number;
 }
 
-type ReadonlyDisplayItem = Readonly<Omit<DisplayItem, "raw">> & {
-  readonly raw: Readonly<Record<string, unknown>>;
+type ReadonlyDisplayItem = Omit<DisplayItem, "raw"> & {
+  readonly raw: Record<string, unknown>;
 };
 
 interface KeyboardEventLike {
@@ -22,13 +22,13 @@ interface KeyboardEventLike {
 
 interface UseTreeKeyboardNavReturn {
   focusedIndex: Ref<number>;
-  handleKeyDown: (event: Readonly<KeyboardEventLike>) => void;
+  handleKeyDown: (event: KeyboardEventLike) => void;
 }
 
 function getBaseIndex(
   currentIndex: number,
   lastIndex: number,
-  bounds: Readonly<VisibleBounds> | undefined,
+  bounds: VisibleBounds | undefined,
   key: string,
 ): number {
   if (currentIndex < 0 || currentIndex > lastIndex) {
@@ -49,13 +49,13 @@ function getBaseIndex(
 }
 
 export function useTreeKeyboardNav(
-  displayItems: Readonly<Ref<readonly ReadonlyDisplayItem[]>>,
+  displayItems: Ref<readonly ReadonlyDisplayItem[]>,
   emit: EmitFn,
   scrollToIndex: (index: number) => void,
-  toggleOpen: (raw: Readonly<Record<string, unknown>>) => void,
+  toggleOpen: (raw: Record<string, unknown>) => void,
   handleItemClick: (item: ReadonlyDisplayItem, index: number) => void,
   getScrollInfo: (() => ScrollInfo | undefined) | undefined,
-  externalFocusedIndex: Readonly<Ref<number>> | undefined,
+  externalFocusedIndex: Ref<number> | undefined,
 ): UseTreeKeyboardNavReturn {
   const focusedIndex = externalFocusedIndex ?? ref(-1);
 
@@ -143,7 +143,7 @@ export function useTreeKeyboardNav(
     return currentIndex;
   }
 
-  function handleKeyDown(event: Readonly<KeyboardEventLike>): void {
+  function handleKeyDown(event: KeyboardEventLike): void {
     if (displayItems.value.length === 0) {
       return;
     }

package/app/composables/tree_scroll.ts

@@ -14,34 +14,34 @@ interface ScrollInfo {
   itemHeight: number;
 }
 
-type ReadonlyMaybeRefOrGetter<Value> = Value | Readonly<Ref<Value>> | (() => Value);
+type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
 
-type ReadonlyDisplayItem = Readonly<Omit<DisplayItem, "raw">> & {
-  readonly raw: Readonly<Record<string, unknown>>;
+type ReadonlyDisplayItem = Omit<DisplayItem, "raw"> & {
+  readonly raw: Record<string, unknown>;
 };
 
 interface ScrollEventLike {
-  readonly target: Readonly<EventTarget> | null;
+  readonly target: EventTarget | null;
 }
 
 interface UseTreeScrollReturn {
   internalScrollTop: Ref<number>;
   virtualScrollRef: Ref<ScrollableElement | undefined>;
   stickyHeader: ComputedRef<ReadonlyDisplayItem | undefined>;
-  handleScroll: (event: Readonly<ScrollEventLike>) => void;
+  handleScroll: (event: ScrollEventLike) => void;
   scrollToIndex: (index: number) => void;
   getScrollInfo: () => ScrollInfo;
 }
 
-function isHtmlElement(value: Readonly<EventTarget> | null): value is HTMLElement {
+function isHtmlElement(value: EventTarget | null): value is HTMLElement {
   return value instanceof HTMLElement;
 }
 
 export function useTreeScroll(
-  propsIn: ReadonlyMaybeRefOrGetter<Readonly<TreeScrollProps>>,
+  propsIn: ReadonlyMaybeRefOrGetter<TreeScrollProps>,
   emit: EmitFn,
-  displayItems: Readonly<Ref<readonly ReadonlyDisplayItem[]>>,
-  actualItemProps: Readonly<Ref<Readonly<ItemPropsConfig>>>,
+  displayItems: Ref<readonly ReadonlyDisplayItem[]>,
+  actualItemProps: Ref<ItemPropsConfig>,
 ): UseTreeScrollReturn {
   const SCROLL_STICKY_THRESHOLD = 10;
   const DEFAULT_ITEM_HEIGHT = 28;
@@ -50,7 +50,7 @@ export function useTreeScroll(
   const internalScrollTop = ref(props.value.scrollTop ?? 0);
   const virtualScrollRef = ref<ScrollableElement | undefined>(undefined);
 
-  function handleScroll(event: Readonly<ScrollEventLike>): void {
+  function handleScroll(event: ScrollEventLike): void {
     const { target } = event;
     if (!isHtmlElement(target)) {
       return;

package/app/composables/use_adaptive_styles.ts

@@ -60,7 +60,7 @@ function getValue(val: unknown): number {
 // oxlint-disable max-lines-per-function
 export function useAdaptiveStyles(
   target: AdaptiveStylesTarget,
-  options: Readonly<AdaptiveStylesOptions> = {},
+  options: AdaptiveStylesOptions = {},
 ): {
   adaptiveStyles: ComputedRef<{
     "--adaptive-blur": string;

package/app/composables/use_overlapping_picker.ts

@@ -34,7 +34,7 @@ interface GetViewerIdParams {
   y: number;
   containerWidth: number;
   containerHeight: number;
-  containerRect: Readonly<{ left: number; top: number }>;
+  containerRect: { left: number; top: number };
 }
 
 interface UseOverlappingPickerReturn {
@@ -43,9 +43,9 @@ interface UseOverlappingPickerReturn {
   intermediateMenuX: Ref<number>;
   intermediateMenuY: Ref<number>;
   getIntermediateMenuStyle: () => { position: string; left: string; top: string };
-  selectIntermediateItem: (item: Readonly<ProposedItem> | undefined) => void;
+  selectIntermediateItem: (item: ProposedItem | undefined) => void;
   handleIntermediateMenuUpdate: (val: boolean) => void;
-  get_viewer_id: (params: Readonly<GetViewerIdParams>) => Promise<ViewerIdResult>;
+  get_viewer_id: (params: GetViewerIdParams) => Promise<ViewerIdResult>;
 }
 
 function isPickedItem(entry: unknown): entry is PickedItem {
@@ -95,14 +95,11 @@ export function useOverlappingPicker(): UseOverlappingPickerReturn {
   const intermediateItems = ref<ProposedItem[]>([]);
   const intermediateMenuX = ref(0);
   const intermediateMenuY = ref(0);
-  let resolveIntermediate: ((item: Readonly<ProposedItem> | undefined) => void) | undefined =
-    undefined;
+  let resolveIntermediate: ((item: ProposedItem | undefined) => void) | undefined = undefined;
 
-  async function fetchProposedItems(
-    pickedList: readonly Readonly<PickedItem>[],
-  ): Promise<ProposedItem[]> {
+  async function fetchProposedItems(pickedList: readonly PickedItem[]): Promise<ProposedItem[]> {
     const proposedItems = await Promise.all(
-      pickedList.map(async (pick: Readonly<PickedItem>) => {
+      pickedList.map(async (pick: PickedItem) => {
         try {
           const item = await dataStore.item(pick.id);
           return {
@@ -134,7 +131,7 @@ export function useOverlappingPicker(): UseOverlappingPickerReturn {
     };
   }
 
-  function selectIntermediateItem(item: Readonly<ProposedItem> | undefined): void {
+  function selectIntermediateItem(item: ProposedItem | undefined): void {
     if (resolveIntermediate) {
       resolveIntermediate(item);
       resolveIntermediate = undefined;
@@ -154,8 +151,8 @@ export function useOverlappingPicker(): UseOverlappingPickerReturn {
     containerWidth,
     containerHeight,
     containerRect,
-  }: Readonly<GetViewerIdParams>): Promise<ViewerIdResult> {
-    const activeIds = new Set(dataItems.value.map((i: Readonly<DataItem>) => i.id));
+  }: GetViewerIdParams): Promise<ViewerIdResult> {
+    const activeIds = new Set(dataItems.value.map((i: DataItem) => i.id));
     const visibleStyleIds = Object.keys(dataStyleStore.styles).filter(
       (styleId) => activeIds.has(styleId) && dataStyleStore.objectVisibility(styleId) === true,
     );
@@ -242,7 +239,7 @@ export function useOverlappingPicker(): UseOverlappingPickerReturn {
 
     /* eslint-disable-next-line promise/avoid-new */
     return new Promise<ViewerIdResult>((resolve) => {
-      resolveIntermediate = (chosenResult: Readonly<ProposedItem> | undefined): void => {
+      resolveIntermediate = (chosenResult: ProposedItem | undefined): void => {
         displayIntermediate.value = false;
         resolve(
           chosenResult

package/app/composables/virtual_tree.ts

@@ -1,13 +1,9 @@
 import type { Ref } from "vue";
 
-// Like Vue's MaybeRefOrGetter<T>, but the Ref branch is narrowed to Readonly<Ref<T>>: a plain
-// Ref<T> always fails prefer-readonly-parameter-types (its `.value` is writable) no matter how
-// Deeply readonly T itself is, and wrapping the *whole* union in Readonly<> instead would collapse
-// The getter-function branch to an uncallable `{}` (Readonly<Fn> has no keys). Callers passing an
-// Ordinary Ref<T> still type-check fine here: a mutable Ref<T> is assignable to Readonly<Ref<T>>.
-type ReadonlyMaybeRefOrGetter<Value> = Value | Readonly<Ref<Value>> | (() => Value);
+// Same shape as Vue's MaybeRefOrGetter<T>, kept as a local alias for readability at call sites.
+type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
 
-type TreeItem = Readonly<Record<string, unknown>>;
+type TreeItem = Record<string, unknown>;
 
 interface ItemPropsConfig {
   value: string;
@@ -28,14 +24,10 @@ interface VirtualTreeProps {
   readonly opened?: readonly unknown[];
   readonly selected?: readonly unknown[];
   readonly active?: readonly unknown[];
-  readonly itemProps?: Readonly<Partial<ItemPropsConfig>>;
-  readonly selection?: Readonly<Partial<SelectionConfig>>;
+  readonly itemProps?: Partial<ItemPropsConfig>;
+  readonly selection?: Partial<SelectionConfig>;
   readonly search?: string;
-  readonly customFilter?: (
-    id: unknown,
-    search: string,
-    context: Readonly<{ raw: TreeItem }>,
-  ) => boolean;
+  readonly customFilter?: (id: unknown, search: string, context: { raw: TreeItem }) => boolean;
 }
 
 interface DisplayItem {

package/app/plugins/auto_store_register.ts

@@ -1,7 +1,7 @@
 import type { PiniaPluginContext } from "pinia";
 import { useAppStore } from "@ogw_front/stores/app";
 
-function autoStoreRegister({ store }: Readonly<PiniaPluginContext>): void {
+function autoStoreRegister({ store }: PiniaPluginContext): void {
   if (store.$id === "app") {
     return;
   }

package/app/stores/app.ts

@@ -22,8 +22,8 @@ declare module "pinia" {
 
 interface RegisterableStore {
   $id: string;
-  $patch?: (partial: Readonly<Record<string, unknown>>) => void;
-  exportStores?: (params?: Readonly<Record<string, unknown>>) => Promise<unknown>;
+  $patch?: (partial: Record<string, unknown>) => void;
+  exportStores?: (params?: Record<string, unknown>) => Promise<unknown>;
   importStores?: (snapshot: unknown) => Promise<void> | void;
   connect?: () => Promise<void>;
   kill?: () => Promise<void>;
@@ -65,9 +65,9 @@ export const useAppStore = defineStore("app", () => {
     }
   }
 
-  function registerStore(store: Readonly<RegisterableStore>): void {
+  function registerStore(store: RegisterableStore): void {
     const isAlreadyRegistered = stores.some(
-      (registeredStore: Readonly<RegisterableStore>) => registeredStore.$id === store.$id,
+      (registeredStore: RegisterableStore) => registeredStore.$id === store.$id,
     );
     if (isAlreadyRegistered) {
       return;
@@ -76,12 +76,12 @@ export const useAppStore = defineStore("app", () => {
   }
 
   async function exportStores(
-    params: Readonly<Record<string, unknown>> = {},
+    params: Record<string, unknown> = {},
   ): Promise<Record<string, unknown>> {
     const snapshot: Record<string, unknown> = {};
 
     await Promise.all(
-      stores.map(async (store: Readonly<RegisterableStore>) => {
+      stores.map(async (store: RegisterableStore) => {
         if (!store.exportStores) {
           return;
         }
@@ -96,9 +96,7 @@ export const useAppStore = defineStore("app", () => {
     return snapshot;
   }
 
-  async function importStores(
-    snapshot: Readonly<Record<string, unknown>> | undefined,
-  ): Promise<void> {
+  async function importStores(snapshot: Record<string, unknown> | undefined): Promise<void> {
     if (!snapshot) {
       return;
     }
@@ -106,7 +104,7 @@ export const useAppStore = defineStore("app", () => {
     const missingStoreIds: string[] = [];
 
     await Promise.all(
-      stores.map(async (store: Readonly<RegisterableStore>) => {
+      stores.map(async (store: RegisterableStore) => {
         if (!store.importStores) {
           return;
         }
@@ -142,7 +140,8 @@ export const useAppStore = defineStore("app", () => {
     getExtensionEnabled,
   } = useAppExtensions();
 
-  async function upload(file: Readonly<File>, callbacks: RequestHandlers = {}): Promise<unknown> {
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
+  async function upload(file: File, callbacks: RequestHandlers = {}): Promise<unknown> {
     const store = useAppStore();
     const schema = opengeodeweb_front_schemas.api.local.extensions.upload;
     const { PROJECT: projectName } = useRuntimeConfig().public;
@@ -163,11 +162,9 @@ export const useAppStore = defineStore("app", () => {
   }
 
   // `TResult` is asserted, not verified, at the single `return result as TResult` boundary below: the backend response is only checked against `schema` at runtime, so callers' `TResult` is a contract with the schema, not something this function can prove.
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
   async function request<TResult = unknown>(
-    {
-      schema,
-      params,
-    }: Readonly<{ schema: JsonRpcSchema; params?: Readonly<Record<string, unknown>> }>,
+    { schema, params }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
     callbacks: RequestHandlers = {},
   ): Promise<TResult> {
     const store = useAppStore();

package/app/stores/back.ts

@@ -77,7 +77,7 @@ export const useBackStore = defineStore("back", {
     stop_request() {
       this.request_counter -= 1;
     },
-    async launch(args: Readonly<Record<string, unknown>>) {
+    async launch(args: Record<string, unknown>) {
       const appStore = useAppStore();
       const { COMMAND_BACK, NUXT_ROOT_PATH } = useRuntimeConfig().public;
       const schema = opengeodeweb_front_schemas.api.local.app.run_back;
@@ -105,10 +105,7 @@ export const useBackStore = defineStore("back", {
       await Promise.resolve();
     },
     async request(
-      {
-        schema,
-        params = {},
-      }: Readonly<{ schema: JsonRpcSchema; params?: Record<string, unknown> }>,
+      { schema, params = {} }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
       callbacks: RequestHandlers = {},
     ) {
       const result = await api_fetch(
@@ -129,7 +126,7 @@ export const useBackStore = defineStore("back", {
       );
       return result;
     },
-    async upload(file: Readonly<File>, callbacks: RequestHandlers = {}) {
+    async upload(file: File, callbacks: RequestHandlers = {}) {
       const schema = back_schemas.opengeodeweb_back.upload_file;
       const result = await upload_file(
         this,

package/app/stores/camera_manager.ts

@@ -25,7 +25,7 @@ export const useCameraManagerStore = defineStore("camera_manager", () => {
     number
   >;
 
-  function refAllCameraPositions(): Readonly<Ref<CameraPositionRecord[]>> {
+  function refAllCameraPositions(): Ref<CameraPositionRecord[]> {
     // 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
@@ -45,10 +45,7 @@ export const useCameraManagerStore = defineStore("camera_manager", () => {
     return position;
   }
 
-  async function saveCameraPosition(
-    name: string,
-    camera_options: Readonly<CameraOptions>,
-  ): Promise<void> {
+  async function saveCameraPosition(name: string, camera_options: CameraOptions): Promise<void> {
     await camera_positions_db.put({
       name,
       camera_options,