@geode/opengeodeweb-front 10.6.2 → 10.6.3-rc.1

package/internal/database/extended_database.js

@@ -1,28 +1,27 @@
-import { Dexie } from "dexie"
-import { dataTable } from "./tables/data"
-import { modelComponentsRelationTable } from "./tables/model_components_relation"
-import { modelComponentsTable } from "./tables/model_components"
+import { Dexie } from "dexie";
+import { dataTable } from "./tables/data";
+import { modelComponentsRelationTable } from "./tables/model_components_relation";
+import { modelComponentsTable } from "./tables/model_components";
 
 export class ExtendedDatabase extends Dexie {
   constructor(currentVersion, currentStores, newTables) {
-    super("Database")
+    super("Database");
 
     for (let version = 1; version <= currentVersion; version += 1) {
       if (version === 1) {
         this.version(1).stores({
           [dataTable.name]: dataTable.schema,
           [modelComponentsTable.name]: modelComponentsTable.schema,
-          [modelComponentsRelationTable.name]:
-            modelComponentsRelationTable.schema,
-        })
+          [modelComponentsRelationTable.name]: modelComponentsRelationTable.schema,
+        });
       } else {
-        this.version(version).stores(currentStores)
+        this.version(version).stores(currentStores);
       }
     }
 
     this.version(currentVersion + 1).stores({
       ...currentStores,
       ...newTables,
-    })
+    });
   }
 }

package/internal/database/tables/data.js

@@ -1,5 +1,4 @@
 export const dataTable = {
   name: "data",
-  schema:
-    "id, name, viewer_type, geode_object_type, visible, created_at, binary_light_viewable",
-}
+  schema: "id, name, viewer_type, geode_object_type, visible, created_at, binary_light_viewable",
+};

package/internal/database/tables/model_components.js

@@ -1,4 +1,4 @@
 export const modelComponentsTable = {
   name: "model_components",
   schema: "[id+geode_id], [id+type], viewer_id, name",
-}
+};

package/internal/database/tables/model_components_relation.js

@@ -1,4 +1,4 @@
 export const modelComponentsRelationTable = {
   name: "model_components_relation",
   schema: "[id+parent+child], type",
-}
+};

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

