@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

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

@@ -0,0 +1,39 @@
+import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
+import { useModelCornersCommonStyle } from "./common";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+const schema = viewer_schemas.opengeodeweb_viewer.model.corners.visibility;
+
+interface ModelCornersVisibilityApi {
+  setModelCornersVisibility: (
+    modelId: string,
+    corners_ids: string[],
+    visibility: boolean | undefined,
+  ) => Promise<unknown>;
+  modelCornerVisibility: (id: string, corner_id?: string) => unknown;
+}
+
+export function useModelCornersVisibility(): ModelCornersVisibilityApi {
+  const modelCommonStyle = useModelCommonStyle();
+  const modelCornersCommonStyle = useModelCornersCommonStyle();
+
+  function modelCornerVisibility(id: string, corner_id?: string): unknown {
+    return modelCornersCommonStyle.modelCornerStyle(id, corner_id).visibility;
+  }
+
+  async function setModelCornersVisibility(
+    modelId: string,
+    corners_ids: string[],
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeVisibility(
+      modelId,
+      corners_ids,
+      visibility,
+      schema,
+    );
+    return result;
+  }
+
+  return { setModelCornersVisibility, modelCornerVisibility };
+}

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

@@ -0,0 +1,29 @@
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
+
+export function useModelEdgesCommonStyle(): {
+  modelEdgesStyle: (id: string) => StyleValues;
+  mutateModelEdgesStyle: (id: string, values: StyleValues) => Promise<string>;
+} {
+  const dataStyleState = useDataStyleState();
+
+  async function mutateModelEdgesStyle(id: string, values: StyleValues): Promise<string> {
+    const result = await dataStyleState.mutateStyle(id, {
+      edges: values,
+    });
+    return result;
+  }
+
+  function modelEdgesStyle(id: string): StyleValues {
+    const { edges } = dataStyleState.getStyle(id);
+    if (edges === undefined) {
+      return {};
+    }
+    return edges;
+  }
+
+  return {
+    modelEdgesStyle,
+    mutateModelEdgesStyle,
+  };
+}

package/internal/stores/data_style/model/edges/{index.js → index.ts}

@@ -1,17 +1,12 @@
 import { useModelEdgesCommonStyle } from "./common";
 import { useModelEdgesVisibilityStyle } from "./visibility";
 
