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

package/app/utils/extension.ts

@@ -3,12 +3,10 @@
 // Third party imports
 
 // Local imports
+import type { RegisterableStore, useAppStore } from "@ogw_front/stores/app";
+import type { Microservice } from "@ogw_front/stores/infra";
 import { isCloudMode } from "@ogw_front/utils/stores";
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
-import { useAppStore } from "@ogw_front/stores/app";
-import { useInfraStore } from "@ogw_front/stores/infra";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Microservice } from "@ogw_front/stores/infra";
 
 interface ExtensionDescriptor {
   id: string;
@@ -23,12 +21,22 @@ interface DownloadExtensionParams {
   extensionFileName: string;
 }
 
+type AppStoreInstance = ReturnType<typeof useAppStore>;
+type ExtensionModuleType = Awaited<ReturnType<AppStoreInstance["loadExtension"]>>;
+interface RegisteredExtension {
+  name: string;
+  version: string;
+  extensionModule: ExtensionModuleType;
+}
+
 async function uploadExtension(file: File): Promise<void> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   await appStore.upload(file);
 }
 
-function runExtensions() {
+async function runExtensions(): Promise<{ extensionsArray: ExtensionDescriptor[] }> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { projectFolderPath } = appStore;
   const { PROJECT: projectName } = useRuntimeConfig().public;
@@ -39,13 +47,18 @@ function runExtensions() {
     projectFolderPath,
     projectName,
   };
-  return appStore.request({
+  const result = await appStore.request<{ extensionsArray: ExtensionDescriptor[] }>({
     schema,
     params,
-  }) as Promise<{ extensionsArray: ExtensionDescriptor[] }>;
+  });
+  return result;
 }
 
-function downloadExtension({ url, extensionFileName }: DownloadExtensionParams) {
+async function downloadExtension({
+  url,
+  extensionFileName,
+}: DownloadExtensionParams): Promise<unknown> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { PROJECT: projectName } = useRuntimeConfig().public;
   const schema = opengeodeweb_front_schemas.api.microservice.extensions.download;
@@ -54,18 +67,25 @@ function downloadExtension({ url, extensionFileName }: DownloadExtensionParams)
     url,
     extensionFileName,
   };