@@ -1,130 +1,114 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
-import { useMeshCellsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap";
+import { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsCellAttributeSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.cell
+const meshCellsCellAttributeSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.attribute.cell;
 
 export function useMeshCellsCellAttributeStyle() {
-  const viewerStore = useViewerStore()
-  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsCellAttribute(id) {
-    return meshCellsCommonStyle.meshCellsColoring(id).cell
+    return meshCellsCommonStyle.meshCellsColoring(id).cell;
   }
 
   function meshCellsCellAttributeStoredConfig(id, name) {
-    const { storedConfigs } = meshCellsCellAttribute(id)
+    const { storedConfigs } = meshCellsCellAttribute(id);
     if (name in storedConfigs) {
-      return storedConfigs[name]
+      return storedConfigs[name];
     }
     return setMeshCellsCellAttributeStoredConfig(id, name, {
       minimum: undefined,
       maximum: undefined,
       colorMap: undefined,
-    })
+    });
   }
 
-  function setMeshCellsCellAttributeStoredConfig(
-    id,
-    name,
-    { minimum, maximum, colorMap },
-  ) {
-    const { storedConfigs } = meshCellsCellAttribute(id)
-    storedConfigs[name] = { minimum, maximum, colorMap }
-    return storedConfigs[name]
+  function setMeshCellsCellAttributeStoredConfig(id, name, { minimum, maximum, colorMap }) {
+    const { storedConfigs } = meshCellsCellAttribute(id);
+    storedConfigs[name] = { minimum, maximum, colorMap };
+    return storedConfigs[name];
   }
 
   function meshCellsCellAttributeName(id) {
-    console.log(
-      meshCellsCellAttributeName.name,
-      { id },
-      meshCellsCellAttribute(id),
-    )
-    return meshCellsCellAttribute(id).name
+    console.log(meshCellsCellAttributeName.name, { id }, meshCellsCellAttribute(id));
+    return meshCellsCellAttribute(id).name;
   }
   function setMeshCellsCellAttributeName(id, name) {
-    console.log(setMeshCellsCellAttributeName.name, { id, name })
+    console.log(setMeshCellsCellAttributeName.name, { id, name });
     return viewerStore.request(
       meshCellsCellAttributeSchemas.name,
       { id, name },
       {
         response_function: async () => {
-          meshCellsCellAttribute(id).name = name
-          const { minimum, maximum } = meshCellsCellAttributeStoredConfig(
-            id,
-            name,
-          )
-          await setMeshCellsCellAttributeRange(id, minimum, maximum)
-          console.log(
-            setMeshCellsCellAttributeName.name,
-            { id },
-            meshCellsCellAttributeName(id),
-          )
+          meshCellsCellAttribute(id).name = name;
+          const { minimum, maximum } = meshCellsCellAttributeStoredConfig(id, name);
+          await setMeshCellsCellAttributeRange(id, minimum, maximum);
+          console.log(setMeshCellsCellAttributeName.name, { id }, meshCellsCellAttributeName(id));
         },
       },
-    )
+    );
   }
 
   function meshCellsCellAttributeRange(id) {
-    const name = meshCellsCellAttributeName(id)
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name)
-    const { minimum, maximum } = storedConfig
-    return [minimum, maximum]
+    const name = meshCellsCellAttributeName(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
   }
   function setMeshCellsCellAttributeRange(id, minimum, maximum) {
-    const name = meshCellsCellAttributeName(id)
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name)
-    storedConfig.minimum = minimum
-    storedConfig.maximum = maximum
-    return setMeshCellsCellAttributeColorMap(id, storedConfig.colorMap)
+    const name = meshCellsCellAttributeName(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
+    storedConfig.minimum = minimum;
+    storedConfig.maximum = maximum;
+    return setMeshCellsCellAttributeColorMap(id, storedConfig.colorMap);
   }
 
   function meshCellsCellAttributeColorMap(id) {
-    const name = meshCellsCellAttributeName(id)
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name)
-    const { colorMap } = storedConfig
-    return colorMap
+    const name = meshCellsCellAttributeName(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
   }
   function setMeshCellsCellAttributeColorMap(id, colorMap) {
-    const name = meshCellsCellAttributeName(id)
-    const storedConfig = meshCellsCellAttributeStoredConfig(id, name)
+    const name = meshCellsCellAttributeName(id);
+    const storedConfig = meshCellsCellAttributeStoredConfig(id, name);
     if (
       storedConfig.minimum === undefined ||
       storedConfig.maximum === undefined ||
       colorMap === undefined
     ) {
-      storedConfig.colorMap = colorMap
-      return
+      storedConfig.colorMap = colorMap;
+      return;
     }
-    const points = getRGBPointsFromPreset(colorMap)
-    const { minimum, maximum } = storedConfig
+    const points = getRGBPointsFromPreset(colorMap);
+    const { minimum, maximum } = storedConfig;
 
     console.log(setMeshCellsCellAttributeColorMap.name, {
       id,
       minimum,
       maximum,
       colorMap,
-    })
+    });
     return viewerStore.request(
       meshCellsCellAttributeSchemas.color_map,
       { id, points, minimum, maximum },
       {
         response_function: () => {
-          storedConfig.colorMap = colorMap
+          storedConfig.colorMap = colorMap;
           console.log(
             setMeshCellsCellAttributeColorMap.name,
             { id },
             meshCellsCellAttributeColorMap(id),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
@@ -135,5 +119,5 @@ export function useMeshCellsCellAttributeStyle() {
     setMeshCellsCellAttributeName,
     setMeshCellsCellAttributeRange,
     setMeshCellsCellAttributeColorMap,
-  }
+  };
 }

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

@@ -1,20 +1,19 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { useMeshCellsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsColorSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.cells.color
+const meshCellsColorSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.color;
 
 export function useMeshCellsColorStyle() {
-  const viewerStore = useViewerStore()
-  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsColor(id) {
-    return meshCellsCommonStyle.meshCellsColoring(id).color
+    return meshCellsCommonStyle.meshCellsColoring(id).color;
   }
   function setMeshCellsColor(id, color) {
     return viewerStore.request(
@@ -22,19 +21,15 @@ export function useMeshCellsColorStyle() {
       { id, color },
       {
         response_function: () => {
-          meshCellsCommonStyle.meshCellsColoring(id).color = color
-          console.log(
-            setMeshCellsColor.name,
-            { id },
-            JSON.stringify(meshCellsColor(id)),
-          )
+          meshCellsCommonStyle.meshCellsColoring(id).color = color;
+          console.log(setMeshCellsColor.name, { id }, JSON.stringify(meshCellsColor(id)));
         },
       },
-    )
+    );
   }
 
   return {
     meshCellsColor,
     setMeshCellsColor,
-  }
+  };
 }

package/internal/stores/data_style/mesh/cells/common.js

@@ -1,23 +1,23 @@
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
 
 export function useMeshCellsCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function meshCellsStyle(id) {
-    return dataStyleStateStore.getStyle(id).cells
+    return dataStyleStateStore.getStyle(id).cells;
   }
 
   function meshCellsColoring(id) {
-    return meshCellsStyle(id).coloring
+    return meshCellsStyle(id).coloring;
   }
 
   function meshCellsActiveColoring(id) {
-    return meshCellsColoring(id).active
+    return meshCellsColoring(id).active;
   }
 
   return {
     meshCellsStyle,
     meshCellsColoring,
     meshCellsActiveColoring,
-  }
+  };
 }

