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

package/app/stores/app.js

@@ -1,326 +0,0 @@
-// Local imports
-import { getRestApiPort, getRestApiProtocol, isCloudMode } from "@ogw_front/utils/stores.js";
-import { Status } from "@ogw_front/utils/status";
-import { api_fetch } from "@ogw_internal/utils/api_fetch.js";
-import { killExtension } from "@ogw_front/utils/extension.js";
-import { upload_file } from "@ogw_internal/utils/upload_file.js";
-import { useInfraStore } from "@ogw_front/stores/infra";
-
-import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
-
-// oxlint-disable-next-line max-lines-per-function, max-statements
-export const useAppStore = defineStore("app", () => {
-  const stores = [];
-  const globalComponents = ref(new Map());
-  const default_local_port = ref(globalThis.location.port);
-  const status = ref(Status.NOT_CONNECTED);
-  const protocol = computed(() => getRestApiProtocol());
-  const port = computed(() => getRestApiPort(default_local_port.value));
-
-  const base_url = computed(() => {
-    const infraStore = useInfraStore();
-    let app_url = `${protocol.value}://${infraStore.domain_name}:${port.value}`;
-    if (isCloudMode()) {
-      app_url += `/server`;
-    }
-    return app_url;
-  });
-
-  function registerGlobalComponent(extensionId, componentId, component) {
-    if (!globalComponents.value.has(extensionId)) {
-      globalComponents.value.set(extensionId, new Map());
-    }
-    globalComponents.value.get(extensionId).set(componentId, component);
-    console.log(
-      `[AppStore] Registered global component ${componentId} for extension ${extensionId}`,
-    );
-  }
-
-  function unregisterGlobalComponent(extensionId, componentId) {
-    if (globalComponents.value.has(extensionId)) {
-      globalComponents.value.get(extensionId).delete(componentId);
-    }
-  }
-
-  function registerStore(store) {
-    const isAlreadyRegistered = stores.some((registeredStore) => registeredStore.$id === store.$id);
-    if (isAlreadyRegistered) {
-      console.log(`[AppStore] Store "${store.$id}" already registered, skipping`);
-      return;
-    }
-    console.log("[AppStore] Registering store", store.$id);
-    stores.push(store);
-  }
-
-  async function exportStores(params = {}) {
-    const snapshot = {};
-    let exportCount = 0;
-
-    console.log(`[AppStore] Exporting stores, total registered: ${stores.length}`);
-    await Promise.all(
-      stores.map(async (store) => {
-        if (!store.exportStores) {
-          return;
-        }
-        const storeId = store.$id;
-        try {
-          snapshot[storeId] = await store.exportStores(params);
-          exportCount += 1;
-        } catch (error) {
-          console.error(`[AppStore] Error exporting store "${storeId}":`, error);
-        }
-      }),
-    );
-    console.log(`[AppStore] Exported ${exportCount} stores; snapshot keys:`, Object.keys(snapshot));
-    return snapshot;
-  }
-
-  async function importStores(snapshot) {
-    if (!snapshot) {
-      console.warn("[AppStore] import called with invalid snapshot");
-      return;
-    }
-    console.log("[AppStore] Import snapshot keys:", Object.keys(snapshot || {}));
-
-    let importedCount = 0;
-    const notFoundStores = [];
-    await Promise.all(
-      stores.map(async (store) => {
-        if (!store.importStores) {
-          return;
-        }
-        const storeId = store.$id;
-        if (!snapshot[storeId]) {
-          notFoundStores.push(storeId);
-          return;
-        }
-        try {
-          await store.importStores(snapshot[storeId]);
-          importedCount += 1;
-        } catch (error) {
-          console.error(`[AppStore] Error importing store "${storeId}":`, error);
-        }
-      }),
-    );
-    if (notFoundStores.length > 0) {
-      console.warn(`[AppStore] Stores not found in snapshot: ${notFoundStores.join(", ")}`);
-    }
-    console.log(`[AppStore] Imported ${importedCount} stores`);
-  }
-
-  const loadedExtensions = ref(new Map());
-  const extensionAPI = ref(undefined);
-  const codeTransformer = ref(undefined);
-
-  function setExtensionAPI(api) {
-    extensionAPI.value = api;
-  }
-
-  function setCodeTransformer(transformer) {
-    codeTransformer.value = transformer;
-  }
-
-  function getExtension(id) {
-    return loadedExtensions.value.get(id);
-  }
-
-  async function loadExtension(path, extensionPort, backendPath = undefined) {
-    try {
-      let finalURL = path;
-
-      if (codeTransformer.value && path.startsWith("blob:")) {
-        const response = await fetch(path);
-        const code = await response.text();
-        const transformedCode = codeTransformer.value(code);
-
-        const newBlob = new Blob([transformedCode], {
-          type: "application/javascript",
-        });
-        finalURL = URL.createObjectURL(newBlob);
-      }
-      // oxlint-disable-next-line no-inline-comments
-      const extensionModule = await import(/* @vite-ignore */ finalURL);
-      const store = extensionModule.metadata.store();
-      store.$patch({ default_local_port: extensionPort });
-
-      if (finalURL !== path && finalURL.startsWith("blob:")) {
-        URL.revokeObjectURL(finalURL);
-      }
-
-      if (!extensionModule.metadata?.id) {
-        throw new Error("Extension must have metadata.id");
-      }
-
-      const extensionId = extensionModule.metadata.id;
-
-      if (loadedExtensions.value.has(extensionId)) {
-        console.warn(`[AppStore] Extension "${extensionId}" is already loaded`);
-        throw new Error(`Extension "${extensionId}" is already loaded.`);
-      }
-
-      if (!extensionAPI.value) {
-        throw new Error("Extension API not initialized");
-      }
-
-      if (typeof extensionModule.install !== "function") {
-        throw new TypeError("Extension must export an install function");
-      }
-
-      await extensionModule.install(extensionAPI.value, backendPath);
-
-      const extensionData = {
-        module: extensionModule,
-        id: extensionId,
-        path,
-        backendPath,
-        loadedAt: new Date().toISOString(),
-        metadata: extensionModule.metadata,
-        enabled: true,
-      };
-      loadedExtensions.value.set(extensionId, extensionData);
-
-      console.log(`[AppStore] Extension loaded successfully: ${extensionId}`);
-      return extensionModule;
-    } catch (error) {
-      console.error(`[AppStore] Failed to load extension from ${path}:`, error);
-      throw error;
-    }
-  }
-
-  function getLoadedExtensions() {
-    return [...loadedExtensions.value.values()];
-  }
-
-  async function unloadExtension(extensionId) {
-    console.log(`[AppStore] Unloading extension: ${extensionId}`);
-    const infraStore = useInfraStore();
-    await infraStore.unregister_microservice(extensionId);
-    await killExtension(extensionId);
-
-    loadedExtensions.value.delete(extensionId);
-    console.log(`[AppStore] Extension unloaded: ${extensionId}`);
-    return true;
-  }
-
-  function toggleExtension(extensionId) {
-    const extensionData = getExtension(extensionId);
-    if (!extensionData) {
-      return false;
-    }
-    extensionData.enabled = !extensionData.enabled;
-    console.log(
-      `[AppStore] Extension ${extensionData.enabled ? "enabled" : "disabled"}: ${extensionId}`,
-    );
-    return extensionData.enabled;
-  }
-
-  function setExtensionEnabled(extensionId, enabled) {
-    const extensionData = getExtension(extensionId);
-    if (!extensionData) {
-      return false;
-    }
-    extensionData.enabled = enabled;
-    console.log(`[AppStore] Extension ${enabled ? "enabled" : "disabled"}: ${extensionId}`);
-    return true;
-  }
-
-  function getExtensionEnabled(extensionId) {
-    return getExtension(extensionId)?.enabled ?? false;
-  }
-
-  function upload(file, callbacks = {}) {
-    const store = useAppStore();
-    const schema = opengeodeweb_front_schemas.api.local.extensions.upload;
-    const { PROJECT: projectName } = useRuntimeConfig().public;
-    const params = { projectName };
-    return upload_file(
-      store,
-      { schema, file, params },
-      {
-        ...callbacks,
-        response_function: async (response) => {
-          console.log("[APP] Request completed:", route);
-          if (callbacks.response_function) {
-            await callbacks.response_function(response);
-          }
-        },
-      },
-    );
-  }
-
-  function request({ schema, params }, callbacks = {}) {
-    const store = useAppStore();
-    return api_fetch(
-      store,
-      { schema, params },
-      {
-        ...callbacks,
-        response_function: async (response) => {
-          if (callbacks.response_function) {
-            await callbacks.response_function(response);
-          }
-        },
-      },
-    );
-  }
-
-  const request_counter = ref(0);
-  function start_request() {
-    request_counter.value += 1;
-  }
-  function stop_request() {
-    request_counter.value -= 1;
-  }
-  const is_busy = computed(() => request_counter.value > 0);
-
-  const projectFolderPath = ref("");
-
-  function createProjectFolder() {
-    const { PROJECT } = useRuntimeConfig().public;
-    const schema = opengeodeweb_front_schemas.api.local.app.project_folder_path;
-    const params = { PROJECT };
-    return request(
-      { schema, params },
-      {
-        response_function: (response) => {
-          console.log(`[APP] ${response.projectFolderPath} created`);
-          projectFolderPath.value = response.projectFolderPath;
-        },
-      },
-    );
-  }
-
-  return {
-    stores,
-    default_local_port,
-    request_counter,
-    status,
-    protocol,
-    port,
-    base_url,
-    is_busy,
-    registerStore,
-    exportStores,
-    importStores,
-    loadedExtensions,
-    extensionAPI,
-    setExtensionAPI,
-    setCodeTransformer,
-    loadExtension,
-    getLoadedExtensions,
-    getExtension,
-    unloadExtension,
-    toggleExtension,
-    setExtensionEnabled,
-    getExtensionEnabled,
-    request,
-    upload,
-    projectFolderPath,
-    createProjectFolder,
-    start_request,
-    stop_request,
-    globalComponents,
-    registerGlobalComponent,
-    unregisterGlobalComponent,
-  };
-});

