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

package/app/stores/treeview.js

@@ -1,290 +0,0 @@
-import { defineStore } from "pinia";
-
-import { ref, watch } from "vue";
-import { compareSelections } from "@ogw_front/utils/treeview";
-import { database } from "@ogw_internal/database/database";
-
-const PANEL_WIDTH = 300;
-
-export const useTreeviewStore = defineStore("treeview", () => {
-  const items = ref([]);
-  const selection = ref([]);
-  const activeItems = ref([]);
-  const opened_views = ref([
-    { type: "object", id: "main", title: "Objects", scrollTop: 0, opened: [] },
-  ]);
-  const panelWidth = ref(PANEL_WIDTH);
-  const additionalPanelWidth = ref(PANEL_WIDTH);
-  const isImporting = ref(false);
-  const pendingSelectionIds = ref([]);
-  const rowHeights = ref([]);
-
-  async function loadConfig() {
-    try {
-      const config = await database.treeview_config.get("main");
-      if (config?.opened_views) {
-        opened_views.value = config.opened_views;
-      }
-      if (config?.panelWidth) {
-        panelWidth.value = config.panelWidth;
-      }
-      if (config?.additionalPanelWidth) {
-        additionalPanelWidth.value = config.additionalPanelWidth;
-      }
-      if (config?.selectionIds) {
-        selection.value = config.selectionIds;
-      }
-      if (config?.rowHeights) {
-        rowHeights.value = config.rowHeights;
-      }
-    } catch (error) {
-      console.error("Failed to load treeview config:", error);
-    }
-  }
-  loadConfig();
-
-  watch(
-    [opened_views, panelWidth, additionalPanelWidth, selection, rowHeights],
-    () => {
-      // oxlint-disable-next-line unicorn/prefer-structured-clone
-      const clean_opened_views = JSON.parse(JSON.stringify(opened_views.value));
-      // oxlint-disable-next-line unicorn/prefer-structured-clone
-      const clean_selectionIds = JSON.parse(JSON.stringify(selection.value));
-      // oxlint-disable-next-line unicorn/prefer-structured-clone
-      const clean_rowHeights = JSON.parse(JSON.stringify(rowHeights.value));
-
-      database.treeview_config.put({
-        id: "main",
-        opened_views: clean_opened_views,
-        panelWidth: panelWidth.value,
-        additionalPanelWidth: additionalPanelWidth.value,
-        selectionIds: clean_selectionIds,
-        rowHeights: clean_rowHeights,
-      });
-    },
-    { deep: true },
-  );
-
-  function closeView(id) {
-    opened_views.value = opened_views.value.filter((view) => view.id !== id);
-  }
-
-  watch(selection, (current, previous) => {
-    const { removed } = compareSelections(current, previous);
-    for (const id of removed) {
-      const index = opened_views.value.findIndex(
-        (view) => view.type === "component" && view.id === id,
-      );
-      if (index !== -1) {
-        closeView(index);
-      }
-    }
-  });
-
-  function toggleView(id) {
-    const index = opened_views.value.findIndex((view) => view.id === id);
-    if (index !== -1) {
-      closeView(id);
-    } else if (id === "main") {
-      opened_views.value.unshift({
-        type: "object",
-        id: "main",
-        title: "Objects",
-        scrollTop: 0,
-        opened: [],
-      });
-    }
-  }
-
-  function addItem(geodeObjectType, name, id, viewer_type) {
-    const child = { title: name, id, viewer_type, geode_object_type: geodeObjectType };
-    let found = false;
-    for (const item of items.value) {
-      if (item.title === geodeObjectType) {
-        item.children.push(child);
-        const options = { numeric: true, sensitivity: "base" };
-        item.children.sort((childA, childB) =>
-          childA.title.localeCompare(childB.title, undefined, options),
-        );
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
-      items.value.push({ id: geodeObjectType, title: geodeObjectType, children: [child] });
-      const sort_options = { numeric: true, sensitivity: "base" };
-      items.value.sort((groupA, groupB) =>
-        groupA.title.localeCompare(groupB.title, undefined, sort_options),
-      );
-    }
-    selection.value = [...selection.value, id];
-  }
-
-  function removeItem(id) {
-    for (let index = 0; index < items.value.length; index += 1) {
-      const group = items.value[index];
-      const childIndex = group.children.findIndex((child) => child.id === id);
-      if (childIndex !== -1) {
-        group.children.splice(childIndex, 1);
-        if (group.children.length === 0) {
-          items.value.splice(index, 1);
-        }
-        selection.value = selection.value.filter((selection_id) => selection_id !== id);
-        return;
-      }
-    }
-  }
-
-  function displayAdditionalTree(id, title, geodeObjectType, viewType = "model_components") {
-    const viewId = `${id}_${viewType}`;
-    const index = opened_views.value.findIndex((view) => view.id === viewId);
-    if (index !== -1) {
-      return closeView(viewId);
-    }
-    additionalPanelWidth.value = panelWidth.value;
-    opened_views.value.push({
-      type: "component",
-      id: viewId,
-      modelId: id,
-      viewType,
-      title: title || id,
-      geode_object_type: geodeObjectType,
-      scrollTop: 0,
-      opened: [],
-    });
-  }
-
-  function moveView(from_index, to_index) {
-    if (from_index !== 0 && to_index !== 0) {
-      const [element] = opened_views.value.splice(from_index, 1);
-      opened_views.value.splice(to_index, 0, element);
-    }
-  }
-
-  function importStores(snapshot) {
-    opened_views.value = snapshot?.opened_views || [
-      { type: "object", id: "main", title: "Objects", scrollTop: 0, opened: [] },
-    ];
-    panelWidth.value = snapshot?.panelWidth || PANEL_WIDTH;
-    additionalPanelWidth.value = snapshot?.additionalPanelWidth || PANEL_WIDTH;
-    rowHeights.value = snapshot?.rowHeights || [];
-    pendingSelectionIds.value =
-      snapshot?.selectionIds ||
-      (snapshot?.selection || []).map((selectionItem) => selectionItem.id || selectionItem) ||
-      [];
-  }
-
-  function finalizeImportSelection() {
-    const rebuilt = [];
-    for (const group of items.value) {
-      for (const child of group.children) {
-        if (
-          pendingSelectionIds.value.length === 0 ||
-          pendingSelectionIds.value.includes(child.id)
-        ) {
-          rebuilt.push(child.id || child);
-        }
-      }
-    }
-    selection.value = rebuilt;
-    pendingSelectionIds.value = [];
-  }
-
-  function clear() {
-    items.value = [];
-    selection.value = [];
-    activeItems.value = [];
-    pendingSelectionIds.value = [];
-    opened_views.value = [
-      { type: "object", id: "main", title: "Objects", scrollTop: 0, opened: [] },
-    ];
-  }
-
-  function displayFileTree() {
-    opened_views.value = [
-      { type: "object", id: "main", title: "Objects", scrollTop: 0, opened: [] },
-    ];
-  }
-
-  function setPanelWidth(width) {
-    panelWidth.value = width;
-  }
-
-  function setAdditionalPanelWidth(width) {
-    additionalPanelWidth.value = width;
-  }
-
-  function setScrollTop(viewId, scrollTop) {
-    const view = opened_views.value.find((openedView) => openedView.id === viewId);
-    if (view) {
-      view.scrollTop = scrollTop;
-    }
-  }
-
-  function setOpened(viewId, opened) {
-    const view = opened_views.value.find((openedView) => openedView.id === viewId);
-    if (view) {
-      view.opened = opened;
-    }
-  }
-
-  function setRowHeights(heights) {
-    rowHeights.value = heights;
-  }
-
-  function exportStores() {
-    return {
-      opened_views: opened_views.value,
-      panelWidth: panelWidth.value,
-      additionalPanelWidth: additionalPanelWidth.value,
-      selectionIds: selection.value,
-      rowHeights: rowHeights.value,
-    };
-  }
-
-  function renameItem(id, newName) {
-    for (const group of items.value) {
-      const child = group.children.find((childItem) => childItem.id === id);
-      if (child) {
-        child.title = newName;
-        const options = { numeric: true, sensitivity: "base" };
-        group.children.sort((childA, childB) =>
-          childA.title.localeCompare(childB.title, undefined, options),
-        );
-        break;
-      }
-    }
-    const view = opened_views.value.find((openedView) => openedView.id === id);
-    if (view) {
-      view.title = newName;
-    }
-  }
-
-  return {
-    items,
-    selection,
-    activeItems,
-    opened_views,
-    panelWidth,
-    additionalPanelWidth,
-    isImporting,
-    rowHeights,
-    addItem,
-    removeItem,
-    renameItem,
-    displayAdditionalTree,
-    closeView,
-    toggleView,
-    moveView,
-    importStores,
-    displayFileTree,
-    setPanelWidth,
-    setAdditionalPanelWidth,
-    setScrollTop,
-    setOpened,
-    setRowHeights,
-    exportStores,
-    finalizeImportSelection,
-    clear,
-  };
-});

package/app/utils/attributes.js

@@ -1,23 +0,0 @@
-export function getAttributeRange(currentAttribute, compIndex = 0) {
-  if (!currentAttribute) {
-    return { min: 0, max: 1 };
-  }
-
-  const { min_values, max_values, min_value, max_value } = currentAttribute;
-  let min = 0;
-  let max = 1;
-
-  if (min_values && min_values[compIndex] !== undefined) {
-    min = min_values[compIndex];
-  } else if (compIndex === 0 && min_value !== undefined) {
-    min = min_value;
-  }
-
-  if (max_values && max_values[compIndex] !== undefined) {
-    max = max_values[compIndex];
-  } else if (compIndex === 0 && max_value !== undefined) {
-    max = max_value;
-  }
-
-  return { min, max };
-}

package/app/utils/clipping_planes.js

@@ -1,110 +0,0 @@
-const AXIS_SCALE = 0.45;
-const SIZE_RATIO = 0.1;
-const DEBOUNCE_DELAY = 200;
-const CHANGE_THRESHOLD = 1e-4;
-// oxlint-disable no-magic-numbers
-const COLOR_BLUE = [0.12, 0.53, 0.9];
-const COLOR_GREEN = [0.26, 0.63, 0.28];
-const COLOR_ORANGE = [0.98, 0.55, 0];
-const COLOR_PURPLE = [0.55, 0.14, 0.67];
-const COLOR_RED = [0.9, 0.22, 0.21];
-// oxlint-enable no-magic-numbers
-const PLANE_COLORS = [COLOR_BLUE, COLOR_GREEN, COLOR_ORANGE, COLOR_PURPLE, COLOR_RED];
-const NORMAL_X = [1, 0, 0];
-const NORMAL_Y = [0, 1, 0];
-const NORMAL_Z = [0, 0, 1];
-const DEFAULT_NORMALS = [NORMAL_X, NORMAL_Y, NORMAL_Z];
-const RGB_MAX_VALUE = 255;
-
-function getPlaneCssColor(index) {
-  const rgb = PLANE_COLORS[index % PLANE_COLORS.length];
-  return `rgb(${rgb.map((channel) => Math.round(channel * RGB_MAX_VALUE)).join(",")})`;
-}
-
-function hasPlaneChanged(origin, normal, currentOrigin, currentNormal) {
-  if (!currentOrigin) {
-    return true;
-  }
-  return (
-    origin.some((val, idx) => Math.abs(val - currentOrigin[idx]) > CHANGE_THRESHOLD) ||
-    normal.some((val, idx) => Math.abs(val - currentNormal[idx]) > CHANGE_THRESHOLD)
-  );
-}
-
-function getPlaneStyle(rgb) {
-  return {
-    active: {
-      plane: { opacity: 1, color: rgb },
-      normal: { opacity: 1, color: rgb },
-      origin: { opacity: 1, color: rgb },
-    },
-    inactive: {
-      plane: { opacity: 0.5, color: rgb },
-      normal: { opacity: 1, color: rgb },
-      origin: { opacity: 1, color: rgb },
-    },
-    static: {
-      display2D: { representation: 0 },
-      outline: { color: [1, 1, 1], opacity: 1, representation: 1, interpolation: 0 },
-    },
-  };
-}
-
-function computeSceneBounds(actors) {
-  let bounds = [Infinity, -Infinity, Infinity, -Infinity, Infinity, -Infinity];
-  for (const actor of actors) {
-    const boundsOfActor = actor.getBounds();
-    bounds = [
-      Math.min(bounds[0], boundsOfActor[0]),
-      Math.max(bounds[1], boundsOfActor[1]),
-      Math.min(bounds[2], boundsOfActor[2]),
-      Math.max(bounds[3], boundsOfActor[3]),
-      Math.min(bounds[4], boundsOfActor[4]),
-      Math.max(bounds[5], boundsOfActor[5]),
-    ];
-  }
-  return bounds;
-}
-
-function computeSceneBoundsInfo(actors) {
-  if (!actors || actors.length === 0) {
-    return { center: [0, 0, 0], cubicBounds: [-1, 1, -1, 1, -1, 1] };
-  }
-  const [xmin, xmax, ymin, ymax, zmin, zmax] = computeSceneBounds(actors);
-  const center = [
-    Number(((xmin + xmax) / 2).toFixed(4)),
-    Number(((ymin + ymax) / 2).toFixed(4)),
-    Number(((zmin + zmax) / 2).toFixed(4)),
-  ];
-
-  const maxActorExtent = Math.max(
-    ...actors.map((actor) => {
-      const bounds = actor.getBounds();
-      return Math.max(bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4]);
-    }),
-  );
-  const halfExtent = maxActorExtent / 2;
-  const cubicBounds = [
-    center[0] - halfExtent,
-    center[0] + halfExtent,
-    center[1] - halfExtent,
-    center[1] + halfExtent,
-    center[2] - halfExtent,
-    center[2] + halfExtent,
-  ];
-  return { center, cubicBounds };
-}
-
-export {
-  AXIS_SCALE,
-  SIZE_RATIO,
-  DEBOUNCE_DELAY,
-  CHANGE_THRESHOLD,
-  PLANE_COLORS,
-  DEFAULT_NORMALS,
-  getPlaneCssColor,
-  hasPlaneChanged,
-  getPlaneStyle,
-  computeSceneBounds,
-  computeSceneBoundsInfo,
-};

