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

package/internal/stores/data_style/model/corners/visibility.js

@@ -1,39 +1,35 @@
 // 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 { useDataStore } from "@ogw_front/stores/data"
-import { useModelCornersCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelCornersCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
+const model_corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners;
 
 export function useModelCornersVisibilityStyle() {
-  const dataStore = useDataStore()
-  const viewerStore = useViewerStore()
-  const modelCornersCommonStyle = useModelCornersCommonStyle()
+  const dataStore = useDataStore();
+  const viewerStore = useViewerStore();
+  const modelCornersCommonStyle = useModelCornersCommonStyle();
   function modelCornerVisibility(id, corner_id) {
-    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility
+    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility;
   }
   function saveModelCornerVisibility(id, corner_id, visibility) {
-    modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility =
-      visibility
+    modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility = visibility;
   }
   async function setModelCornersVisibility(id, corner_ids, visibility) {
     if (!corner_ids || corner_ids.length === 0) {
-      return
+      return;
     }
-    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-      id,
-      corner_ids,
-    )
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, corner_ids);
     if (!corner_viewer_ids || corner_viewer_ids.length === 0) {
-      console.warn(
-        "[setModelCornersVisibility] No viewer IDs found, skipping visibility request",
-        { id, corner_ids },
-      )
-      return
+      console.warn("[setModelCornersVisibility] No viewer IDs found, skipping visibility request", {
+        id,
+        corner_ids,
+      });
+      return;
     }
     return viewerStore.request(
       model_corners_schemas.visibility,
@@ -41,21 +37,21 @@ export function useModelCornersVisibilityStyle() {
       {
         response_function: () => {
           for (const corner_id of corner_ids) {
-            saveModelCornerVisibility(id, corner_id, visibility)
+            saveModelCornerVisibility(id, corner_id, visibility);
           }
           console.log(
             setModelCornersVisibility.name,
             { id },
             { corner_ids },
             modelCornerVisibility(id, corner_ids[0]),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
     modelCornerVisibility,
     setModelCornersVisibility,
-  }
+  };
 }

package/internal/stores/data_style/model/edges/common.js

@@ -1,13 +1,13 @@
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
 
 export function useModelEdgesCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function modelEdgesStyle(id) {
-    return dataStyleStateStore.styles[id].edges
+    return dataStyleStateStore.styles[id].edges;
   }
 
   return {
     modelEdgesStyle,
-  }
+  };
 }

package/internal/stores/data_style/model/edges/index.js

@@ -1,21 +1,21 @@
 // Local imports
-import { useModelEdgesCommonStyle } from "./common"
-import { useModelEdgesVisibilityStyle } from "./visibility"
+import { useModelEdgesCommonStyle } from "./common";
+import { useModelEdgesVisibilityStyle } from "./visibility";
 
 export function useModelEdgesStyle() {
-  const modelEdgesCommonStyle = useModelEdgesCommonStyle()
-  const modelEdgesVisibilityStyle = useModelEdgesVisibilityStyle()
+  const modelEdgesCommonStyle = useModelEdgesCommonStyle();
+  const modelEdgesVisibilityStyle = useModelEdgesVisibilityStyle();
 
   function applyModelEdgesStyle(id) {
-    const style = modelEdgesCommonStyle.modelEdgesStyle(id)
+    const style = modelEdgesCommonStyle.modelEdgesStyle(id);
     return Promise.resolve([
       modelEdgesVisibilityStyle.setModelEdgesVisibility(id, style.visibility),
-    ])
+    ]);
   }
 
   return {
     applyModelEdgesStyle,
     ...modelEdgesCommonStyle,
     ...modelEdgesVisibilityStyle,
-  }
+  };
 }

package/internal/stores/data_style/model/edges/visibility.js

