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

package/app/stores/data_helpers/collections.js

@@ -1,96 +0,0 @@
-import { MESH_COMPONENT_TYPES } from "@ogw_front/utils/default_styles";
-import { database } from "@ogw_internal/database/database.js";
-import { liveQuery } from "dexie";
-import { useDataMesh } from "./mesh.js";
-import { useObservable } from "@vueuse/rxjs";
-
-function pluralize(type) {
-  if (type.endsWith("y")) {
-    return `${type.slice(0, -1)}ies`;
-  }
-  return `${type}s`;
-}
-
-export function useDataCollections() {
-  const model_components_db = database.model_components;
-  const model_components_relation_db = database.model_components_relation;
-  const { getAllMeshComponents } = useDataMesh();
-
-  async function hasCollectionComponents(modelId) {
-    const count = await model_components_db
-      .where("id")
-      .equals(modelId)
-      .and((component) => !MESH_COMPONENT_TYPES.includes(component.type))
-      .count();
-    return count > 0;
-  }
-
-  async function getAllCollectionComponents(modelId) {
-    const items = await model_components_db.where("id").equals(modelId).toArray();
-    return items
-      .filter((component) => !MESH_COMPONENT_TYPES.includes(component.type))
-      .map((component) => ({
-        id: component.geode_id,
-        title: component.name,
-        category: component.type,
-        viewer_id: Number(component.viewer_id),
-        is_active: component.is_active,
-      }));
-  }
-
-  async function fetchAllCollectionComponents(modelId) {
-    const components = await getAllCollectionComponents(modelId);
-    const relations = await model_components_relation_db.where("id").equals(modelId).toArray();
-    const allMeshComponents = await getAllMeshComponents(modelId);
-    const meshComponentsById = {};
-    for (const meshComponent of allMeshComponents) {
-      meshComponentsById[meshComponent.id] = meshComponent;
-    }
-
-    const byType = {};
-    for (const component of components) {
-      if (!byType[component.category]) {
-        byType[component.category] = [];
-      }
-      const itemRelations = relations.filter(
-        (relation) => relation.parent === component.id && relation.type === "collection",
-      );
-      const children = itemRelations
-        .map((relation) => meshComponentsById[relation.child])
-        .filter(Boolean);
-      byType[component.category].push({
-        ...component,
-        children,
-      });
-    }
-    return byType;
-  }
-
-  async function formatedCollectionComponents(modelId) {
-    const byType = await fetchAllCollectionComponents(modelId);
-    const collectionTypes = Object.keys(byType);
-
-    return collectionTypes
-      .filter((type) => byType[type] && byType[type].length > 0)
-      .map((type) => ({
-        id: type,
-        title: pluralize(type),
-        children: byType[type],
-      }));
-  }
-
-  function refFormatedCollectionComponents(modelId) {
-    return useObservable(
-      liveQuery(() => formatedCollectionComponents(modelId)),
-      { initialValue: undefined },
-    );
-  }
-
-  return {
-    hasCollectionComponents,
-    getAllCollectionComponents,
-    fetchAllCollectionComponents,
-    formatedCollectionComponents,
-    refFormatedCollectionComponents,
-  };
-}

package/app/stores/data_helpers/mesh.js