package/internal/stores/data_style/mesh/cells/index.js

@@ -1,74 +1,64 @@
 // Third party imports
 
 // Local imports
-import { useMeshCellsCellAttributeStyle } from "./cell"
-import { useMeshCellsColorStyle } from "./color"
-import { useMeshCellsCommonStyle } from "./common"
-import { useMeshCellsTexturesStyle } from "./textures"
-import { useMeshCellsVertexAttributeStyle } from "./vertex"
-import { useMeshCellsVisibilityStyle } from "./visibility"
+import { useMeshCellsCellAttributeStyle } from "./cell";
+import { useMeshCellsColorStyle } from "./color";
+import { useMeshCellsCommonStyle } from "./common";
+import { useMeshCellsTexturesStyle } from "./textures";
+import { useMeshCellsVertexAttributeStyle } from "./vertex";
+import { useMeshCellsVisibilityStyle } from "./visibility";
 
 // Local constants
 
 export function useMeshCellsStyle() {
-  const meshCellsCommonStyle = useMeshCellsCommonStyle()
-  const meshCellsVisibility = useMeshCellsVisibilityStyle()
-  const meshCellsColorStyle = useMeshCellsColorStyle()
-  const meshCellsTexturesStore = useMeshCellsTexturesStyle()
-  const meshCellsVertexAttributeStyle = useMeshCellsVertexAttributeStyle()
-  const meshCellsCellAttributeStyle = useMeshCellsCellAttributeStyle()
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
+  const meshCellsVisibility = useMeshCellsVisibilityStyle();
+  const meshCellsColorStyle = useMeshCellsColorStyle();
+  const meshCellsTexturesStore = useMeshCellsTexturesStyle();
+  const meshCellsVertexAttributeStyle = useMeshCellsVertexAttributeStyle();
+  const meshCellsCellAttributeStyle = useMeshCellsCellAttributeStyle();
 
   async function setMeshCellsActiveColoring(id, type) {
-    const coloring = meshCellsCommonStyle.meshCellsColoring(id)
-    coloring.active = type
+    const coloring = meshCellsCommonStyle.meshCellsColoring(id);
+    coloring.active = type;
     console.log(
       setMeshCellsActiveColoring.name,
       { id },
       meshCellsCommonStyle.meshCellsActiveColoring(id),
-    )
+    );
     if (type === "color") {
-      return meshCellsColorStyle.setMeshCellsColor(
-        id,
-        meshCellsColorStyle.meshCellsColor(id),
-      )
-    } else if (type === "textures") {
-      const textures = meshCellsTexturesStore.meshCellsTextures(id)
+      return meshCellsColorStyle.setMeshCellsColor(id, meshCellsColorStyle.meshCellsColor(id));
+    }
+    if (type === "textures") {
+      const textures = meshCellsTexturesStore.meshCellsTextures(id);
       if (textures === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshCellsTexturesStore.setMeshCellsTextures(id, textures)
-    } else if (type === "vertex") {
-      const name =
-        meshCellsVertexAttributeStyle.meshCellsVertexAttributeName(id)
+      return meshCellsTexturesStore.setMeshCellsTextures(id, textures);
+    }
+    if (type === "vertex") {
+      const name = meshCellsVertexAttributeStyle.meshCellsVertexAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      return meshCellsVertexAttributeStyle.setMeshCellsVertexAttributeName(
-        id,
-        name,
-      )
-    } else if (type === "cell") {
-      const name = meshCellsCellAttributeStyle.meshCellsCellAttributeName(id)
+      return meshCellsVertexAttributeStyle.setMeshCellsVertexAttributeName(id, name);
+    }
+    if (type === "cell") {
+      const name = meshCellsCellAttributeStyle.meshCellsCellAttributeName(id);
       if (name === undefined) {
-        return Promise.resolve()
+        return;
       }
-      await meshCellsCellAttributeStyle.setMeshCellsCellAttributeName(id, name)
-    } else {
-      throw new Error(`Unknown mesh cells coloring type: ${type}`)
+      await meshCellsCellAttributeStyle.setMeshCellsCellAttributeName(id, name);
+      return;
     }
+    throw new Error(`Unknown mesh cells coloring type: ${type}`);
   }
 
   function applyMeshCellsStyle(id) {
     return Promise.all([
-      meshCellsVisibility.setMeshCellsVisibility(
-        id,
-        meshCellsVisibility.meshCellsVisibility(id),
-      ),
-      setMeshCellsActiveColoring(
-        id,
-        meshCellsCommonStyle.meshCellsActiveColoring(id),
-      ),
-    ])
+      meshCellsVisibility.setMeshCellsVisibility(id, meshCellsVisibility.meshCellsVisibility(id)),
+      setMeshCellsActiveColoring(id, meshCellsCommonStyle.meshCellsActiveColoring(id)),
+    ]);
   }
 
   return {
@@ -80,5 +70,5 @@ export function useMeshCellsStyle() {
     ...meshCellsTexturesStore,
     ...meshCellsVertexAttributeStyle,
     ...meshCellsCellAttributeStyle,
-  }
+  };
 }