@@ -1,19 +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 { useModelEdgesCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useModelEdgesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges
+const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges;
 
 export function useModelEdgesVisibilityStyle() {
-  const viewerStore = useViewerStore()
-  const modelEdgesCommonStyle = useModelEdgesCommonStyle()
+  const viewerStore = useViewerStore();
+  const modelEdgesCommonStyle = useModelEdgesCommonStyle();
 
   function modelEdgesVisibility(id) {
-    return modelEdgesCommonStyle.modelEdgesStyle(id).visibility
+    return modelEdgesCommonStyle.modelEdgesStyle(id).visibility;
   }
 
   function setModelEdgesVisibility(id, visibility) {
@@ -22,19 +22,15 @@ export function useModelEdgesVisibilityStyle() {
       { id, visibility },
       {
         response_function: () => {
-          modelEdgesCommonStyle.modelEdgesStyle(id).visibility = visibility
-          console.log(
-            setModelEdgesVisibility.name,
-            { id },
-            modelEdgesVisibility(id),
-          )
+          modelEdgesCommonStyle.modelEdgesStyle(id).visibility = visibility;
+          console.log(setModelEdgesVisibility.name, { id }, modelEdgesVisibility(id));
         },
       },
-    )
+    );
   }
 
   return {
     modelEdgesVisibility,
     setModelEdgesVisibility,
-  }
+  };
 }

package/internal/stores/data_style/model/index.js

@@ -1,35 +1,35 @@
 // 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 { useDataStore } from "@ogw_front/stores/data"
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer"
-import { useModelBlocksStyle } from "./blocks"
-import { useModelCornersStyle } from "./corners"
-import { useModelEdgesStyle } from "./edges"
-import { useModelLinesStyle } from "./lines"
-import { useModelPointsStyle } from "./points"
-import { useModelSurfacesStyle } from "./surfaces"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useDataStore } from "@ogw_front/stores/data";
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
+import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
+import { useModelBlocksStyle } from "./blocks";
+import { useModelCornersStyle } from "./corners";
+import { useModelEdgesStyle } from "./edges";
+import { useModelLinesStyle } from "./lines";
+import { useModelPointsStyle } from "./points";
+import { useModelSurfacesStyle } from "./surfaces";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_schemas = viewer_schemas.opengeodeweb_viewer.model
+const model_schemas = viewer_schemas.opengeodeweb_viewer.model;
 
 export function useModelStyle() {
-  const dataStore = useDataStore()
-  const dataStyleStateStore = useDataStyleStateStore()
-  const modelCornersStyleStore = useModelCornersStyle()
-  const modelBlocksStyleStore = useModelBlocksStyle()
-  const modelEdgesStyleStore = useModelEdgesStyle()
-  const modelLinesStyleStore = useModelLinesStyle()
-  const modelPointsStyleStore = useModelPointsStyle()
-  const modelSurfacesStyleStore = useModelSurfacesStyle()
-  const hybridViewerStore = useHybridViewerStore()
-  const viewerStore = useViewerStore()
+  const dataStore = useDataStore();
+  const dataStyleStateStore = useDataStyleStateStore();
+  const modelCornersStyleStore = useModelCornersStyle();
+  const modelBlocksStyleStore = useModelBlocksStyle();
+  const modelEdgesStyleStore = useModelEdgesStyle();
+  const modelLinesStyleStore = useModelLinesStyle();
+  const modelPointsStyleStore = useModelPointsStyle();
+  const modelSurfacesStyleStore = useModelSurfacesStyle();
+  const hybridViewerStore = useHybridViewerStore();
+  const viewerStore = useViewerStore();
 
   function modelVisibility(id) {
-    return dataStyleStateStore.getStyle(id).visibility
+    return dataStyleStateStore.getStyle(id).visibility;
   }
   function setModelVisibility(id, visibility) {
     return viewerStore.request(
@@ -37,63 +37,66 @@ export function useModelStyle() {
       { id, visibility },
       {
         response_function: () => {
-          dataStyleStateStore.getStyle(id).visibility = visibility
-          hybridViewerStore.setVisibility(id, visibility)
-          console.log(setModelVisibility.name, { id }, modelVisibility(id))
+          dataStyleStateStore.getStyle(id).visibility = visibility;
+          hybridViewerStore.setVisibility(id, visibility);
+          console.log(setModelVisibility.name, { id }, modelVisibility(id));
         },
       },
-    )
+    );
   }
 
   function visibleMeshComponents(id) {
-    const visible_mesh_components = ref([])
-    const styles = dataStyleStateStore.styles[id]
+    const visible_mesh_components = ref([]);
+    const styles = dataStyleStateStore.styles[id];
     if (!styles) {
-      return visible_mesh_components
+      return visible_mesh_components;
     }
 
     for (const [corner_id, style] of Object.entries(styles.corners || {})) {
       if (style.visibility) {
-        visible_mesh_components.value.push(corner_id)
+        visible_mesh_components.value.push(corner_id);
       }
     }
 
     for (const [line_id, style] of Object.entries(styles.lines || {})) {
       if (style.visibility) {
-        visible_mesh_components.value.push(line_id)
+        visible_mesh_components.value.push(line_id);
       }
     }
 
     for (const [surface_id, style] of Object.entries(styles.surfaces || {})) {
       if (style.visibility) {
-        visible_mesh_components.value.push(surface_id)
+        visible_mesh_components.value.push(surface_id);
       }
     }
 
     for (const [block_id, style] of Object.entries(styles.blocks || {})) {
       if (style.visibility) {
-        visible_mesh_components.value.push(block_id)
+        visible_mesh_components.value.push(block_id);
       }
     }
 
-    return visible_mesh_components
+    return visible_mesh_components;
   }
 
   function modelMeshComponentVisibility(id, component_type, component_id) {
     if (component_type === "Corner") {
-      return modelCornersStyleStore.modelCornerVisibility(id, component_id)
-    } else if (component_type === "Line") {
-      return modelLinesStyleStore.modelLineVisibility(id, component_id)
-    } else if (component_type === "Surface") {
-      return modelSurfacesStyleStore.modelSurfaceVisibility(id, component_id)
-    } else if (component_type === "Block") {
-      return modelBlocksStyleStore.modelBlockVisibility(id, component_id)
-    }
-    throw new Error(`Unknown model component_type: ${component_type}`)
+      return modelCornersStyleStore.modelCornerVisibility(id, component_id);
+    }
+    if (component_type === "Line") {
+      return modelLinesStyleStore.modelLineVisibility(id, component_id);
+    }
+    if (component_type === "Surface") {
+      return modelSurfacesStyleStore.modelSurfaceVisibility(id, component_id);
+    }
+    if (component_type === "Block") {
+      return modelBlocksStyleStore.modelBlockVisibility(id, component_id);
+    }
+    throw new Error(`Unknown model component_type: ${component_type}`);
   }
 
   function modelColor(id) {
-    return dataStyleStateStore.getStyle(id).color
+    return dataStyleStateStore.getStyle(id).color;
   }
   function setModelColor(id, color) {
     return viewerStore.request(
@@ -101,95 +104,76 @@ export function useModelStyle() {
       { id, color },
       {
         response_function: () => {
-          dataStyleStateStore.styles[id].color = color
-          console.log(setModelColor.name, { id }, modelColor(id))
+          dataStyleStateStore.styles[id].color = color;
+          console.log(setModelColor.name, { id }, modelColor(id));
         },
       },
-    )
+    );
   }
 