@@ -1,122 +0,0 @@
-import { database } from "@ogw_internal/database/database.js";
-import { liveQuery } from "dexie";
-import { useObservable } from "@vueuse/rxjs";
-
-export function useDataMesh() {
-  const model_components_db = database.model_components;
-
-  async function formatedMeshComponents(modelId) {
-    const items = await model_components_db.where("id").equals(modelId).toArray();
-    const componentTitles = {
-      Corner: "Corners",
-      Line: "Lines",
-      Surface: "Surfaces",
-      Block: "Blocks",
-    };
-
-    const componentsByType = {};
-    for (const component_item of items) {
-      if (componentTitles[component_item.type]) {
-        if (!componentsByType[component_item.type]) {
-          componentsByType[component_item.type] = [];
-        }
-        componentsByType[component_item.type].push(component_item);
-      }
-    }
-
-    return Object.keys(componentTitles)
-      .filter((type) => componentsByType[type])
-      .map((type) => ({
-        id: type,
-        title: componentTitles[type],
-        children: componentsByType[type].map((meshComponent) => ({
-          id: meshComponent.geode_id,
-          title: meshComponent.name,
-          category: meshComponent.type,
-          viewer_id: Number(meshComponent.viewer_id),
-          is_active: meshComponent.is_active,
-        })),
-      }));
-  }
-
-  function refFormatedMeshComponents(modelId) {
-    return useObservable(
-      liveQuery(() => formatedMeshComponents(modelId)),
-      { initialValue: undefined },
-    );
-  }
-
-  async function getMeshComponentsByType(modelId, type) {
-    const components = await model_components_db
-      .where("[id+type]")
-      .equals([modelId, type])
-      .toArray();
-    return components.map((meshComponent) => ({
-      id: meshComponent.geode_id,
-      title: meshComponent.name,
-      category: meshComponent.type,
-      viewer_id: Number(meshComponent.viewer_id),
-      is_active: meshComponent.is_active,
-    }));
-  }
-
-  async function getAllMeshComponents(modelId) {
-    const items = await model_components_db.where("id").equals(modelId).toArray();
-    return items.map((meshComponent) => ({
-      id: meshComponent.geode_id,
-      title: meshComponent.name,
-      category: meshComponent.type,
-      viewer_id: Number(meshComponent.viewer_id),
-      is_active: meshComponent.is_active,
-    }));
-  }
-
-  async function fetchAllMeshComponents(modelId) {
-    const components = await getAllMeshComponents(modelId);
-    const byType = {};
-    for (const component of components) {
-      if (!byType[component.category]) {
-        byType[component.category] = [];
-      }
-      byType[component.category].push(component);
-    }
-    return byType;
-  }
-
-  async function getMeshComponentGeodeIds(modelId, type) {
-    const components = await model_components_db
-      .where("[id+type]")
-      .equals([modelId, type])
-      .toArray();
-    return components.map((component) => component.geode_id);
-  }
-
-  async function getCornersGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Corner");
-  }
-
-  async function getLinesGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Line");
-  }
-
-  async function getSurfacesGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Surface");
-  }
-
-  async function getBlocksGeodeIds(modelId) {
-    return await getMeshComponentGeodeIds(modelId, "Block");
-  }
-
-  return {
-    formatedMeshComponents,
-    refFormatedMeshComponents,
-    getMeshComponentsByType,
-    getAllMeshComponents,
-    fetchAllMeshComponents,
-    getMeshComponentGeodeIds,
-    getCornersGeodeIds,
-    getLinesGeodeIds,
-    getSurfacesGeodeIds,
-    getBlocksGeodeIds,
-  };
-}

package/app/stores/data_style.js

@@ -1,116 +0,0 @@
-import { database } from "@ogw_internal/database/database.js";
-import { getDefaultStyle } from "@ogw_front/utils/default_styles";
-import { useDataStore } from "@ogw_front/stores/data";
-import { useDataStyleState } from "@ogw_internal/stores/data_style/state";
-import { useMeshStyle } from "@ogw_internal/stores/data_style/mesh/index";
-import { useModelStyle } from "@ogw_internal/stores/data_style/model/index";
-
-// oxlint-disable-next-line max-lines-per-function
-export const useDataStyleStore = defineStore("dataStyle", () => {
-  const dataStyleState = useDataStyleState();
-  const meshStyleStore = useMeshStyle();
-  const modelStyleStore = useModelStyle();
-  const dataStore = useDataStore();
-  const data_style_db = database.data_style;
-  const model_component_type_datastyle_db = database.model_component_type_datastyle;
-  const component_datastyle_db = database.model_component_datastyle;
-
-  async function addDataStyle(id, geode_object) {
-    await data_style_db.put(structuredClone({ id, ...getDefaultStyle(geode_object) }));
-  }
-
-  async function setVisibility(id, visibility) {
-    const item = await dataStore.item(id);
-    if (!(await dataStore.isItemViewable(item))) {
-      return dataStyleState.mutateStyle(id, { visibility });
-    }
-
-    const { viewer_type } = item;
-
-    if (viewer_type === "mesh") {
-      return meshStyleStore.setMeshVisibility(id, visibility);
-    }
-    if (viewer_type === "model") {
-      return modelStyleStore.setModelVisibility(id, visibility);
-    }
-    throw new Error("Unknown viewer_type");
-  }
-
-  async function applyDefaultStyle(id) {
-    const item = await dataStore.item(id);
-    if (!(await dataStore.isItemViewable(item))) {
-      throw new Error(`applyDefaultStyle called for non-viewable item: ${id}`);
-    }
-
-    const { viewer_type } = item;
-
-    if (viewer_type === "mesh") {
-      return meshStyleStore.applyMeshStyle(id);
-    }
-    if (viewer_type === "model") {
-      return modelStyleStore.applyModelStyle(id);
-    }
-    throw new Error(`Unknown viewer_type: ${viewer_type}`);
-  }
-
-  function exportStores() {
-    return {
-      styles: dataStyleState.styles.value,
-      componentStyles: dataStyleState.componentStyles.value,
-      modelComponentTypeStyles: dataStyleState.modelComponentTypeStyles.value,
-    };
-  }
-
-  async function importStores(snapshot) {
-    const stylesSnapshot = snapshot.styles;
-    const componentStylesSnapshot = snapshot.componentStyles;
-    const modelComponentTypeStylesSnapshot = snapshot.modelComponentTypeStyles;
-
-    await dataStyleState.clear();
-
-    const style_promises = Object.entries(stylesSnapshot).map(([id, style]) =>
-      data_style_db.put(structuredClone({ id, ...style })),
-    );
-    const component_style_promises = Object.values(componentStylesSnapshot).map((style) =>
-      component_datastyle_db.put(structuredClone(style)),
-    );
-    const model_component_type_style_promises = Object.values(modelComponentTypeStylesSnapshot).map(
-      (style) => model_component_type_datastyle_db.put(structuredClone(style)),
-    );
-
-    await Promise.all([
-      ...style_promises,
-      ...component_style_promises,
-      ...model_component_type_style_promises,
-    ]);
-  }
-
-  function applyAllStylesFromState() {
-    const ids = Object.keys(dataStyleState.styles.value);
-    const promises = ids.map(async (id) => {
-      const meta = await dataStore.item(id);
-      if (!(await dataStore.isItemViewable(meta))) {
-        return;
-      }
-      const viewerType = meta.viewer_type;
-      if (viewerType === "mesh") {
-        return meshStyleStore.applyMeshStyle(id);
-      } else if (viewerType === "model") {
-        return modelStyleStore.applyModelStyle(id);
-      }
-    });
-    return Promise.all(promises);
-  }
-
-  return {
-    addDataStyle,
-    applyDefaultStyle,
-    setVisibility,
-    exportStores,
-    importStores,
-    applyAllStylesFromState,
-    ...dataStyleState,
-    ...meshStyleStore,
-    ...modelStyleStore,
-  };
-});