-export function useModelEdgesStyle() {
+export function useModelEdgesStyle(): ReturnType<typeof useModelEdgesCommonStyle> &
+  ReturnType<typeof useModelEdgesVisibilityStyle> {
   const modelEdgesCommonStyle = useModelEdgesCommonStyle();
   const modelEdgesVisibilityStyle = useModelEdgesVisibilityStyle();
 
-  function applyModelEdgesStyle(id) {
-    const { visibility } = modelEdgesCommonStyle.modelEdgesStyle(id);
-    return modelEdgesVisibilityStyle.setModelEdgesVisibility(id, visibility);
-  }
-
   return {
-    applyModelEdgesStyle,
     ...modelEdgesCommonStyle,
     ...modelEdgesVisibilityStyle,
   };

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

@@ -0,0 +1,55 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+import { useModelEdgesCommonStyle } from "./common";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+
+// Local constants
+const schema = viewer_schemas.opengeodeweb_viewer.model.edges.visibility;
+
+interface ModelEdgesVisibilityStyleApi {
+  modelEdgesVisibility: (id: string) => boolean | undefined;
+  setModelEdgesVisibility: (id: string, visibility: boolean | undefined) => Promise<unknown>;
+  applyModelEdgesStyle: (id: string) => Promise<unknown[]>;
+}
+
+export function useModelEdgesVisibilityStyle(): ModelEdgesVisibilityStyleApi {
+  const viewerStore = useViewerStore();
+  const modelEdgesCommonStyle = useModelEdgesCommonStyle();
+
+  function modelEdgesVisibility(id: string): boolean | undefined {
+    const { visibility } = modelEdgesCommonStyle.modelEdgesStyle(id);
+    if (typeof visibility === "boolean") {
+      return visibility;
+    }
+    return undefined;
+  }
+
+  async function setModelEdgesVisibility(
+    id: string,
+    visibility: boolean | undefined,
+  ): Promise<unknown> {
+    const params = { id, visibility };
+    const result = await viewerStore.request(
+      { schema, params },
+      {
+        response_function: async () => {
+          await modelEdgesCommonStyle.mutateModelEdgesStyle(id, { visibility });
+        },
+      },
+    );
+    return result;
+  }
+
+  async function applyModelEdgesStyle(id: string): Promise<unknown[]> {
+    const visibility = modelEdgesVisibility(id);
+    const result = await setModelEdgesVisibility(id, visibility);
+    return [result];
+  }
+
+  return {
+    modelEdgesVisibility,
+    setModelEdgesVisibility,
+    applyModelEdgesStyle,
+  };
+}

package/internal/stores/data_style/model/{index.js → index.ts}

@@ -1,3 +1,4 @@
+import type { ComputedRef } from "vue";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
 import { useModelBlocksStyle } from "./blocks";
@@ -10,8 +11,21 @@ import { useModelSelection } from "./selection";
 import { useModelSurfacesStyle } from "./surfaces";
 import { useModelVisibilityStyle } from "./visibility";
 
+type UseModelStyleReturn = ReturnType<typeof useModelColorStyle> &
+  ReturnType<typeof useModelVisibilityStyle> &
+  ReturnType<typeof useModelBlocksStyle> &
+  ReturnType<typeof useModelCornersStyle> &
+  ReturnType<typeof useModelEdgesStyle> &
+  ReturnType<typeof useModelLinesStyle> &
+  ReturnType<typeof useModelPointsStyle> &
+  ReturnType<typeof useModelSurfacesStyle> & {
+    visibleMeshComponents: (modelId: string) => ComputedRef<string[]>;
+    applyModelStyle: (modelId: string) => Promise<unknown[]>;
+    setModelMeshComponentsDefaultStyle: (modelId: string) => Promise<unknown[]>;
+  };
+
 // oxlint-disable-next-line max-lines-per-function, max-statements
-function useModelStyle() {
+function useModelStyle(): UseModelStyleReturn {
   const dataStore = useDataStore();
   const dataStyleState = useDataStyleState();
   const modelCornersStyle = useModelCornersStyle();
@@ -31,15 +45,15 @@ function useModelStyle() {
   const modelColorStyle = useModelColorStyle(componentStyleFunctions);
   const modelVisibilityStyle = useModelVisibilityStyle(componentStyleFunctions);
 
-  function visibleMeshComponents(modelId) {
+  function visibleMeshComponents(modelId: string): ComputedRef<string[]> {
     return useModelSelection(modelId, dataStyleState);
   }
 
-  function applyModelStyle(modelId) {
+  async function applyModelStyle(modelId: string): Promise<unknown[]> {
     const style = dataStyleState.getStyle(modelId);
 
-    return Promise.all([
-      modelVisibilityStyle.setModelVisibility(modelId, style.visibility),
+    const results = await Promise.all([
+      modelVisibilityStyle.setModelVisibility(modelId, style.visibility ?? false),
       modelBlocksStyle.applyModelBlocksStyle(modelId),
       modelSurfacesStyle.applyModelSurfacesStyle(modelId),
       modelLinesStyle.applyModelLinesStyle(modelId),
@@ -47,19 +61,18 @@ function useModelStyle() {
       modelPointsStyle.applyModelPointsStyle(modelId),
       modelEdgesStyle.applyModelEdgesStyle(modelId),
     ]);
+    return results;
   }
 
-  async function setModelMeshComponentsDefaultStyle(modelId) {
-    const item = await dataStore.item(modelId);
-    if (!item) {
-      return;
-    }
-    return await Promise.all([
+  async function setModelMeshComponentsDefaultStyle(modelId: string): Promise<unknown[]> {
+    await dataStore.item(modelId);
+    const results = await Promise.all([
       modelBlocksStyle.setModelBlocksDefaultStyle(modelId),
       modelSurfacesStyle.setModelSurfacesDefaultStyle(modelId),
       modelLinesStyle.setModelLinesDefaultStyle(modelId),
       modelCornersStyle.setModelCornersDefaultStyle(modelId),
     ]);
+    return results;
   }
 
   return {

package/internal/stores/data_style/model/lines/{color.js → color.ts}

@@ -1,36 +1,72 @@
 import { isModelLinesEdgeAttributeValid, useModelLinesEdgeAttribute } from "./edge";
 import { isModelLinesVertexAttributeValid, useModelLinesVertexAttribute } from "./vertex";
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import { useDataStore } from "@ogw_front/stores/data";
 import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
 import { useModelLinesCommonStyle } from "./common";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
 const schema = viewer_schemas.opengeodeweb_viewer.model.lines.color;
 
-export function useModelLinesColor() {
+export function useModelLinesColor(): {
+  setModelLinesColor: (
+    modelId: string,
+    lines_ids: string[],
+    color: unknown,
+    activeColoring?: string,
+  ) => Promise<unknown>;
+  modelLineColoring: (id: string, line_id?: string) => StyleValues;
+  modelLineColor: (id: string, line_id?: string) => unknown;
+  modelLineActiveColoring: (id: string, line_id?: string) => unknown;
+  setModelLinesActiveColoring: (
+    modelId: string,
+    lines_ids: string[],
+    activeColoring: string,
+  ) => Promise<unknown>;
+} {
+  const dataStore = useDataStore();
   const modelCommonStyle = useModelCommonStyle();
   const modelLinesCommonStyle = useModelLinesCommonStyle();
   const modelLinesVertexAttribute = useModelLinesVertexAttribute();
   const modelLinesEdgeAttribute = useModelLinesEdgeAttribute();
 
-  function modelLineColoring(id, line_id) {
-    return modelLinesCommonStyle.modelLineStyle(id, line_id).coloring;
+  function modelLineColoring(id: string, line_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
+    return modelLinesCommonStyle.modelLineStyle(id, line_id).coloring as StyleValues;
   }
 
-  function modelLineColor(id, line_id) {
+  function modelLineColor(id: string, line_id?: string): unknown {
     return modelLineColoring(id, line_id).constant;
   }
 
-  function setModelLinesColor(modelId, lines_ids, color, activeColoring = "constant") {
-    return modelCommonStyle.setModelTypeColor(modelId, lines_ids, color, schema, activeColoring);
+  async function setModelLinesColor(
+    modelId: string,
+    lines_ids: string[],
+    color: unknown,
+    activeColoring = "constant",
+  ): Promise<unknown> {
+    const result = await modelCommonStyle.setModelTypeColor(
+      modelId,
+      lines_ids,
+      color,
+      schema,
+      activeColoring,
+    );
+    return result;
   }
 
-  function modelLineActiveColoring(id, line_id) {
+  function modelLineActiveColoring(id: string, line_id?: string): unknown {
     return modelLineColoring(id, line_id).active;
   }
 
-  async function setModelLinesActiveColoring(modelId, lines_ids, activeColoring) {
-    if (lines_ids.length > 1) {
-      modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
+  async function setModelLinesActiveColoring(
+    modelId: string,
+    lines_ids: string[],
+    activeColoring: string,
+  ): Promise<unknown> {
+    const totalLineIds = await dataStore.getLinesGeodeIds(modelId);
+    if (lines_ids.length === totalLineIds.length) {
+      await modelLinesCommonStyle.mutateModelLinesTypeColoring(modelId, {
         active: activeColoring,
       });
     }
@@ -77,6 +113,7 @@ export function useModelLinesColor() {
         return modelLinesEdgeAttribute.setModelLinesEdgeAttribute(modelId, lines_ids, attribute);
       }
     }
+    return undefined;
   }
 
   return {

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

@@ -0,0 +1,63 @@
+import type { StyleValues } from "@ogw_internal/stores/data_style/types.js";
+import merge from "lodash/merge";
+import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
+import { useModelCommonStyle } from "@ogw_internal/stores/data_style/model/common";
+
+export function useModelLinesCommonStyle(): {
+  modelLinesStyle: (id: string) => StyleValues;
+  modelLineStyle: (id: string, line_id?: string) => StyleValues;
+  modelLineColoring: (id: string, line_id?: string) => StyleValues;
+  mutateModelLinesColoring: (id: string, lines_ids: string[], values: StyleValues) => Promise<void>;
+  mutateModelLinesTypeColoring: (id: string, values: StyleValues) => Promise<void>;
+} {
+  const dataStyleState = useDataStyleState();
+  const modelCommonStyle = useModelCommonStyle();
+
+  function modelLinesStyle(id: string): StyleValues {
+    return dataStyleState.getStyle(id).lines ?? {};
+  }
+
+  function modelComponentTypeLinesStyle(id: string): StyleValues {
+    const defaultStyle = modelLinesStyle(id);
+    const typeStyle = dataStyleState.getModelComponentTypeStyle(id, "Line");
+    return merge({}, defaultStyle, typeStyle);
+  }
+
+  function modelLineStyle(id: string, line_id?: string): StyleValues {
+    if (line_id === undefined) {
+      return modelComponentTypeLinesStyle(id);
+    }
+    const typeStyle = modelComponentTypeLinesStyle(id);
+    const individualStyle = dataStyleState.getComponentStyle(id, line_id);
+    return merge({}, typeStyle, individualStyle);
+  }
+
+  function modelLineColoring(id: string, line_id?: string): StyleValues {
+    // oxlint-disable-next-line no-unsafe-type-assertion -- coloring shape is defined by the data style schema.
+    return modelLineStyle(id, line_id).coloring as StyleValues;
+  }
+
+  async function mutateModelLinesColoring(
+    id: string,
+    lines_ids: string[],
+    values: StyleValues,
+  ): Promise<void> {
+    await modelCommonStyle.mutateComponentStyles(id, lines_ids, {
+      coloring: values,
+    });
+  }
+
+  async function mutateModelLinesTypeColoring(id: string, values: StyleValues): Promise<void> {
+    await modelCommonStyle.mutateModelComponentTypeStyle(id, "Line", {
+      coloring: values,
+    });
+  }
+
+  return {
+    modelLinesStyle,
+    modelLineStyle,
+    modelLineColoring,
+    mutateModelLinesColoring,
+    mutateModelLinesTypeColoring,
+  };
+}