package/app/utils/colormap.js

@@ -1,64 +0,0 @@
-// oxlint-disable unicorn/prefer-export-from
-import colormaps from "@ogw_front/assets/colormaps.json";
-
-import { newInstance as vtkColorTransferFunction } from "@kitware/vtk.js/Rendering/Core/ColorTransferFunction";
-
-function getPresetByName(presetName) {
-  return colormaps
-    .flatMap((category) => category.Children)
-    .find((preset) => preset.Name === presetName);
-}
-
-function getRGBPointsFromPreset(presetName) {
-  return getPresetByName(presetName)?.RGBPoints ?? [];
-}
-
-function getPresetsWithCurrentAtTop(presetName) {
-  const currentPreset = getPresetByName(presetName);
-  return [currentPreset, ...colormaps].filter(Boolean);
-}
-
-function drawCanvasForPreset(presetName, canvas) {
-  if (!canvas) {
-    return;
-  }
-  const rgbPoints = getRGBPointsFromPreset(presetName);
-  if (!rgbPoints || rgbPoints.length === 0) {
-    return;
-  }
-  const ctx = canvas.getContext("2d");
-  const { height, width } = canvas;
-  const lut = vtkColorTransferFunction();
-
-  const LAST_POINT_OFFSET = 4;
-  const THREE = 3;
-
-  for (let pointIdx = 0; pointIdx < rgbPoints.length; pointIdx += 4) {
-    lut.addRGBPoint(
-      rgbPoints[pointIdx],
-      rgbPoints[pointIdx + 1],
-      rgbPoints[pointIdx + 2],
-      rgbPoints[pointIdx + THREE],
-    );
-  }
-  const table = lut.getUint8Table(rgbPoints[0], rgbPoints.at(-LAST_POINT_OFFSET), width, true);
-  const imageData = ctx.createImageData(width, height);
-  for (let xCoord = 0; xCoord < width; xCoord += 1) {
-    const alpha = table[xCoord * 4 + THREE];
-    const blue = table[xCoord * 4 + 2];
-    const green = table[xCoord * 4 + 1];
-    const red = table[xCoord * 4];
-    for (let yCoord = 0; yCoord < height; yCoord += 1) {
-      const pixelIdx = (yCoord * width + xCoord) * 4;
-      imageData.data[pixelIdx] = red;
-      imageData.data[pixelIdx + 1] = green;
-      imageData.data[pixelIdx + 2] = blue;
-      imageData.data[pixelIdx + THREE] = alpha;
-    }
-  }
-  ctx.putImageData(imageData, 0, 0);
-}
-
-export { drawCanvasForPreset, getRGBPointsFromPreset, getPresetByName, getPresetsWithCurrentAtTop };
-
-export { default as colormaps } from "@ogw_front/assets/colormaps.json";