-  async function setModelMeshComponentsVisibility(
-    id,
-    component_geode_ids,
-    visibility,
-  ) {
-    const component_type = await dataStore.meshComponentType(
-      id,
-      component_geode_ids[0],
-    )
+  async function setModelMeshComponentsVisibility(id, component_geode_ids, visibility) {
+    const component_type = await dataStore.meshComponentType(id, component_geode_ids[0]);
     if (component_type === "Corner") {
-      return modelCornersStyleStore.setModelCornersVisibility(
-        id,
-        component_geode_ids,
-        visibility,
-      )
-    } else if (component_type === "Line") {
-      return modelLinesStyleStore.setModelLinesVisibility(
-        id,
-        component_geode_ids,
-        visibility,
-      )
-    } else if (component_type === "Surface") {
+      return modelCornersStyleStore.setModelCornersVisibility(id, component_geode_ids, visibility);
+    }
+    if (component_type === "Line") {
+      return modelLinesStyleStore.setModelLinesVisibility(id, component_geode_ids, visibility);
+    }
+    if (component_type === "Surface") {
       return modelSurfacesStyleStore.setModelSurfacesVisibility(
         id,
         component_geode_ids,
         visibility,
-      )
-    } else if (component_type === "Block") {
-      return modelBlocksStyleStore.setModelBlocksVisibility(
-        id,
-        component_geode_ids,
-        visibility,
-      )
-    } else {
-      throw new Error(`Unknown model component_type: ${component_type}`)
+      );
     }
+    if (component_type === "Block") {
+      return modelBlocksStyleStore.setModelBlocksVisibility(id, component_geode_ids, visibility);
+    }
+    throw new Error(`Unknown model component_type: ${component_type}`);
   }
 
   function applyModelStyle(id) {
-    const style = dataStyleStateStore.getStyle(id)
-    const promise_array = []
+    const style = dataStyleStateStore.getStyle(id);
+    const promise_array = [];
     for (const [key, value] of Object.entries(style)) {
       if (key === "visibility") {
-        promise_array.push(setModelVisibility(id, value))
+        promise_array.push(setModelVisibility(id, value));
       } else if (key === "corners") {
-        promise_array.push(modelCornersStyleStore.applyModelCornersStyle(id))
+        promise_array.push(modelCornersStyleStore.applyModelCornersStyle(id));
       } else if (key === "lines") {
-        promise_array.push(modelLinesStyleStore.applyModelLinesStyle(id))
+        promise_array.push(modelLinesStyleStore.applyModelLinesStyle(id));
       } else if (key === "surfaces") {
-        promise_array.push(modelSurfacesStyleStore.applyModelSurfacesStyle(id))
+        promise_array.push(modelSurfacesStyleStore.applyModelSurfacesStyle(id));
       } else if (key === "blocks") {
-        promise_array.push(modelBlocksStyleStore.applyModelBlocksStyle(id))
+        promise_array.push(modelBlocksStyleStore.applyModelBlocksStyle(id));
       } else if (key === "points") {
-        promise_array.push(modelPointsStyleStore.applyModelPointsStyle(id))
+        promise_array.push(modelPointsStyleStore.applyModelPointsStyle(id));
       } else if (key === "edges") {
-        promise_array.push(modelEdgesStyleStore.applyModelEdgesStyle(id))
+        promise_array.push(modelEdgesStyleStore.applyModelEdgesStyle(id));
       } else {
-        throw new Error(`Unknown model key: ${key}`)
+        throw new Error(`Unknown model key: ${key}`);
       }
     }
-    return Promise.all(promise_array)
+    return Promise.all(promise_array);
   }
 
   async function setModelMeshComponentsDefaultStyle(id) {
-    const item = await dataStore.item(id)
-    const { mesh_components } = item
-    const promise_array = []
+    const item = await dataStore.item(id);
+    const { mesh_components } = item;
+    const promise_array = [];
     if ("Corner" in mesh_components) {
-      promise_array.push(modelCornersStyleStore.setModelCornersDefaultStyle(id))
+      promise_array.push(modelCornersStyleStore.setModelCornersDefaultStyle(id));
     }
     if ("Line" in mesh_components) {
-      promise_array.push(modelLinesStyleStore.setModelLinesDefaultStyle(id))
+      promise_array.push(modelLinesStyleStore.setModelLinesDefaultStyle(id));
     }
     if ("Surface" in mesh_components) {
-      promise_array.push(
-        modelSurfacesStyleStore.setModelSurfacesDefaultStyle(id),
-      )
+      promise_array.push(modelSurfacesStyleStore.setModelSurfacesDefaultStyle(id));
     }
     if ("Block" in mesh_components) {
-      promise_array.push(modelBlocksStyleStore.setModelBlocksDefaultStyle(id))
+      promise_array.push(modelBlocksStyleStore.setModelBlocksDefaultStyle(id));
     }
-    return promise_array
+    return promise_array;
   }
 
   return {
@@ -207,5 +191,5 @@ export function useModelStyle() {
     ...useModelLinesStyle(),
     ...useModelPointsStyle(),
     ...useModelSurfacesStyle(),
-  }
+  };
 }