package/app/stores/camera_manager.js

@@ -1,57 +0,0 @@
-// Third party imports
-import { liveQuery } from "dexie";
-import { useObservable } from "@vueuse/rxjs";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-// Local imports
-import { database } from "@ogw_internal/database/database.js";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-export const useCameraManagerStore = defineStore("camera_manager", () => {
-  const viewerStore = useViewerStore();
-  const camera_positions_db = database.camera_positions;
-
-  function refAllCameraPositions() {
-    return useObservable(
-      liveQuery(() => camera_positions_db.toArray()),
-      { initialValue: [] },
-    );
-  }
-
-  async function getCameraPosition(id) {
-    return await camera_positions_db.get(id);
-  }
-
-  async function saveCameraPosition(name, camera_options) {
-    await camera_positions_db.put({
-      name,
-      camera_options,
-    });
-  }
-
-  async function restoreCameraPosition(id) {
-    const position = await camera_positions_db.get(id);
-    if (position) {
-      const schema = viewer_schemas.opengeodeweb_viewer.viewer.update_camera;
-      const params = { camera_options: position.camera_options };
-      await viewerStore.request({ schema, params });
-    }
-  }
-
-  async function deleteCameraPosition(id) {
-    await camera_positions_db.delete(id);
-  }
-
-  async function renameCameraPosition(id, newName) {
-    await camera_positions_db.update(id, { name: newName });
-  }
-
-  return {
-    refAllCameraPositions,
-    getCameraPosition,
-    saveCameraPosition,
-    restoreCameraPosition,
-    deleteCameraPosition,
-    renameCameraPosition,
-  };
-});