package/app/utils/default_styles/meshes.js

@@ -1,191 +0,0 @@
-import {
-  CELLS_DEFAULT_COLOR,
-  CELLS_DEFAULT_VISIBILITY,
-  EDGES_DEFAULT_COLOR,
-  EDGES_DEFAULT_VISIBILITY,
-  EDGES_DEFAULT_WIDTH,
-  MESH_DEFAULT_ACTIVE_COLORING,
-  POINTS_DEFAULT_COLOR,
-  POINTS_DEFAULT_SIZE,
-  POINTS_DEFAULT_VISIBILITY,
-  POLYGONS_DEFAULT_COLOR,
-  POLYGONS_DEFAULT_VISIBILITY,
-  POLYHEDRA_DEFAULT_COLOR,
-  POLYHEDRA_DEFAULT_VISIBILITY,
-} from "./constants";
-
-function meshPointsDefaultStyle(
-  visibility = POINTS_DEFAULT_VISIBILITY,
-  size = POINTS_DEFAULT_SIZE,
-  constant = POINTS_DEFAULT_COLOR,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: MESH_DEFAULT_ACTIVE_COLORING,
-      constant,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-    size,
-  };
-}
-
-function meshEdgesDefaultStyle(
-  visibility = EDGES_DEFAULT_VISIBILITY,
-  width = EDGES_DEFAULT_WIDTH,
-  constant = EDGES_DEFAULT_COLOR,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: MESH_DEFAULT_ACTIVE_COLORING,
-      constant,
-      edge: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-    width,
-  };
-}
-
-function meshCellsDefaultStyle(
-  visibility = CELLS_DEFAULT_VISIBILITY,
-  constant = CELLS_DEFAULT_COLOR,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: MESH_DEFAULT_ACTIVE_COLORING,
-      cell: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      constant,
-      // oxlint-disable-next-line unicorn/no-null
-      textures: null,
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-  };
-}
-
-function meshPolygonsDefaultStyle(
-  visibility = POLYGONS_DEFAULT_VISIBILITY,
-  constant = POLYGONS_DEFAULT_COLOR,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: MESH_DEFAULT_ACTIVE_COLORING,
-      constant,
-      // oxlint-disable-next-line unicorn/no-null
-      textures: null,
-      polygon: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-  };
-}
-
-function meshPolyhedraDefaultStyle(
-  visibility = POLYHEDRA_DEFAULT_VISIBILITY,
-  constant = POLYHEDRA_DEFAULT_COLOR,
-) {
-  return {
-    visibility,
-    coloring: {
-      active: MESH_DEFAULT_ACTIVE_COLORING,
-      constant,
-      polyhedron: {
-        name: undefined,
-        storedConfigs: {},
-      },
-      vertex: {
-        name: undefined,
-        storedConfigs: {},
-      },
-    },
-  };
-}
-
-function pointSetDefaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(),
-  };
-}
-
-function edgedCurveDefaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(),
-    edges: meshEdgesDefaultStyle(),
-  };
-}
-
-function grid2dDefaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    cells: meshCellsDefaultStyle(),
-  };
-}
-
-function grid3dDefaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    cells: meshCellsDefaultStyle(),
-    polyhedra: meshPolyhedraDefaultStyle(),
-  };
-}
-
-function surfaceDefaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    polygons: meshPolygonsDefaultStyle(),
-  };
-}
-
-function solidDefaultStyle() {
-  return {
-    visibility: true,
-    points: meshPointsDefaultStyle(false),
-    edges: meshEdgesDefaultStyle(false),
-    polygons: meshPolygonsDefaultStyle(),
-    polyhedra: meshPolyhedraDefaultStyle(),
-  };
-}
-
-export {
-  meshPointsDefaultStyle,
-  meshEdgesDefaultStyle,
-  meshCellsDefaultStyle,
-  meshPolygonsDefaultStyle,
-  meshPolyhedraDefaultStyle,
-  pointSetDefaultStyle,
-  edgedCurveDefaultStyle,
-  grid2dDefaultStyle,
-  grid3dDefaultStyle,
-  surfaceDefaultStyle,
-  solidDefaultStyle,
-};

package/app/utils/status.js

@@ -1,10 +0,0 @@
-const Status = {
-  NOT_CREATED: "NOT_CREATED",
-  CREATING: "CREATING",
-  CREATED: "CREATED",
-  NOT_CONNECTED: "NOT_CONNECTED",
-  CONNECTING: "CONNECTING",
-  CONNECTED: "CONNECTED",
-};
-
-export { Status };

package/commitlint.config.js

@@ -1,20 +0,0 @@
-const Configuration = {
-  extends: ["@commitlint/config-angular"],
-  rules: {
-    "scope-empty": [2, "never"],
-    "subject-empty": [2, "never"],
-    "subject-max-length": [0],
-    "body-leading-blank": [0],
-    "footer-leading-blank": [0],
-    "header-max-length": [0],
-    "scope-case": [0],
-    "subject-case": [0],
-    "subject-full-stop": [0],
-    "type-case": [0],
-    "type-empty": [0],
-    "type-enum": [2, "always", ["feat", "fix", "perf"]],
-  },
-  defaultIgnores: false,
-};
-
-export default Configuration;