package/internal/stores/data_style/model/lines/color.js

@@ -1,38 +1,35 @@
 // 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 { useDataStore } from "@ogw_front/stores/data"
-import { useModelLinesCommonStyle } from "./common"
-import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelLinesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
 
 // Local constants
-const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
+const model_lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines;
 
 export function useModelLinesColorStyle() {
-  const dataStore = useDataStore()
-  const viewerStore = useViewerStore()
-  const modelLinesCommonStyle = useModelLinesCommonStyle()
+  const dataStore = useDataStore();
+  const viewerStore = useViewerStore();
+  const modelLinesCommonStyle = useModelLinesCommonStyle();
   function modelLineColor(id, line_id) {
-    return modelLinesCommonStyle.modelLineStyle(id, line_id).color
+    return modelLinesCommonStyle.modelLineStyle(id, line_id).color;
   }
   function saveModelLineColor(id, line_id, color) {
-    modelLinesCommonStyle.modelLineStyle(id, line_id).color = color
+    modelLinesCommonStyle.modelLineStyle(id, line_id).color = color;
   }
   async function setModelLinesColor(id, line_ids, color) {
     if (!line_ids || line_ids.length === 0) {
-      return
+      return;
     }
-    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(
-      id,
-      line_ids,
-    )
+    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(id, line_ids);
     if (!line_viewer_ids || line_viewer_ids.length === 0) {
-      console.warn(
-        "[setModelLinesColor] No viewer IDs found, skipping color request",
-        { id, line_ids },
-      )
-      return
+      console.warn("[setModelLinesColor] No viewer IDs found, skipping color request", {
+        id,
+        line_ids,
+      });
+      return;
     }
     return viewerStore.request(
       model_lines_schemas.color,
@@ -40,21 +37,21 @@ export function useModelLinesColorStyle() {
       {
         response_function: () => {
           for (const line_id of line_ids) {
-            saveModelLineColor(id, line_id, color)
+            saveModelLineColor(id, line_id, color);
           }
           console.log(
             setModelLinesColor.name,
             { id },
             { line_ids },
             JSON.stringify(modelLineColor(id, line_ids[0])),
-          )
+          );
         },
       },
-    )
+    );
   }
 
   return {
     modelLineColor,
     setModelLinesColor,
-  }
+  };
 }