-  return appStore.request({
+  const result = await appStore.request({
     schema,
     params,
   });
+  return result;
+}
+
+function isMicroservice(store: RegisterableStore): store is RegisterableStore & Microservice {
+  return typeof store.connect === "function";
 }
 
-async function registerRunningExtensions() {
+async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
+  const { useInfraStore } = await import("@ogw_front/stores/infra");
   const appStore = useAppStore();
   const infraStore = useInfraStore();
   const { extensionsArray } = await runExtensions();
   return Promise.all(
-    extensionsArray.map(async (extension) => {
+    extensionsArray.map(async (extension: ExtensionDescriptor) => {
       const { id, name, version, frontendContent, port } = extension;
       const blob = new Blob([frontendContent], {
         type: "application/javascript",
@@ -80,7 +100,11 @@ async function registerRunningExtensions() {
       // Extension-provided stores are expected to satisfy the fuller
       // Microservice contract (connect, etc.) even though the loader's own
       // RegisterableStore type only models what app.ts itself needs.
-      infraStore.register_microservice(store as unknown as Microservice);
+      if (isMicroservice(store)) {
+        infraStore.register_microservice(store);
+      } else {
+        console.warn("[ExtensionManager] Store does not implement Microservice:", store.$id);
+      }
       return {
         name,
         version,
@@ -90,17 +114,18 @@ async function registerRunningExtensions() {
   );
 }
 
-async function importExtensionFile(file: File) {
+async function importExtensionFile(file: File): Promise<RegisteredExtension[]> {
   await uploadExtension(file);
   return registerRunningExtensions();
 }
 
-async function importExtensionURL(url: DownloadExtensionParams) {
+async function importExtensionURL(url: DownloadExtensionParams): Promise<RegisteredExtension[]> {
   await downloadExtension(url);
   return registerRunningExtensions();
 }
 
 async function unloadExtension(extensionId: string): Promise<boolean> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   console.log("[ExtensionManager] Unloading extension:", extensionId);
   const extensionData = appStore.getExtension(extensionId);
@@ -111,21 +136,22 @@ async function unloadExtension(extensionId: string): Promise<boolean> {
 
   // Get the store if it exists
   const storeFactory = extensionData.metadata?.store;
-  if (storeFactory) {
+  if (storeFactory !== undefined) {
     const store = storeFactory();
     // Stop the microservice if possible
-    if (typeof store.kill === "function") {
-      await (store.kill as () => Promise<void>)();
+    if (store.kill) {
+      await store.kill();
     }
   }
 
   // Unload from AppStore
-  appStore.unloadExtension(extensionId);
+  await appStore.unloadExtension(extensionId);
   console.log("[ExtensionManager] Extension unloaded:", extensionId);
   return true;
 }
 
-function killExtension(extensionId: string) {
+async function killExtension(extensionId: string): Promise<unknown> {
+  const { useAppStore } = await import("@ogw_front/stores/app");
   const appStore = useAppStore();
   const { projectFolderPath } = appStore;
   const { PROJECT: projectName } = useRuntimeConfig().public;
@@ -135,10 +161,11 @@ function killExtension(extensionId: string) {
     projectFolderPath,
     projectName,
   };
-  return appStore.request({
+  const result = await appStore.request({
     schema,
     params,
   });
+  return result;
 }
 export {
   importExtensionFile,

package/app/utils/import_workflow.ts

@@ -3,20 +3,20 @@
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
 
 // Local imports
+import { type NewDataItem, useDataStore } from "@ogw_front/stores/data";
 import { useBackStore } from "@ogw_front/stores/back";
-import { useDataStore } from "@ogw_front/stores/data";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { NewDataItem } from "@ogw_front/stores/data";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useTreeviewStore } from "@ogw_front/stores/treeview";
 
 interface FileToImport {
-  filename: string;
-  geode_object_type: string;
+  readonly filename: string;
+  readonly geode_object_type: 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();
@@ -74,10 +74,11 @@ async function importFile(filename: string, geode_object_type: string): Promise<
     schema,
     params,
   });
+  // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary; the back-end response shape matches NewDataItem.
   return importItem(response as NewDataItem);
 }
 
-async function importWorkflow(files: FileToImport[]): Promise<string[]> {
+async function importWorkflow(files: readonly FileToImport[]): Promise<string[]> {
   const chunk_size = 5;
   const chunks: FileToImport[][] = [];
   for (let i = 0; i < files.length; i += chunk_size) {
@@ -91,20 +92,22 @@ async function importWorkflow(files: FileToImport[]): Promise<string[]> {
     }
     const chunk = chunks[chunkIndex] ?? [];
     const chunk_results = await Promise.all(
-      chunk.map(
-        async ({ filename, geode_object_type }) => await importFile(filename, geode_object_type),
-      ),
+      chunk.map(async ({ filename, geode_object_type }) => {
+        const id = await importFile(filename, geode_object_type);
+        return id;
+      }),
     );
     results.push(...chunk_results);
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
   const hybridViewerStore = useHybridViewerStore();
-  hybridViewerStore.remoteRender();
+  await hybridViewerStore.remoteRender();
   return results;
 }
 
-async function importWorkflowFromSnapshot(items: NewDataItem[]): Promise<string[]> {
+// NewDataItem has mutable array fields (mesh_components, collection_components), so a readonly array of it can't satisfy prefer-readonly-parameter-types deeply; left unfixed (same pattern as app/plugins/auto_store_register.ts).
+async function importWorkflowFromSnapshot(items: readonly NewDataItem[]): Promise<string[]> {
   console.log("[importWorkflowFromSnapshot] start", { count: items?.length });
   const hybridViewerStore = useHybridViewerStore();
   const chunk_size = 5;
@@ -118,12 +121,17 @@ async function importWorkflowFromSnapshot(items: NewDataItem[]): Promise<string[
       return;
     }
     const chunk = chunks[chunkIndex] ?? [];
-    const chunk_ids = await Promise.all(chunk.map((item) => importItem(item)));
+    const chunk_ids = await Promise.all(
+      chunk.map(async (item) => {
+        const id = await importItem(item);
+        return id;
+      }),
+    );
     ids.push(...chunk_ids);
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
-  hybridViewerStore.remoteRender();
+  await hybridViewerStore.remoteRender();
   console.log("[importWorkflowFromSnapshot] done", {
     ids,
   });

package/app/utils/name_cleaner.ts

@@ -8,7 +8,7 @@ function formatListId(
   sliceStart: number = DEFAULT_SLICE_START,
   sliceEndOffset: number = DEFAULT_SLICE_END_OFFSET,
 ): string {
-  if (!id) {
+  if (id === undefined || id === null || id === "") {
     return "";
   }
   if (id.length <= maxLength) {

package/app/utils/string.ts

@@ -16,7 +16,7 @@ export function middleTruncate(
   startChars: number = DEFAULT_START_CHARS,
   endChars: number = DEFAULT_END_CHARS,
 ): string | undefined | null {
-  if (!text || text.length <= maxLength) {
+  if (text === undefined || text === null || text.length <= maxLength) {
     return text;
   }
 

package/app/utils/treeview.ts

@@ -1,6 +1,6 @@
 function compareSelections<Item>(
-  current: Item[],
-  previous: Item[],
+  current: readonly Item[],
+  previous: readonly Item[],
 ): { added: Item[]; removed: Item[] } {
   const added = current.filter((item) => !previous.includes(item));
   const removed = previous.filter((item) => !current.includes(item));

package/internal/database/base_database.ts

@@ -8,7 +8,7 @@ import { modelComponentsRelationTable } from "./tables/model_components_relation
 import { modelComponentsTable } from "./tables/model_components";
 
 export class BaseDatabase extends Dexie {
-  static get initialStores(): Record<string, string> {
+  public static get initialStores(): Record<string, string> {
     return {
       [dataTable.name]: dataTable.schema,
       [modelComponentsTable.name]: modelComponentsTable.schema,
@@ -21,7 +21,11 @@ export class BaseDatabase extends Dexie {
     };
   }
 
-  clear(): Promise<void[]> {
-    return Promise.all(this.tables.map((table) => table.clear()));
+  public async clear(): Promise<void> {
+    await Promise.all(
+      this.tables.map(async (table) => {
+        await table.clear();
+      }),
+    );
   }
 }

package/internal/database/database.ts

@@ -1,9 +1,5 @@
-// 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 { Dexie, type Table } from "dexie";
 import { BaseDatabase } from "./base_database";
-import { Dexie } from "dexie";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Table } from "dexie";
 import { ExtendedDatabase } from "./extended_database";
 
 interface DatabaseContainer {
@@ -13,17 +9,17 @@ interface DatabaseContainer {
 const databaseContainer: DatabaseContainer = { instance: undefined };
 
 class Database extends BaseDatabase {
-  constructor() {
+  public constructor() {
     super("Database");
 
     this.version(3).stores(BaseDatabase.initialStores);
   }
 
-  static async addTable(tableName: string, schemaDefinition: string): Promise<void> {
+  public static async addTable(tableName: string, schemaDefinition: string): Promise<void> {
     await this.addTables({ [tableName]: schemaDefinition });
   }
 
-  static async addTables(newTables: Record<string, string>): Promise<void> {
+  public static async addTables(newTables: Record<string, string>): Promise<void> {
     let currentVersion = 1;
     let currentStores: Record<string, string> = { ...BaseDatabase.initialStores };
 
@@ -44,10 +40,12 @@ class Database extends BaseDatabase {
       tempDb.close();
     }
 
-    const allExisting = Object.keys(newTables).every((tableName) => currentStores[tableName]);
+    const allExisting = Object.keys(newTables).every(
+      (tableName) => currentStores[tableName] !== undefined,
+    );
 
     // Set at module load time below; always defined by the time addTable/addTables runs.
-    databaseContainer.instance!.close();
+    databaseContainer.instance?.close();
 
     if (allExisting) {
       const existingDb = new Dexie("Database");
@@ -70,23 +68,35 @@ class Database extends BaseDatabase {
 
 // oxlint-disable-next-line no-top-level-await
 await Dexie.delete("Database");
-databaseContainer.instance = new Database();
-(databaseContainer.instance as Database).clear();
+const initialDatabase = new Database();
+databaseContainer.instance = initialDatabase;
+// oxlint-disable-next-line no-top-level-await
+await initialDatabase.clear();
 
 // The set of tables is assembled dynamically at runtime (Database.addTable/addTables add stores on the fly), so fully modelling this with Dexie's row generics isn't worth it here: the proxy target is typed loosely as "any table name maps to a Dexie Table of loosely-typed rows".
-interface DatabaseTables {
-  [tableName: string]: Table<Record<string, unknown>, string>;
-}
-
-const database = new Proxy({} as DatabaseTables, {
-  get(_target, prop: string | symbol) {
-    const instance = databaseContainer.instance as unknown as Record<string | symbol, unknown>;
-    const value = instance[prop];
-    if (typeof value === "function") {
-      return value.bind(databaseContainer.instance);
-    }
-    return value;
+type DatabaseTables = Record<string, Table<Record<string, unknown>, string>>;
+
+const database = new Proxy<DatabaseTables>(
+  {},
+  {
+    get(_target, prop: string | symbol): unknown {
+      // The instance is a Dexie subclass whose tables are only known dynamically at runtime.
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      const instance = databaseContainer.instance as unknown as Record<string | symbol, unknown>;
+      const value = instance[prop];
+      if (typeof value === "function") {
+        // oxlint-disable-next-line no-unsafe-return
+        return value.bind(databaseContainer.instance);
+      }
+      return value;
+    },
   },
-});
+);
+
+// The proxy only knows the loose DatabaseTables shape; callers cast to the row type they know a given table holds.
+function getTable<TRow>(tableName: string): Table<TRow, string> {
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return database[tableName] as unknown as Table<TRow, string>;
+}
 
-export { Database, database };
+export { Database, database, getTable };

package/internal/database/extended_database.ts

@@ -1,7 +1,7 @@
 import { BaseDatabase } from "./base_database";
 
 export class ExtendedDatabase extends BaseDatabase {
-  constructor(
+  public constructor(
     currentVersion: number,
     currentStores: Record<string, string>,
     newTables: Record<string, string>,

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

@@ -49,10 +49,32 @@ function isMeshCellsCellAttributeValid({
 }
 
 // oxlint-disable-next-line max-lines-per-function
-function useMeshCellsCellAttributeStyle() {
+function useMeshCellsCellAttributeStyle(): {
+  meshCellsCellAttributeName: (id: string) => string | undefined;
+  meshCellsCellAttributeItem: (id: string) => number;
+  meshCellsCellAttributeRange: (id: string) => [number | undefined, number | undefined];
+  meshCellsCellAttributeColorMap: (id: string) => string | undefined;
+  meshCellsCellAttributeStoredConfig: (
+    id: string,
+    name: string | undefined,
+    item: number | undefined,
+  ) => AttributeStoredConfig;
+  setMeshCellsCellAttribute: (id: string, input: AttributeInput) => Promise<unknown>;
+  setMeshCellsCellAttributeName: (id: string, name: string) => Promise<unknown>;
+  setMeshCellsCellAttributeItem: (id: string, item: number) => Promise<unknown>;
+  setMeshCellsCellAttributeRange: (
+    id: string,
+    minimum: number,
+    maximum: number,
+  ) => Promise<unknown>;
+  setMeshCellsCellAttributeColorMap: (id: string, colorMap: string | undefined) => Promise<unknown>;
+  meshCellsCellAttributeNoDataColor: (id: string) => unknown;
+  setMeshCellsCellAttributeNoDataColor: (id: string, no_data_color: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
   function meshCellsCellAttribute(id: string): AttributeState {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring.cell shape is defined by the data style schema.
     return meshCellsCommonStyle.meshCellsColoring(id).cell as AttributeState;
   }
   function meshCellsCellAttributeStoredConfig(
@@ -61,14 +83,10 @@ function useMeshCellsCellAttributeStyle() {
     item: number | undefined,
   ): AttributeStoredConfig {
     const { storedConfigs } = meshCellsCellAttribute(id);
-    if (
-      storedConfigs &&
-      name !== undefined &&
-      name in storedConfigs &&
-      item !== undefined &&
-      item in storedConfigs[name]!
-    ) {
-      return storedConfigs[name]![item]!;
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    const itemConfig = item === undefined ? undefined : nameConfig?.[item];
+    if (itemConfig !== undefined) {
+      return itemConfig;
     }
     return {
       minimum: undefined,
@@ -77,35 +95,41 @@ function useMeshCellsCellAttributeStyle() {
       no_data_color: DEFAULT_NO_DATA_COLOR,
     };
   }
-  function mutateMeshCellsCellStyle(id: string, values: Record<string, unknown>) {
-    return meshCellsCommonStyle.mutateMeshCellsStyle(id, {
+  async function mutateMeshCellsCellStyle(
+    id: string,
+    values: Record<string, unknown>,
+  ): Promise<string> {
+    const result = await meshCellsCommonStyle.mutateMeshCellsStyle(id, {
       coloring: {
         cell: values,
       },
     });
+    return result;
   }
-  function setMeshCellsCellAttributeStoredConfig(
+  async function setMeshCellsCellAttributeStoredConfig(
     id: string,
     name: string | undefined,
     item: number | undefined,
     config: Partial<AttributeStoredConfig>,
-  ) {
-    return mutateMeshCellsCellStyle(id, {
+  ): Promise<string> {
+    const result = await mutateMeshCellsCellStyle(id, {
       storedConfigs: {
-        [name as string]: {
+        [name ?? ""]: {
           lastItem: item,
-          [item as number]: config,
+          [item ?? 0]: config,
         },
       },
     });
+    return result;
   }
   function meshCellsCellAttributeName(id: string): string | undefined {
     return meshCellsCellAttribute(id).name;
   }
   function meshCellsCellAttributeLastItem(id: string, name: string | undefined): number {
     const { storedConfigs } = meshCellsCellAttribute(id);
-    if (storedConfigs && name !== undefined && name in storedConfigs) {
-      return storedConfigs[name]!.lastItem;
+    const nameConfig = name === undefined ? undefined : storedConfigs?.[name];
+    if (nameConfig !== undefined) {
+      return nameConfig.lastItem;
     }
     return 0;
   }
@@ -113,7 +137,7 @@ function useMeshCellsCellAttributeStyle() {
     const { item, name } = meshCellsCellAttribute(id);
     return item ?? meshCellsCellAttributeLastItem(id, name);
   }
-  function setMeshCellsCellAttribute(
+  async function setMeshCellsCellAttribute(
     id: string,
     {
       name,
@@ -123,18 +147,18 @@ function useMeshCellsCellAttributeStyle() {
       colorMap,
       no_data_color = DEFAULT_NO_DATA_COLOR,
     }: AttributeInput,
-  ) {
-    mutateMeshCellsCellStyle(id, {
+  ): Promise<unknown> {
+    await mutateMeshCellsCellStyle(id, {
       name,
       item,
     });
-    setMeshCellsCellAttributeStoredConfig(id, name, item, {
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
       minimum,
       maximum,
       colorMap,
       no_data_color,
     });
-    const points = getRGBPointsFromPreset(colorMap as string);
+    const points = getRGBPointsFromPreset(colorMap ?? "");
     const schema = meshCellsCellAttributeSchemas.attribute;
     const params = {
       id,
@@ -150,7 +174,7 @@ function useMeshCellsCellAttributeStyle() {
       params,
     });
   }
-  function applyCellAttribute(id: string) {
+  async function applyCellAttribute(id: string): Promise<unknown> {
     const name = meshCellsCellAttributeName(id);
     const item = meshCellsCellAttributeItem(id);
     const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
@@ -163,19 +187,21 @@ function useMeshCellsCellAttributeStyle() {
       no_data_color: storedConfig.no_data_color,
     };
     if (isMeshCellsCellAttributeValid(attribute)) {
-      return setMeshCellsCellAttribute(id, attribute);
+      const result = await setMeshCellsCellAttribute(id, attribute);
+      return result;
     }
+    return undefined;
   }
-  function setMeshCellsCellAttributeName(id: string, name: string) {
+  async function setMeshCellsCellAttributeName(id: string, name: string): Promise<unknown> {
     const item = meshCellsCellAttributeLastItem(id, name);
-    mutateMeshCellsCellStyle(id, {
+    await mutateMeshCellsCellStyle(id, {
       name,
       item,
     });
     return applyCellAttribute(id);
   }
-  function setMeshCellsCellAttributeItem(id: string, item: number) {
-    mutateMeshCellsCellStyle(id, {
+  async function setMeshCellsCellAttributeItem(id: string, item: number): Promise<unknown> {
+    await mutateMeshCellsCellStyle(id, {
       item,
     });
     return applyCellAttribute(id);
@@ -186,10 +212,14 @@ function useMeshCellsCellAttributeStyle() {
     const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
     return [storedConfig.minimum, storedConfig.maximum];
   }
-  function setMeshCellsCellAttributeRange(id: string, minimum: number, maximum: number) {
+  async function setMeshCellsCellAttributeRange(
+    id: string,
+    minimum: number,
+    maximum: number,
+  ): Promise<unknown> {
     const name = meshCellsCellAttributeName(id);
     const item = meshCellsCellAttributeItem(id);
-    setMeshCellsCellAttributeStoredConfig(id, name, item, {
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
       minimum,
       maximum,
     });
@@ -201,10 +231,13 @@ function useMeshCellsCellAttributeStyle() {
     const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
     return storedConfig.colorMap;
   }
-  function setMeshCellsCellAttributeColorMap(id: string, colorMap: string | undefined) {
+  async function setMeshCellsCellAttributeColorMap(
+    id: string,
+    colorMap: string | undefined,
+  ): Promise<unknown> {
     const name = meshCellsCellAttributeName(id);
     const item = meshCellsCellAttributeItem(id);
-    setMeshCellsCellAttributeStoredConfig(id, name, item, {
+    await setMeshCellsCellAttributeStoredConfig(id, name, item, {
       colorMap,
     });
     return applyCellAttribute(id);
@@ -215,7 +248,10 @@ function useMeshCellsCellAttributeStyle() {
     const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);
     return storedConfig.no_data_color;
   }
-  async function setMeshCellsCellAttributeNoDataColor(id: string, no_data_color: unknown) {
+  async function setMeshCellsCellAttributeNoDataColor(
+    id: string,
+    no_data_color: unknown,
+  ): Promise<unknown> {
     const name = meshCellsCellAttributeName(id);
     const item = meshCellsCellAttributeItem(id);
     const storedConfig = meshCellsCellAttributeStoredConfig(id, name, item);

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

@@ -8,27 +8,33 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 // Local constants
 const schema = viewer_schemas.opengeodeweb_viewer.mesh.cells.color;
 
-export function useMeshCellsColorStyle() {
+export function useMeshCellsColorStyle(): {
+  meshCellsColor: (id: string) => unknown;
+  setMeshCellsColor: (id: string, color: unknown) => Promise<unknown>;
+} {
   const viewerStore = useViewerStore();
   const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsColor(id: string): unknown {
     return meshCellsCommonStyle.meshCellsColoring(id).constant;
   }
-  function setMeshCellsColor(id: string, color: unknown) {
+  async function setMeshCellsColor(id: string, color: unknown): Promise<unknown> {
     const params = { id, color };
-    return viewerStore.request(
+    const result = await viewerStore.request(
       {
         schema,
         params,
       },
       {
-        response_function: () =>
-          meshCellsCommonStyle.mutateMeshCellsColoring(id, {
+        response_function: async () => {
+          const mutateResult = await meshCellsCommonStyle.mutateMeshCellsColoring(id, {
             constant: color,
-          }),
+          });
+          return mutateResult;
+        },
       },
     );
+    return result;
   }
 
   return {