package/app/stores/data.js

@@ -1,278 +0,0 @@
-// Third party imports
-import { liveQuery } from "dexie";
-import { useObservable } from "@vueuse/rxjs";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-// Local imports
-import { database } from "@ogw_internal/database/database.js";
-import { useDataCollections } from "./data_helpers/collections.js";
-import { useDataMesh } from "./data_helpers/mesh.js";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-
-const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic;
-function checkItemViewable(item) {
-  if (!item || typeof item !== "object") {
-    return false;
-  }
-  if (item.is_viewable !== undefined) {
-    return Boolean(item.is_viewable);
-  }
-  if (item.binary_light_viewable !== undefined) {
-    return item.binary_light_viewable !== "not_viewable";
-  }
-  if (
-    item.geode_object_type === "HorizonStack3D" ||
-    item.id === "HorizonStack3D" ||
-    item.title === "HorizonStack3D"
-  ) {
-    return false;
-  }
-  return true;
-}
-function isItemViewable(itemOrId) {
-  if (typeof itemOrId === "string") {
-    return database.data.get(itemOrId).then(checkItemViewable);
-  }
-  return checkItemViewable(itemOrId);
-}
-
-// oxlint-disable-next-line max-lines-per-function, max-statements
-export const useDataStore = defineStore("data", () => {
-  const viewerStore = useViewerStore();
-  const data_db = database.data;
-  const model_components_db = database.model_components;
-  const model_components_relation_db = database.model_components_relation;
-  const {
-    formatedMeshComponents,
-    refFormatedMeshComponents,
-    getMeshComponentsByType,
-    getAllMeshComponents,
-    fetchAllMeshComponents,
-    getMeshComponentGeodeIds,
-    getCornersGeodeIds,
-    getLinesGeodeIds,
-    getSurfacesGeodeIds,
-    getBlocksGeodeIds,
-  } = useDataMesh();
-  const {
-    hasCollectionComponents,
-    getAllCollectionComponents,
-    fetchAllCollectionComponents,
-    formatedCollectionComponents,
-    refFormatedCollectionComponents,
-  } = useDataCollections();
-  async function item(id) {
-    const data_item = await data_db.get(id);
-    if (!data_item) {
-      throw new Error(`Item not found: ${id}`);
-    }
-    return data_item;
-  }
-  async function allItems() {
-    return await data_db.toArray();
-  }
-  function refItem(id) {
-    return useObservable(
-      liveQuery(() => data_db.get(id)),
-      {
-        initialValue: {},
-      },
-    );
-  }
-  function refAllItems() {
-    return useObservable(
-      liveQuery(() => data_db.toArray()),
-      {
-        initialValue: [],
-      },
-    );
-  }
-  async function meshComponentType(modelId, geode_id) {
-    const component = await model_components_db
-      .where("[id+geode_id]")
-      .equals([modelId, geode_id])
-      .first();
-    return component?.type;
-  }
-  async function registerObject(id, name) {
-    const schema = viewer_generic_schemas.register;
-    const params = {
-      id,
-      name,
-    };
-    return await viewerStore.request({
-      schema,
-      params,
-      timeout: 0,
-    });
-  }
-  async function deregisterObject(id) {
-    const schema = viewer_generic_schemas.deregister;
-    const params = {
-      id,
-    };
-    return await viewerStore.request({
-      schema,
-      params,
-    });
-  }
-  function addItem(new_item) {
-    const itemData = {
-      id: new_item.id,
-      name: new_item.name || new_item.id,
-      viewer_type: new_item.viewer_type,
-      geode_object_type: new_item.geode_object_type,
-      visible: true,
-      created_at: new Date().toISOString(),
-      is_viewable: new_item.is_viewable,
-    };
-    if (new_item.binary_light_viewable !== undefined && new_item.binary_light_viewable !== null) {
-      itemData.binary_light_viewable = new_item.binary_light_viewable;
-    }
-    return data_db.put(itemData);
-  }
-  function addComponents(new_item) {
-    const allComponents = [];
-    function addModelComponents(components) {
-      for (const component of components) {
-        allComponents.push({
-          id: new_item.id,
-          geode_id: component.geode_id,
-          type: component.type,
-          viewer_id: component.viewer_id,
-          name: component.name,
-          is_active: component.is_active,
-        });
-      }
-    }
-    if (new_item.mesh_components) {
-      addModelComponents(new_item.mesh_components);
-    }
-    if (new_item.collection_components) {
-      addModelComponents(new_item.collection_components);
-    }
-    return model_components_db.bulkPut(allComponents);
-  }
-  function addComponentRelations(new_item) {
-    const relations = [];
-    function addModelComponentRelations(components, parent, type) {
-      for (const child of components) {
-        relations.push({
-          id: new_item.id,
-          parent,
-          child,
-          type,
-        });
-      }
-    }
-    if (new_item.mesh_components) {
-      for (const component of new_item.mesh_components) {
-        if (component.boundaries) {
-          addModelComponentRelations(component.boundaries, component.geode_id, "boundary");
-        }
-        if (component.internals) {
-          addModelComponentRelations(component.internals, component.geode_id, "internal");
-        }
-      }
-    }
-    if (new_item.collection_components) {
-      for (const component of new_item.collection_components) {
-        if (component.items) {
-          addModelComponentRelations(component.items, component.geode_id, "collection");
-        }
-      }
-    }
-    return model_components_relation_db.bulkPut(relations);
-  }
-  async function getComponentByViewerId(modelId, viewer_id) {
-    const component = await model_components_db
-      .where("viewer_id")
-      .equals(Number(viewer_id))
-      .and((model_component) => model_component.id === modelId)
-      .first();
-    return component;
-  }
-  async function deleteModelComponents(modelId) {
-    await model_components_db.where("id").equals(modelId).delete();
-    await database.model_components_relation.where("id").equals(modelId).delete();
-  }
-
-  async function deleteItem(id) {
-    await data_db.delete(id);
-    await deleteModelComponents(id);
-  }
-
-  async function updateItem(id, changes) {
-    await data_db.update(id, changes);
-  }
-
-  async function getAllModelComponentsViewerIds(modelId) {
-    const components = await model_components_db.where("id").equals(modelId).toArray();
-    return components.map((component) => Math.trunc(Number(component.viewer_id)));
-  }
-  async function getMeshComponentsViewerIds(modelId, meshComponentGeodeIds) {
-    const components = await model_components_db
-      .where("[id+geode_id]")
-      .anyOf(meshComponentGeodeIds.map((geode_id) => [modelId, geode_id]))
-      .toArray();
-    return components.map((component) => Math.trunc(Number(component.viewer_id)));
-  }
-  async function exportStores() {
-    const items = await data_db.toArray();
-    const modelComponents = await model_components_db.toArray();
-    const modelComponentsRelations = await model_components_relation_db.toArray();
-    return {
-      items,
-      modelComponents,
-      modelComponentsRelations,
-    };
-  }
-
-  async function clear() {
-    await data_db.clear();
-    await model_components_db.clear();
-    await model_components_relation_db.clear();
-  }
-
-  async function importStores(snapshot) {
-    await clear();
-    await model_components_db.bulkPut(snapshot.modelComponents);
-    await model_components_relation_db.bulkPut(snapshot.modelComponentsRelations);
-  }
-  return {
-    refAllItems,
-    item,
-    allItems,
-    refItem,
-    isItemViewable,
-    meshComponentType,
-    registerObject,
-    deregisterObject,
-    addItem,
-    addComponents,
-    addComponentRelations,
-    deleteItem,
-    updateItem,
-    getAllModelComponentsViewerIds,
-    getMeshComponentsViewerIds,
-    getComponentByViewerId,
-    exportStores,
-    importStores,
-    clear,
-    formatedMeshComponents,
-    refFormatedMeshComponents,
-    getMeshComponentsByType,
-    getAllMeshComponents,
-    fetchAllMeshComponents,
-    getMeshComponentGeodeIds,
-    getCornersGeodeIds,
-    getLinesGeodeIds,
-    getSurfacesGeodeIds,
-    getBlocksGeodeIds,
-    hasCollectionComponents,
-    getAllCollectionComponents,
-    fetchAllCollectionComponents,
-    formatedCollectionComponents,
-    refFormatedCollectionComponents,
-  };
-});