package/internal/stores/data_style/mesh/cells/textures.js

@@ -1,20 +1,19 @@
 // Third party imports
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 // Local imports
-import { useMeshCellsCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshCellsCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const meshCellsTexturesSchemas =
-  viewer_schemas.opengeodeweb_viewer.mesh.cells.apply_textures
+const meshCellsTexturesSchemas = viewer_schemas.opengeodeweb_viewer.mesh.cells.apply_textures;
 
 export function useMeshCellsTexturesStyle() {
-  const viewerStore = useViewerStore()
-  const meshCellsCommonStyle = useMeshCellsCommonStyle()
+  const viewerStore = useViewerStore();
+  const meshCellsCommonStyle = useMeshCellsCommonStyle();
 
   function meshCellsTextures(id) {
-    return meshCellsCommonStyle.meshCellsColoring(id).textures
+    return meshCellsCommonStyle.meshCellsColoring(id).textures;
   }
   function setMeshCellsTextures(id, textures) {
     return viewerStore.request(
@@ -22,15 +21,15 @@ export function useMeshCellsTexturesStyle() {
       { id, textures },
       {
         response_function: () => {
-          meshCellsCommonStyle.meshCellsColoring(id).textures = textures
-          console.log(setMeshCellsTextures.name, { id }, meshCellsTextures(id))
+          meshCellsCommonStyle.meshCellsColoring(id).textures = textures;
+          console.log(setMeshCellsTextures.name, { id }, meshCellsTextures(id));
         },
       },
-    )
+    );
   }
 
   return {
     meshCellsTextures,
     setMeshCellsTextures,
-  }
+  };
 }