package/internal/stores/data_style/model/lines/common.js

@@ -1,21 +1,21 @@
-import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state"
+import { useDataStyleStateStore } from "@ogw_internal/stores/data_style/state";
 
 export function useModelLinesCommonStyle() {
-  const dataStyleStateStore = useDataStyleStateStore()
+  const dataStyleStateStore = useDataStyleStateStore();
 
   function modelLinesStyle(id) {
-    return dataStyleStateStore.getStyle(id).lines
+    return dataStyleStateStore.getStyle(id).lines;
   }
 
   function modelLineStyle(id, line_id) {
     if (!modelLinesStyle(id)[line_id]) {
-      modelLinesStyle(id)[line_id] = {}
+      modelLinesStyle(id)[line_id] = {};
     }
-    return modelLinesStyle(id)[line_id]
+    return modelLinesStyle(id)[line_id];
   }
 
   return {
     modelLinesStyle,
     modelLineStyle,
-  }
+  };
 }

package/internal/stores/data_style/model/lines/index.js

@@ -1,30 +1,26 @@
 // Local imports
-import { useDataStore } from "@ogw_front/stores/data"
-import { useModelLinesColorStyle } from "./color"
-import { useModelLinesCommonStyle } from "./common"
-import { useModelLinesVisibilityStyle } from "./visibility"
+import { useDataStore } from "@ogw_front/stores/data";
+import { useModelLinesColorStyle } from "./color";
+import { useModelLinesCommonStyle } from "./common";
+import { useModelLinesVisibilityStyle } from "./visibility";
 
 async function setModelLinesDefaultStyle(_id) {
   // Placeholder for oxlint
 }
 
 export function useModelLinesStyle() {
-  const dataStore = useDataStore()
-  const modelLinesCommonStyle = useModelLinesCommonStyle()
-  const modelLinesVisibilityStyle = useModelLinesVisibilityStyle()
-  const modelLinesColorStyle = useModelLinesColorStyle()
+  const dataStore = useDataStore();
+  const modelLinesCommonStyle = useModelLinesCommonStyle();
+  const modelLinesVisibilityStyle = useModelLinesVisibilityStyle();
+  const modelLinesColorStyle = useModelLinesColorStyle();
 
   async function applyModelLinesStyle(id) {
-    const style = modelLinesCommonStyle.modelLinesStyle(id)
-    const line_ids = await dataStore.getLinesGeodeIds(id)
+    const style = modelLinesCommonStyle.modelLinesStyle(id);
+    const line_ids = await dataStore.getLinesGeodeIds(id);
     return Promise.all([
-      modelLinesVisibilityStyle.setModelLinesVisibility(
-        id,
-        line_ids,
-        style.visibility,
-      ),
+      modelLinesVisibilityStyle.setModelLinesVisibility(id, line_ids, style.visibility),
       modelLinesColorStyle.setModelLinesColor(id, line_ids, style.color),
-    ])
+    ]);
   }
 
   return {
@@ -33,5 +29,5 @@ export function useModelLinesStyle() {
     ...modelLinesCommonStyle,
     ...modelLinesVisibilityStyle,
     ...modelLinesColorStyle,
-  }
+  };
 }