@geode/opengeodeweb-front 10.34.0-rc.9 → 10.34.0

package/app/stores/camera_manager.ts

@@ -1,17 +1,12 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-// Third party imports
-import { liveQuery } from "dexie";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Table } from "dexie";
-import { useObservable } from "@vueuse/rxjs";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+import { type Table, liveQuery } from "dexie";
 import type { Observable } from "rxjs";
+import { useObservable } from "@vueuse/rxjs";
 
 // Local imports
+import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types.js";
 import { database } from "@ogw_internal/database/database.js";
 import { useViewerStore } from "@ogw_front/stores/viewer";
-import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types.js";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 interface CameraPositionRecord {
   id?: number;
@@ -19,38 +14,45 @@ interface CameraPositionRecord {
   camera_options: CameraOptions;
 }
 
+// oxlint-disable-next-line max-lines-per-function
 export const useCameraManagerStore = defineStore("camera_manager", () => {
   const viewerStore = useViewerStore();
+  // Database's table map is assembled dynamically at runtime (see internal/database/database.ts),
+  // So it's typed as `{}`; this store's table is registered before use, hence the cast.
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted database table boundary.
   const camera_positions_db = database.camera_positions as unknown as Table<
     CameraPositionRecord,
     number
   >;
 
-  function refAllCameraPositions() {
+  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
     // `.subscribe`) but not identical, hence the cast.
     return useObservable(
-      liveQuery(() => camera_positions_db.toArray()) as unknown as Observable<
-        CameraPositionRecord[]
-      >,
+      liveQuery(async () => {
+        const positions = await camera_positions_db.toArray();
+        return positions;
+        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
+      }) as unknown as Observable<CameraPositionRecord[]>,
       { initialValue: [] as CameraPositionRecord[] },
     );
   }
 
-  async function getCameraPosition(id: number) {
-    return await camera_positions_db.get(id);
+  async function getCameraPosition(id: number): Promise<CameraPositionRecord | undefined> {
+    const position = await camera_positions_db.get(id);
+    return position;
   }
 
-  async function saveCameraPosition(name: string, camera_options: CameraOptions) {
+  async function saveCameraPosition(name: string, camera_options: CameraOptions): Promise<void> {
     await camera_positions_db.put({
       name,
       camera_options,
-    } as CameraPositionRecord);
+    });
   }
 
-  async function restoreCameraPosition(id: number) {
+  async function restoreCameraPosition(id: number): Promise<void> {
     const position = await camera_positions_db.get(id);
     if (position) {
       const schema = viewer_schemas.opengeodeweb_viewer.viewer.update_camera;
@@ -59,11 +61,11 @@ export const useCameraManagerStore = defineStore("camera_manager", () => {
     }
   }
 
-  async function deleteCameraPosition(id: number) {
+  async function deleteCameraPosition(id: number): Promise<void> {
     await camera_positions_db.delete(id);
   }
 
-  async function renameCameraPosition(id: number, newName: string) {
+  async function renameCameraPosition(id: number, newName: string): Promise<void> {
     await camera_positions_db.update(id, { name: newName });
   }
 

package/app/stores/cloud.ts

@@ -1,9 +1,6 @@
 import { Status } from "@ogw_front/utils/status";
 import { fetchSchema } from "@ogw_shared/utils/fetch_schema";
 import { setAppBaseUrl } from "@ogw_shared/scripts";
-import { useAppStore } from "./app";
-import { useFeedbackStore } from "./feedback";
-import { useInfraStore } from "./infra";
 
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
 
@@ -12,31 +9,39 @@ export const useCloudStore = defineStore("cloud", {
     status: Status.NOT_CONNECTED,
   }),
   actions: {
-    launch(email: string) {
+    async launch(email: string) {
       this.status = Status.CONNECTING;
-      console.log("[CLOUD] Launching cloud backend...");
       const schema = opengeodeweb_front_schemas.api.serverless.run_cloud;
       const params = { email };
-      console.log("[CLOUD] params", params);
+      const { useAppStore } = await import("./app");
+      const { useFeedbackStore } = await import("./feedback");
       const appStore = useAppStore();
       const feedbackStore = useFeedbackStore();
-      return fetchSchema(
+      const result = await fetchSchema(
         { schema, params },
         {
           request_error_function: () => {
             feedbackStore.$patch({ server_error: true });
             this.status = Status.NOT_CONNECTED;
           },
-          response_function: (response: unknown) => {
-            const { url } = response as { url: string };
+          response_function: async (response: unknown) => {
+            if (
+              typeof response !== "object" ||
+              response === null ||
+              !("url" in response) ||
+              typeof response.url !== "string"
+            ) {
+              return;
+            }
+            const { url } = response;
             feedbackStore.$patch({ server_error: false });
-            console.log(`[CLOUD] Cloud launched on ${url}`);
             this.status = Status.CONNECTED;
+            const { useInfraStore } = await import("./infra");
             const infraStore = useInfraStore();
             infraStore.$patch({
               domain_name: url,
             });
-            setAppBaseUrl(appStore.base_url);
+            setAppBaseUrl(appStore.base_url).catch(() => undefined);
             appStore.$patch({
               projectFolderPath: "/project",
             });
@@ -47,11 +52,10 @@ export const useCloudStore = defineStore("cloud", {
           },
         },
       );
+      return result;
     },
     connect() {
-      console.log("[CLOUD] Cloud connected");
       this.status = Status.CONNECTED;
-      return Promise.resolve();
     },
   },
   share: {

package/app/stores/data.ts

@@ -1,19 +1,14 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports, eslint/max-lines
+// oxlint-disable eslint/max-lines
 // Third party imports
-import { liveQuery } from "dexie";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Table } from "dexie";
+import { type Table, liveQuery } from "dexie";
+import type { Observable } from "rxjs";
 import { useObservable } from "@vueuse/rxjs";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-import type { Observable } from "rxjs";
 
 // Local imports
+import { type ModelComponentRecord, useDataMesh } from "./data_helpers/mesh.js";
 import { database } from "@ogw_internal/database/database.js";
 import { useDataCollections } from "./data_helpers/collections.js";
-import { useDataMesh } from "./data_helpers/mesh.js";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { ModelComponentRecord } from "./data_helpers/mesh.js";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 interface DataItem {
@@ -66,12 +61,16 @@ interface ViewableItemLike {
 }
 
 const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic;
+// 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.
+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: ViewableItemLike | undefined | null): boolean {
   if (!item || typeof item !== "object") {
     return false;
   }
   if (item.is_viewable !== undefined) {
-    return Boolean(item.is_viewable);
+    return item.is_viewable;
   }
   if (item.binary_light_viewable !== undefined) {
     return item.binary_light_viewable !== "not_viewable";
@@ -87,9 +86,8 @@ function checkItemViewable(item: ViewableItemLike | undefined | null): boolean {
 }
 function isItemViewable(itemOrId: string | ViewableItemLike): boolean | Promise<boolean> {
   if (typeof itemOrId === "string") {
-    return (database.data as unknown as Table<DataItem, string>)
-      .get(itemOrId)
-      .then(checkItemViewable);
+    // 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);
   }
   return checkItemViewable(itemOrId);
 }
@@ -97,12 +95,12 @@ function isItemViewable(itemOrId: string | ViewableItemLike): boolean | Promise<
 // oxlint-disable-next-line max-lines-per-function, max-statements
 export const useDataStore = defineStore("data", () => {
   const viewerStore = useViewerStore();
-  const data_db = database.data as unknown as Table<DataItem, string>;
-  const model_components_db = database.model_components as unknown as Table<
-    ModelComponentRecord,
-    string
-  >;
-  const model_components_relation_db = database.model_components_relation as unknown as Table<
+  // oxlint-disable-next-line no-unsafe-type-assertion -- database's table map is dynamically typed at runtime; see comment above.
+  const data_db = typedDatabase.data as Table<DataItem, string>;
+  // oxlint-disable-next-line no-unsafe-type-assertion -- database's table map is dynamically typed at runtime; see comment above.
+  const model_components_db = typedDatabase.model_components as Table<ModelComponentRecord, string>;
+  // oxlint-disable-next-line no-unsafe-type-assertion -- database's table map is dynamically typed at runtime; see comment above.
+  const model_components_relation_db = typedDatabase.model_components_relation as Table<
     ModelComponentRelationRecord,
     string
   >;
@@ -133,24 +131,37 @@ export const useDataStore = defineStore("data", () => {
     return data_item;
   }
   async function allItems(): Promise<DataItem[]> {
-    return await data_db.toArray();
+    const items = await data_db.toArray();
+    return items;
   }
-  function refItem(id: string) {
+  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
     // `.subscribe`) but not identical, hence the cast.
     return useObservable(
-      liveQuery(() => data_db.get(id)) as unknown as Observable<DataItem | undefined>,
+      liveQuery(async () => {
+        const data_item = await data_db.get(id);
+        return data_item;
+        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
+      }) as unknown as Observable<DataItem | undefined>,
       {
+        // oxlint-disable-next-line no-unsafe-type-assertion -- placeholder until the live query resolves; consumers must treat this as possibly incomplete.
         initialValue: {} as DataItem,
       },
     );
   }
-  function refAllItems() {
-    return useObservable(liveQuery(() => data_db.toArray()) as unknown as Observable<DataItem[]>, {
-      initialValue: [] as DataItem[],
-    });
+  function refAllItems(): Ref<DataItem[]> {
+    return useObservable(
+      liveQuery(async () => {
+        const items = await data_db.toArray();
+        return items;
+        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
+      }) as unknown as Observable<DataItem[]>,
+      {
+        initialValue: [] as DataItem[],
+      },
+    );
   }
   async function meshComponentType(modelId: string, geode_id: string): Promise<string | undefined> {
     const component = await model_components_db
@@ -159,32 +170,36 @@ export const useDataStore = defineStore("data", () => {
       .first();
     return component?.type;
   }
-  async function registerObject(id: string, name: string) {
+  async function registerObject(id: string, name: string): Promise<unknown> {
     const schema = viewer_generic_schemas.register;
     const params = {
       id,
       name,
     };
-    return await viewerStore.request({
+    const result = await viewerStore.request({
       schema,
       params,
       timeout: 0,
     });
+    return result;
   }
-  async function deregisterObject(id: string) {
+  async function deregisterObject(id: string): Promise<unknown> {
     const schema = viewer_generic_schemas.deregister;
     const params = {
       id,
     };
-    return await viewerStore.request({
+    const result = await viewerStore.request({
       schema,
       params,
     });
+    return result;
   }
-  function addItem(new_item: NewDataItem) {
+  // 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,
+      name: new_item.name ?? new_item.id,
       viewer_type: new_item.viewer_type,
       geode_object_type: new_item.geode_object_type,
       visible: true,
@@ -194,11 +209,16 @@ export const useDataStore = defineStore("data", () => {
     if (new_item.binary_light_viewable !== undefined && new_item.binary_light_viewable !== null) {
       itemData.binary_light_viewable = new_item.binary_light_viewable;
     }
-    return data_db.put(itemData);
+    const id = await data_db.put(itemData);
+    return id;
   }
-  function addComponents(new_item: NewDataItem) {
+  // 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[] = [];
-    function addModelComponents(components: ModelComponentInput[]) {
+    // 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.
+    function addModelComponents(components: readonly ModelComponentInput[]): void {
       for (const component of components) {
         allComponents.push({
           id: new_item.id,
@@ -216,11 +236,18 @@ export const useDataStore = defineStore("data", () => {
     if (new_item.collection_components) {
       addModelComponents(new_item.collection_components);
     }
-    return model_components_db.bulkPut(allComponents);
+    const lastKey = await model_components_db.bulkPut(allComponents);
+    return lastKey;
   }
-  function addComponentRelations(new_item: NewDataItem) {
+  // 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: string[], parent: string, type: string) {
+    function addModelComponentRelations(
+      components: readonly string[],
+      parent: string,
+      type: string,
+    ): void {
       for (const child of components) {
         relations.push({
           id: new_item.id,
@@ -247,13 +274,17 @@ export const useDataStore = defineStore("data", () => {
         }
       }
     }
-    return model_components_relation_db.bulkPut(relations);
+    const lastKey = await model_components_relation_db.bulkPut(relations);
+    return lastKey;
   }
-  async function getComponentByViewerId(modelId: string, viewer_id: string | number) {
+  async function getComponentByViewerId(
+    modelId: string,
+    viewer_id: string | number,
+  ): Promise<ModelComponentRecord | undefined> {
     const component = await model_components_db
       .where("viewer_id")
       .equals(Number(viewer_id))
-      .and((model_component) => model_component.id === modelId)
+      .and((model_component: ModelComponentRecord) => model_component.id === modelId)
       .first();
     return component;
   }
@@ -273,19 +304,27 @@ 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) => Math.trunc(Number(component.viewer_id)));
+    return components.map((component: ModelComponentRecord) =>
+      Math.trunc(Number(component.viewer_id)),
+    );
   }
   async function getMeshComponentsViewerIds(
     modelId: string,
-    meshComponentGeodeIds: string[],
+    meshComponentGeodeIds: readonly string[],
   ): Promise<number[]> {
     const components = await model_components_db
       .where("[id+geode_id]")
       .anyOf(meshComponentGeodeIds.map((geode_id) => [modelId, geode_id]))
       .toArray();
-    return components.map((component) => Math.trunc(Number(component.viewer_id)));
+    return components.map((component: ModelComponentRecord) =>
+      Math.trunc(Number(component.viewer_id)),
+    );
   }
-  async function exportStores() {
+  async function exportStores(): Promise<{
+    items: DataItem[];
+    modelComponents: ModelComponentRecord[];
+    modelComponentsRelations: ModelComponentRelationRecord[];
+  }> {
     const items = await data_db.toArray();
     const modelComponents = await model_components_db.toArray();
     const modelComponentsRelations = await model_components_relation_db.toArray();
@@ -302,9 +341,11 @@ export const useDataStore = defineStore("data", () => {
     await model_components_relation_db.clear();
   }
 
+  // Dexie's bulkPut expects mutable arrays, so this snapshot parameter can't deeply satisfy
+  // The prefer-readonly-parameter-types rule; same pattern as app/utils/import_workflow.ts.
   async function importStores(snapshot: {
-    modelComponents: ModelComponentRecord[];
-    modelComponentsRelations: ModelComponentRelationRecord[];
+    readonly modelComponents: readonly ModelComponentRecord[];
+    readonly modelComponentsRelations: readonly ModelComponentRelationRecord[];
   }): Promise<void> {
     await clear();
     await model_components_db.bulkPut(snapshot.modelComponents);

package/app/stores/data_helpers/collections.ts

@@ -1,15 +1,10 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
-import { liveQuery } from "dexie";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Table } from "dexie";
+import { type FormattedComponent, type ModelComponentRecord, useDataMesh } from "./mesh.js";
 import { MESH_COMPONENT_TYPES } from "@ogw_front/utils/default_styles";
-import { database } from "@ogw_internal/database/database.js";
-import { useDataMesh } from "./mesh.js";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { FormattedComponent, ModelComponentRecord } from "./mesh.js";
-import { useObservable } from "@vueuse/rxjs";
 import type { Observable } from "rxjs";
+import type { Ref } from "vue";
+import { getTable } from "@ogw_internal/database/database.js";
+import { liveQuery } from "dexie";
+import { useObservable } from "@vueuse/rxjs";
 
 interface ModelComponentRelationRecord {
   id: string;
@@ -19,13 +14,13 @@ interface ModelComponentRelationRecord {
 }
 
 interface CollectionComponent extends FormattedComponent {
-  children: FormattedComponent[];
+  readonly children: readonly FormattedComponent[];
 }
 
 interface CollectionComponentGroup {
   id: string;
   title: string;
-  children: CollectionComponent[];
+  readonly children: readonly CollectionComponent[];
 }
 
 function pluralize(type: string): string {
@@ -35,22 +30,25 @@ function pluralize(type: string): string {
   return `${type}s`;
 }
 
-export function useDataCollections() {
-  const model_components_db = database.model_components as unknown as Table<
-    ModelComponentRecord,
-    string
-  >;
-  const model_components_relation_db = database.model_components_relation as unknown as Table<
-    ModelComponentRelationRecord,
-    string
-  >;
+// oxlint-disable-next-line eslint/max-lines-per-function
+export function useDataCollections(): {
+  hasCollectionComponents: typeof hasCollectionComponents;
+  getAllCollectionComponents: typeof getAllCollectionComponents;
+  fetchAllCollectionComponents: typeof fetchAllCollectionComponents;
+  formatedCollectionComponents: typeof formatedCollectionComponents;
+  refFormatedCollectionComponents: typeof refFormatedCollectionComponents;
+} {
+  const model_components_db = getTable<ModelComponentRecord>("model_components");
+  const model_components_relation_db = getTable<ModelComponentRelationRecord>(
+    "model_components_relation",
+  );
   const { getAllMeshComponents } = useDataMesh();
 
   async function hasCollectionComponents(modelId: string): Promise<boolean> {
     const count = await model_components_db
       .where("id")
       .equals(modelId)
-      .and((component) => !MESH_COMPONENT_TYPES.includes(component.type))
+      .and((component: ModelComponentRecord) => !MESH_COMPONENT_TYPES.includes(component.type))
       .count();
     return count > 0;
   }
@@ -58,8 +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) => !MESH_COMPONENT_TYPES.includes(component.type))
-      .map((component) => ({
+      .filter((component: ModelComponentRecord) => !MESH_COMPONENT_TYPES.includes(component.type))
+      .map((component: ModelComponentRecord) => ({
         id: component.geode_id,
         title: component.name,
         category: component.type,
@@ -81,14 +79,13 @@ export function useDataCollections() {
 
     const byType: Record<string, CollectionComponent[]> = {};
     for (const component of components) {
-      if (!byType[component.category]) {
-        byType[component.category] = [];
-      }
+      byType[component.category] ??= [];
       const itemRelations = relations.filter(
-        (relation) => relation.parent === component.id && relation.type === "collection",
+        (relation: ModelComponentRelationRecord) =>
+          relation.parent === component.id && relation.type === "collection",
       );
       const children = itemRelations
-        .map((relation) => meshComponentsById[relation.child])
+        .map((relation: ModelComponentRelationRecord) => meshComponentsById[relation.child])
         .filter((child): child is FormattedComponent => Boolean(child));
       byType[component.category]?.push({
         ...component,
@@ -105,7 +102,7 @@ export function useDataCollections() {
     const collectionTypes = Object.keys(byType);
 
     return collectionTypes
-      .filter((type) => byType[type] && (byType[type]?.length ?? 0) > 0)
+      .filter((type) => (byType[type]?.length ?? 0) > 0)
       .map((type) => ({
         id: type,
         title: pluralize(type),
@@ -113,15 +110,16 @@ export function useDataCollections() {
       }));
   }
 
-  function refFormatedCollectionComponents(modelId: string) {
-    // 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
-    // `.subscribe`) but not identical, hence the cast.
+  function refFormatedCollectionComponents(
+    modelId: string,
+  ): Ref<CollectionComponentGroup[] | undefined> {
     return useObservable(
-      liveQuery(() => formatedCollectionComponents(modelId)) as unknown as Observable<
-        CollectionComponentGroup[]
-      >,
+      // Dexie's liveQuery returns its own Observable-like type, not rxjs's Observable, so bridging needs a cast.
+      liveQuery(async () => {
+        const groups = await formatedCollectionComponents(modelId);
+        return groups;
+        // oxlint-disable-next-line no-unsafe-type-assertion
+      }) as unknown as Observable<CollectionComponentGroup[]>,
       {
         initialValue: undefined,
       },