package/app/stores/infra.js

@@ -1,95 +0,0 @@
-import { Status } from "@ogw_front/utils/status";
-import { appMode } from "@ogw_shared/app_mode";
-import { registerRunningExtensions } from "@ogw_front/utils/extension";
-import { setAppBaseUrl } from "@ogw_shared/scripts";
-import { useAppStore } from "@ogw_front/stores/app";
-import { useCloudStore } from "@ogw_front/stores/cloud";
-
-export const useInfraStore = defineStore("infra", {
-  state: () => ({
-    app_mode: useRuntimeConfig().public.MODE,
-    status: Status.NOT_CREATED,
-    microservices: [],
-    domain_name: globalThis.location.hostname,
-  }),
-  getters: {
-    microservices_connected() {
-      console.log("microservices", this.microservices);
-      return this.microservices.every((store) => store.status === Status.CONNECTED);
-    },
-    microservices_busy() {
-      return this.microservices.some((store) => store.is_busy === true);
-    },
-  },
-  actions: {
-    register_microservice(store) {
-      const store_name = store.$id;
-      console.log("[INFRA] Registering microservice:", store_name);
-
-      if (!this.microservices.some((microservice) => microservice.$id === store_name)) {
-        this.microservices.push(store);
-        console.log("[INFRA] Microservice registered:", store_name);
-      }
-    },
-    unregister_microservice(microserviceId) {
-      console.log("[INFRA] Unregistering microservice:", microserviceId);
-      this.microservices = this.microservices.filter(
-        (microservice) => microservice.$id !== microserviceId,
-      );
-      console.log("[INFRA] Microservice unregistered:", microserviceId);
-    },
-    create_backend(email) {
-      console.log("[INFRA] Starting create_backend - Mode:", this.app_mode);
-      console.log(
-        "[INFRA] Registered microservices:",
-        this.microservices.map((store) => store.$id),
-      );
-      if (this.status === Status.CREATED) {
-        return;
-      }
-      return navigator.locks.request("infra.create_backend", async () => {
-        if (this.status === Status.CREATED) {
-          return;
-        }
-        this.status = Status.CREATING;
-        console.log("[INFRA] Lock granted for create_backend");
-        if (this.app_mode === appMode.CLOUD) {
-          const cloudStore = useCloudStore();
-          await cloudStore.launch(email);
-        } else {
-          const appStore = useAppStore();
-          await appStore.createProjectFolder();
-          if (this.app_mode === appMode.DESKTOP) {
-            globalThis.electronAPI.project_folder_path({
-              projectFolderPath: appStore.projectFolderPath,
-            });
-          }
-          await setAppBaseUrl(appStore.base_url);
-          const microservices_with_launch = this.microservices.filter((store) => store.launch);
-          const launch_promises = microservices_with_launch.map((store) =>
-            store.launch({ projectFolderPath: appStore.projectFolderPath }),
-          );
-          launch_promises.push(registerRunningExtensions());
-          await Promise.all(launch_promises);
-        }
-        this.status = Status.CREATED;
-        console.log("[INFRA] Backend created successfully");
-        return this.create_connection();
-      });
-    },
-    async create_connection() {
-      console.log("[INFRA] Starting create_connection");
-      await Promise.all(
-        this.microservices.map(async (store) => {
-          console.log("[INFRA] Connecting to microservice:", store.$id);
-          await store.connect();
-          console.log("[INFRA] Microservice connected:", store.$id);
-        }),
-      );
-      console.log("[INFRA] All microservices connected");
-    },
-  },
-  share: {
-    omit: ["microservices"],
-  },
-});