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

package/app/composables/virtual_tree.ts

@@ -0,0 +1,271 @@
+import type { Ref } from "vue";
+
+// Same shape as Vue's MaybeRefOrGetter<T>, kept as a local alias for readability at call sites.
+type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
+
+type TreeItem = Record<string, unknown>;
+
+interface ItemPropsConfig {
+  value: string;
+  title: string;
+  children: string;
+  height: number;
+  [key: string]: unknown;
+}
+
+interface SelectionConfig {
+  selectable: boolean;
+  strategy: string;
+  [key: string]: unknown;
+}
+
+interface VirtualTreeProps {
+  readonly items?: readonly TreeItem[];
+  readonly opened?: readonly unknown[];
+  readonly selected?: readonly unknown[];
+  readonly active?: readonly unknown[];
+  readonly itemProps?: Partial<ItemPropsConfig>;
+  readonly selection?: Partial<SelectionConfig>;
+  readonly search?: string;
+  readonly customFilter?: (id: unknown, search: string, context: { raw: TreeItem }) => boolean;
+}
+
+interface DisplayItem {
+  raw: TreeItem;
+  id: unknown;
+  depth: number;
+  isOpen: boolean;
+  isActive: boolean;
+  isLeaf: boolean;
+}
+
+type EmitFn = (event: string, ...args: readonly unknown[]) => void;
+
+interface UseVirtualTreeReturn {
+  actualItemProps: ComputedRef<ItemPropsConfig>;
+  actualSelection: ComputedRef<SelectionConfig>;
+  displayItems: ComputedRef<DisplayItem[]>;
+  toggleOpen: (item: TreeItem) => void;
+  toggleSelect: (item: TreeItem) => void;
+  isSelected: (item: TreeItem) => boolean;
+  getIndeterminate: (item: TreeItem) => boolean;
+}
+
+// Real runtime check (rather than an `as TreeItem[]` cast) for the duck-typed "children" field:
+// Item shapes vary across callers (treeview groups, model component/collection groups, ...), so
+// This only verifies it is actually an array, same as the assumption the old cast silently made.
+function isTreeItemArray(value: unknown): value is TreeItem[] {
+  return Array.isArray(value);
+}
+
+// Extracted so we never call String() directly on a value typed as `unknown` (ids and titles can
+// Be anything at runtime): only stringify primitives that have a sane toString, and fall back to
+// "" for anything else instead of risking "[object Object]".
+function toDisplayString(value: unknown): string {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
+
+function useVirtualTree(
+  propsIn: ReadonlyMaybeRefOrGetter<VirtualTreeProps>,
+  emit: EmitFn,
+): UseVirtualTreeReturn {
+  const props = toRef(propsIn);
+
+  const actualItemProps = computed<ItemPropsConfig>(() => ({
+    value: "id",
+    title: "title",
+    children: "children",
+    height: 28,
+    ...props.value.itemProps,
+  }));
+
+  const actualSelection = computed<SelectionConfig>(() => ({
+    selectable: false,
+    strategy: "classic",
+    ...props.value.selection,
+  }));
+
+  const openedSet = computed(() => new Set(props.value.opened));
+  const selectedSet = computed(() => new Set(props.value.selected));
+  const activeSet = computed(() => new Set(props.value.active));
+
+  function toggleOpen(item: TreeItem): void {
+    const id = item[actualItemProps.value.value];
+    const { opened: openedArray = [] } = props.value;
+    const newOpened = new Set(openedArray);
+    if (newOpened.has(id)) {
+      newOpened.delete(id);
+    } else {
+      newOpened.add(id);
+    }
+    emit("update:opened", [...newOpened]);
+  }
+
+  function getChildrenOf(item: TreeItem): TreeItem[] | undefined {
+    const rawChildren = item[actualItemProps.value.children];
+    return isTreeItemArray(rawChildren) ? rawChildren : undefined;
+  }
+
+  function getLeafChildrenIds(item: TreeItem): unknown[] {
+    const children = getChildrenOf(item);
+    if (children) {
+      return children.flatMap((child) => getLeafChildrenIds(child));
+    }
+    return [item[actualItemProps.value.value]];
+  }
+
+  function isSelected(item: TreeItem): boolean {
+    const id = item[actualItemProps.value.value];
+    if (selectedSet.value.has(id)) {
+      return true;
+    }
+    if (actualSelection.value.strategy === "classic") {
+      const childrenIds = getLeafChildrenIds(item);
+      return (
+        childrenIds.length > 0 && childrenIds.every((childId) => selectedSet.value.has(childId))
+      );
+    }
+    return false;
+  }
+
+  function getIndeterminate(item: TreeItem): boolean {
+    if (actualSelection.value.strategy !== "classic") {
+      return false;
+    }
+    const childrenIds = getLeafChildrenIds(item);
+    if (childrenIds.length === 0) {
+      return false;
+    }
+
+    const selectedChildren = childrenIds.filter((childId) => selectedSet.value.has(childId));
+    return selectedChildren.length > 0 && selectedChildren.length < childrenIds.length;
+  }
+
+  function toggleSelect(item: TreeItem): void {
+    const id = item[actualItemProps.value.value];
+    const { selected: selectedArray = [] } = props.value;
+    const newSelected = new Set(selectedArray);
+    const isCurrentlySelected = newSelected.has(id) || isSelected(item);
+
+    if (actualSelection.value.strategy === "classic") {
+      const childrenIds = getLeafChildrenIds(item);
+      if (isCurrentlySelected) {
+        newSelected.delete(id);
+        for (const childId of childrenIds) {
+          newSelected.delete(childId);
+        }
+      } else {
+        newSelected.add(id);
+        for (const childId of childrenIds) {
+          newSelected.add(childId);
+        }
+      }
+    } else if (isCurrentlySelected) {
+      newSelected.delete(id);
+    } else {
+      newSelected.add(id);
+    }
+    emit("update:selected", [...newSelected]);
+  }
+
+  function flattenTree(itemsList: readonly TreeItem[], depth = 0): DisplayItem[] {
+    const { search, customFilter } = props.value;
+    const result: DisplayItem[] = [];
+
+    for (const item of itemsList) {
+      const id = item[actualItemProps.value.value];
+      const children = getChildrenOf(item);
+      const hasChildren = Boolean(children && children.length > 0);
+
+      const isOpen = openedSet.value.has(id);
+      const isActive = activeSet.value.has(id);
+
+      if (search !== undefined && search !== "") {
+        const lowerSearch = search.toLowerCase();
+        const matches = customFilter
+          ? customFilter(id, search, { raw: item })
+          : toDisplayString(item[actualItemProps.value.title])
+              .toLowerCase()
+              .includes(lowerSearch) || toDisplayString(id).toLowerCase().includes(lowerSearch);
+
+        if (hasChildren) {
+          const subtree = flattenTree(children ?? [], depth + 1);
+          if (subtree.length === 0 && !matches) {
+            continue;
+          }
+
+          result.push({
+            raw: item,
+            id,
+            depth,
+            isOpen,
+            isActive,
+            isLeaf: false,
+          });
+          if (isOpen) {
+            result.push(...subtree);
+          }
+          continue;
+        }
+        if (!matches) {
+          continue;
+        }
+      }
+
+      result.push({
+        raw: item,
+        id,
+        depth,
+        isOpen,
+        isActive,
+        isLeaf: !hasChildren,
+      });
+
+      if (isOpen && hasChildren) {
+        result.push(...flattenTree(children ?? [], depth + 1));
+      }
+    }
+    return result;
+  }
+
+  function collectNonLeafIds(itemsList: readonly TreeItem[]): unknown[] {
+    const allIds: unknown[] = [];
+    for (const item of itemsList) {
+      const children = getChildrenOf(item);
+      if (children && children.length > 0) {
+        allIds.push(item[actualItemProps.value.value], ...collectNonLeafIds(children));
+      }
+    }
+    return allIds;
+  }
+
+  const displayItems = computed(() => flattenTree(props.value.items ?? []));
+
+  watch(
+    () => props.value.search,
+    (newSearch, oldSearch) => {
+      const hasNewSearch = newSearch !== undefined && newSearch !== "";
+      const hadOldSearch = oldSearch !== undefined && oldSearch !== "";
+      if (hasNewSearch && !hadOldSearch) {
+        const allIds = collectNonLeafIds(props.value.items ?? []);
+        emit("update:opened", [...new Set([...(props.value.opened ?? []), ...allIds])]);
+      }
+    },
+  );
+
+  return {
+    actualItemProps,
+    actualSelection,
+    displayItems,
+    toggleOpen,
+    toggleSelect,
+    isSelected,
+    getIndeterminate,
+  };
+}
+
+export { useVirtualTree };
+export type { TreeItem, ItemPropsConfig, SelectionConfig, DisplayItem, EmitFn };

package/app/composables/vtk_implicit_plane_widget.d.ts

@@ -0,0 +1,2 @@
+// Vtk.js does not ship type declarations for this widget module.
+declare module "@kitware/vtk.js/Widgets/Widgets3D/ImplicitPlaneWidget";

package/app/plugins/{auto_store_register.js → auto_store_register.ts}

@@ -1,13 +1,13 @@
+import type { PiniaPluginContext } from "pinia";
 import { useAppStore } from "@ogw_front/stores/app";
 
-function autoStoreRegister({ store }) {
+function autoStoreRegister({ store }: PiniaPluginContext): void {
   if (store.$id === "app") {
     return;
   }
 
   const appStore = useAppStore();
   appStore.registerStore(store);
-  console.log(`[AutoRegister] Store "${store.$id}" processed`);
 }
 
 export default defineNuxtPlugin({
@@ -15,12 +15,10 @@ export default defineNuxtPlugin({
   dependsOn: ["pinia"],
   setup(nuxtApp) {
     const { $pinia } = nuxtApp;
-    if (!$pinia) {
-      console.warn("Pinia instance not available.");
+    if ($pinia === undefined) {
       return;
     }
 
     $pinia.use(autoStoreRegister);
-    console.log("[AUTOREGISTER PLUGIN] Loaded automatically from OpenGeodeWeb-Front");
   },
 });

package/app/plugins/click_outside_ignore_snackbars.client.ts

@@ -0,0 +1,36 @@
+import { ClickOutside } from "vuetify/directives/click-outside";
+import type { DirectiveBinding } from "vue";
+
+type ClickOutsideValue =
+  | ((event: MouseEvent) => void)
+  | {
+      handler: (event: MouseEvent) => void;
+      closeConditional?: (event: Event) => boolean;
+      include?: () => HTMLElement[];
+    };
+
+function snackbarElements(): HTMLElement[] {
+  return [...document.querySelectorAll<HTMLElement>(".v-snackbar")];
+}
+
+export default defineNuxtPlugin({
+  name: "click-outside-ignore-snackbars",
+  setup() {
+    const originalMounted = ClickOutside.mounted;
+
+    ClickOutside.mounted = (element: HTMLElement, binding: DirectiveBinding<ClickOutsideValue>) => {
+      const { value } = binding;
+      const handler = typeof value === "function" ? value : value.handler;
+      const closeConditional = typeof value === "function" ? undefined : value.closeConditional;
+      const include = typeof value === "function" ? undefined : value.include;
+
+      binding.value = {
+        handler,
+        closeConditional,
+        include: () => [...(include?.() ?? []), ...snackbarElements()],
+      };
+
+      originalMounted(element, binding);
+    };
+  },
+});

package/app/stores/app.ts

@@ -0,0 +1,252 @@
+// 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 { upload_file } from "@ogw_internal/utils/upload_file.js";
+import { useAppExtensions } from "./app_helpers/extension.js";
+import { useInfraStore } from "@ogw_front/stores/infra";
+
+import type { JsonRpcSchema, RequestHandlers } from "@ogw_shared/utils/types.js";
+import type { StateTree } from "pinia";
+
+import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
+
+// The `share` defineStore option (used by every store in this codebase) is implemented by a runtime pinia plugin outside this package's type surface; this augmentation only teaches the type checker about the option shape already used at each defineStore call site.
+declare module "pinia" {
+  // TypeScript requires a merged interface declaration's type parameter names to match pinia's own (`S`, `Store`) exactly, not just their count.
+  // oxlint-disable-next-line eslint/id-length
+  interface DefineStoreOptionsBase<S extends StateTree, Store> {
+    share?: { omit?: string[] };
+  }
+}
+
+interface RegisterableStore {
+  $id: string;
+  $patch?: (partial: Record<string, unknown>) => void;
+  exportStores?: (params?: Record<string, unknown>) => Promise<unknown>;
+  importStores?: (snapshot: unknown) => Promise<void> | void;
+  connect?: () => Promise<void>;
+  kill?: () => Promise<void>;
+  [key: string]: unknown;
+}
+
+// oxlint-disable-next-line max-lines-per-function, max-statements
+export const useAppStore = defineStore("app", () => {
+  const stores: RegisterableStore[] = [];
+  const globalComponents = ref<Map<string, Map<string, unknown>>>(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: string,
+    componentId: string,
+    component: unknown,
+  ): void {
+    if (!globalComponents.value.has(extensionId)) {
+      globalComponents.value.set(extensionId, new Map());
+    }
+    globalComponents.value.get(extensionId)?.set(componentId, component);
+  }
+
+  function unregisterGlobalComponent(extensionId: string, componentId: string): void {
+    if (globalComponents.value.has(extensionId)) {
+      globalComponents.value.get(extensionId)?.delete(componentId);
+    }
+  }
+
+  function registerStore(store: RegisterableStore): void {
+    const isAlreadyRegistered = stores.some(
+      (registeredStore: RegisterableStore) => registeredStore.$id === store.$id,
+    );
+    if (isAlreadyRegistered) {
+      return;
+    }
+    stores.push(store);
+  }
+
+  async function exportStores(
+    params: Record<string, unknown> = {},
+  ): Promise<Record<string, unknown>> {
+    const snapshot: Record<string, unknown> = {};
+
+    await Promise.all(
+      stores.map(async (store: RegisterableStore) => {
+        if (!store.exportStores) {
+          return;
+        }
+        const storeId = store.$id;
+        try {
+          snapshot[storeId] = await store.exportStores(params);
+        } catch {
+          // Ignore stores that fail to export; other stores still complete independently.
+        }
+      }),
+    );
+    return snapshot;
+  }
+
+  async function importStores(snapshot: Record<string, unknown> | undefined): Promise<void> {
+    if (!snapshot) {
+      return;
+    }
+
+    const missingStoreIds: string[] = [];
+
+    await Promise.all(
+      stores.map(async (store: RegisterableStore) => {
+        if (!store.importStores) {
+          return;
+        }
+        const storeId = store.$id;
+        if (snapshot[storeId] === undefined) {
+          missingStoreIds.push(storeId);
+          return;
+        }
+        try {
+          await store.importStores(snapshot[storeId]);
+        } catch {
+          // Ignore stores that fail to import; other stores still complete independently.
+        }
+      }),
+    );
+
+    if (missingStoreIds.length > 0) {
+      console.warn(`Stores not found in snapshot: ${missingStoreIds.join(", ")}`);
+    }
+  }
+
+  const {
+    loadedExtensions,
+    extensionAPI,
+    setExtensionAPI,
+    setCodeTransformer,
+    getExtension,
+    loadExtension,
+    getLoadedExtensions,
+    unloadExtension,
+    toggleExtension,
+    setExtensionEnabled,
+    getExtensionEnabled,
+  } = useAppExtensions();
+
+  const request_counter = ref(0);
+  function start_request(): void {
+    request_counter.value += 1;
+  }
+  function stop_request(): void {
+    request_counter.value -= 1;
+  }
+  const is_busy = computed(() => request_counter.value > 0);
+
+  async function upload(file: Readonly<File>, callbacks: RequestHandlers = {}): Promise<unknown> {
+    const schema = opengeodeweb_front_schemas.api.local.extensions.upload;
+    const { PROJECT: projectName } = useRuntimeConfig().public;
+    const params = { projectName };
+    const result = await upload_file(
+      { $id: "app", base_url: base_url.value, start_request, stop_request },
+      { schema, file, params },
+      {
+        ...callbacks,
+        response_function: async (response: unknown) => {
+          if (callbacks.response_function) {
+            await callbacks.response_function(response);
+          }
+        },
+      },
+    );
+    return result;
+  }
+
+  // `TResult` is asserted, not verified, at the single `return result as TResult` boundary below: the backend response is only checked against `schema` at runtime, so callers' `TResult` is a contract with the schema, not something this function can prove.
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
+  async function request<TResult = unknown>(
+    { schema, params }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
+    callbacks: RequestHandlers = {},
+  ): Promise<TResult> {
+    const result = await api_fetch(
+      { $id: "app", base_url: base_url.value, start_request, stop_request },
+      // The app store is only ever used with HTTP ("front") schemas, which always carry `methods`; the wider JsonRpcSchema param above is kept as-is to match this action's public signature (e.g. relayed from get_version-style callers that only know about the shared, looser schema shape).
+      // oxlint-disable-next-line no-unsafe-type-assertion -- narrowing optional `methods` to required is safe here; see comment above.
+      { schema: schema as JsonRpcSchema & { methods: string[] }, params },
+      {
+        ...callbacks,
+        response_function: async (response: unknown) => {
+          if (callbacks.response_function) {
+            await callbacks.response_function(response);
+          }
+        },
+      },
+    );
+    // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary; see comment above.
+    return result as TResult;
+  }
+
+  const projectFolderPath = ref("");
+
+  async function createProjectFolder(): Promise<unknown> {
+    const { PROJECT } = useRuntimeConfig().public;
+    const schema = opengeodeweb_front_schemas.api.local.app.project_folder_path;
+    const params = { PROJECT };
+    const result = await request(
+      { schema, params },
+      {
+        response_function: (response: unknown) => {
+          // oxlint-disable-next-line no-unsafe-type-assertion
+          const { projectFolderPath: newProjectFolderPath } = response as {
+            projectFolderPath: string;
+          };
+          projectFolderPath.value = newProjectFolderPath;
+        },
+      },
+    );
+    return result;
+  }
+
+  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,
+  };
+});
+
+export type { RegisterableStore };