@vc-shell/framework 1.2.3 → 1.2.4-beta.1

package/shared/components/blade-navigation/composables/useBladeNavigation/internal/bladeRouteResolver.ts

@@ -1,244 +0,0 @@
-import { Component, isVNode } from "vue";
-import * as _ from "lodash-es";
-import { RouteLocationNormalized, Router, RouteLocationRaw } from "vue-router";
-import { IBladeRegistry } from "../../../../../../core/composables/useBladeRegistry";
-import type { BladeInstanceConstructor, BladeVNode } from "../../../types";
-import type { _createBladeStateManagement } from "./bladeState";
-import type { _createRouterUtils } from "./routerUtils";
-import type { _createBladeActions } from "./bladeActions";
-
-/**
- * Checks if a component is routable from URL
- */
-function isComponentRoutable(component: BladeInstanceConstructor | undefined): boolean {
-  return !(component && typeof component.routable === "boolean" && !component.routable);
-}
-
-// --- Blade Route Resolver Module ---
-export function _createBladeRouteResolver(
-  router: Router,
-  route: RouteLocationNormalized,
-  bladeRegistry: IBladeRegistry,
-  routerUtils: ReturnType<typeof _createRouterUtils>,
-  bladeActions: ReturnType<typeof _createBladeActions>,
-  bladeState: ReturnType<typeof _createBladeStateManagement>,
-  ensureBladeComponent: <Blade extends Component>(
-    bladeInput: BladeInstanceConstructor<Blade> | { name: string } | null | undefined,
-  ) => BladeInstanceConstructor<Blade>,
-  hasAccess: (permissions?: string | string[]) => boolean,
-) {
-  // Internal helper to find a blade component based on a URL segment
-  function findBladeComponentByUrlSegment(segment: string): BladeInstanceConstructor | undefined {
-    try {
-      const allRoutes = router.getRoutes();
-      const segmentWithSlash = segment.startsWith("/") ? segment : `/${segment}`;
-      const segmentWithoutSlash = segment.startsWith("/") ? segment.substring(1) : segment;
-
-      // 1. Check router's resolved routes by path suffix.
-      for (const r of allRoutes) {
-        let resolvedComponent: unknown;
-        let componentToCheck: unknown;
-
-        try {
-          const resolvedRoute = router.resolve({ name: r.name || undefined, path: !r.name ? r.path : undefined });
-
-          if (resolvedRoute.matched.length > 0) {
-            resolvedComponent = resolvedRoute.matched[resolvedRoute.matched.length - 1]?.components?.default;
-          }
-
-          componentToCheck = resolvedComponent;
-          if (resolvedComponent && isVNode(resolvedComponent) && resolvedComponent.type) {
-            componentToCheck = resolvedComponent.type;
-          }
-        } catch (e) {
-          // Silently continue to next route if resolution fails
-          continue;
-        }
-
-        const comp = componentToCheck as BladeInstanceConstructor;
-
-        if (comp && comp.isBlade && typeof comp.url === "string") {
-          const compUrlNormalized = comp.url.startsWith("/") ? comp.url : `/${comp.url}`;
-          if (compUrlNormalized === segmentWithSlash) {
-            return comp;
-          }
-        }
-      }
-
-      const potentialNames = [segmentWithoutSlash];
-      if (segment && segment !== "/" && segment.includes("-")) potentialNames.push(segment);
-
-      for (const nameToTry of _.uniq(potentialNames.filter(Boolean))) {
-        const bladeByName = bladeRegistry.getBladeComponent(nameToTry);
-        if (bladeByName && bladeByName.isBlade && typeof bladeByName.url === "string") {
-          const bladeByNameUrlNormalized = bladeByName.url.startsWith("/") ? bladeByName.url : `/${bladeByName.url}`;
-          if (bladeByNameUrlNormalized === segmentWithSlash) {
-            return bladeByName;
-          }
-        }
-      }
-
-      const bladeByFullPath = bladeRegistry.getBlade(segmentWithSlash);
-      if (bladeByFullPath && bladeByFullPath.component && bladeByFullPath.component.isBlade) {
-        const componentUrlNormalized = bladeByFullPath.component.url?.startsWith("/")
-          ? bladeByFullPath.component.url
-          : `/${bladeByFullPath.component.url}`;
-        if (componentUrlNormalized === segmentWithSlash) {
-          return bladeByFullPath.component as BladeInstanceConstructor;
-        }
-      }
-
-      return undefined;
-    } catch (error) {
-      console.error("Error in findBladeComponentByUrlSegment:", error instanceof Error ? error.message : String(error));
-      return undefined;
-    }
-  }
-
-  async function routeResolver(to: RouteLocationNormalized): Promise<RouteLocationRaw | undefined> {
-    const { path: toPath, query: toQueryFromTo } = to;
-    let currentConstructedPath: string | undefined;
-    if (bladeState.activeWorkspace.value) {
-      currentConstructedPath = routerUtils.constructBladePath(
-        bladeState.activeWorkspace.value,
-        _.last(bladeState.blades.value) as BladeVNode | undefined,
-      );
-    }
-    const currentFullPath = currentConstructedPath
-      ? (routerUtils.mainRouteBaseParamURL.value &&
-        !currentConstructedPath.startsWith(routerUtils.mainRouteBaseParamURL.value)
-          ? routerUtils.mainRouteBaseParamURL.value
-          : "") + currentConstructedPath
-      : undefined;
-
-    if (
-      currentFullPath &&
-      decodeURIComponent(to.fullPath).startsWith(decodeURIComponent(currentFullPath)) &&
-      bladeState.blades.value.length > 0
-    ) {
-      const toPathDecoded = decodeURIComponent(to.path);
-      const currentPathDecoded = decodeURIComponent(currentFullPath);
-      const toSegments = toPathDecoded.split("/").filter(Boolean);
-      const currentSegments = currentPathDecoded.split("/").filter(Boolean);
-
-      if (toPathDecoded.startsWith(currentPathDecoded) && toSegments.length === currentSegments.length) {
-        const targetRoute = routerUtils.allRoutes.find((r) => r.name === to.name);
-
-        if (
-          targetRoute &&
-          bladeState.activeWorkspace.value &&
-          targetRoute.components?.default === bladeState.activeWorkspace.value.type
-        ) {
-          return undefined;
-        }
-      }
-    }
-
-    const parsedUrl = routerUtils.parseUrlParams(to.path, to.params);
-
-    if (!parsedUrl || !parsedUrl.workspace) {
-      const rootRoute = routerUtils.goToRoot();
-      if (typeof rootRoute === "object" && rootRoute.name && rootRoute.name === to.name) {
-        return undefined;
-      }
-      return rootRoute;
-    }
-
-    const workspaceSegment = parsedUrl.workspace;
-    const bladeSegment = parsedUrl.blade;
-    const paramSegment = parsedUrl.param;
-
-    const workspaceComponent = findBladeComponentByUrlSegment(workspaceSegment);
-
-    if (!isComponentRoutable(workspaceComponent)) {
-      await bladeState.removeBladesStartingFrom(0);
-      bladeState.clearActiveWorkspaceState();
-      return routerUtils.goToRoot();
-    }
-
-    if (!workspaceComponent || !workspaceComponent.isWorkspace) {
-      const rootRoute = routerUtils.goToRoot();
-      if (typeof rootRoute === "object" && rootRoute.name && rootRoute.name === to.name) {
-        return undefined;
-      }
-      return rootRoute;
-    }
-
-    if (!hasAccess(workspaceComponent.permissions)) {
-      return routerUtils.goToRoot();
-    }
-
-    // Determine the parameter to pass to the workspace.
-    // It depends on whether a bladeSegment exists and if that blade shares its param with the parent.
-    let paramForWorkspace: string | undefined = undefined;
-    if (bladeSegment) {
-      const childBladeComponent = findBladeComponentByUrlSegment(bladeSegment);
-      // Check if workspace and child blade are from the same module using moduleUid
-      // and if the child blade is routable
-      if (
-        workspaceComponent &&
-        childBladeComponent &&
-        isComponentRoutable(childBladeComponent) &&
-        Object.prototype.hasOwnProperty.call(workspaceComponent, "moduleUid") &&
-        Object.prototype.hasOwnProperty.call(childBladeComponent, "moduleUid") &&
-        (workspaceComponent as BladeInstanceConstructor & { moduleUid?: string }).moduleUid ===
-          (childBladeComponent as BladeInstanceConstructor & { moduleUid?: string }).moduleUid
-      ) {
-        paramForWorkspace = paramSegment;
-      } else {
-        paramForWorkspace = undefined; // Default: child blade exists, its param is not for the workspace
-      }
-    } else {
-      paramForWorkspace = paramSegment; // No child blade segment, workspace gets the param from URL if present
-    }
-
-    const openWorkspaceResult = await bladeActions.openWorkspace(
-      {
-        blade: ensureBladeComponent(workspaceComponent),
-        param: paramForWorkspace,
-      },
-      to.query,
-      to.params,
-      true,
-    );
-
-    if (openWorkspaceResult && "redirectedFrom" in openWorkspaceResult) {
-      return undefined;
-    }
-
-    let lastOpenedBladeComponent = workspaceComponent;
-    let effectiveBladeSegment = bladeSegment;
-
-    if (effectiveBladeSegment) {
-      const bladeComponent = findBladeComponentByUrlSegment(effectiveBladeSegment);
-
-      if (!isComponentRoutable(bladeComponent)) {
-        effectiveBladeSegment = undefined;
-      }
-
-      if (effectiveBladeSegment && bladeComponent && bladeComponent.isBlade && !bladeComponent.isWorkspace) {
-        if (!hasAccess(bladeComponent.permissions)) {
-          // No access to blade, workspace remains open
-        } else {
-          await bladeActions.openBlade({
-            blade: ensureBladeComponent(bladeComponent),
-            param: paramSegment,
-          });
-          lastOpenedBladeComponent = bladeComponent;
-        }
-      }
-    }
-
-    if (lastOpenedBladeComponent.name && String(lastOpenedBladeComponent.name) === String(to.name)) {
-      return undefined;
-    }
-
-    const finalTargetRoute = routerUtils.allRoutes.find((r) => String(r.name) === String(to.name));
-    if (finalTargetRoute && bladeState.blades.value.some((b) => b.type === finalTargetRoute.components?.default)) {
-      return undefined;
-    }
-
-    return undefined;
-  }
-  return routeResolver;
-}

package/shared/components/blade-navigation/composables/useBladeNavigation/internal/bladeState.ts

@@ -1,127 +0,0 @@
-import { computed, shallowRef, Ref, toValue } from "vue";
-import type { Router } from "vue-router";
-import { DisplayableError, parseError } from "../../../../../../core/utilities/error";
-import type { BladeVNode } from "../../../types";
-
-// --- Blade State Management Module ---
-export function _createBladeStateManagement(router: Router) {
-  const blades: Ref<BladeVNode[]> = shallowRef<BladeVNode[]>([]);
-  const activeWorkspace: Ref<BladeVNode | undefined> = shallowRef<BladeVNode | undefined>();
-
-  async function removeBladesStartingFrom(startIndex: number): Promise<boolean> {
-    if (blades.value.length === 0 || startIndex < 0) {
-      return false;
-    }
-
-    try {
-      const bladesToClose = blades.value.slice(startIndex).reverse();
-      let isPrevented = false;
-
-      for (const blade of bladesToClose) {
-        if (blade.props?.navigation?.onBeforeClose) {
-          const result = await blade.props.navigation.onBeforeClose();
-          if (result === false) {
-            isPrevented = true;
-            break; // Stop further checks if one blade prevents closing
-          }
-        }
-      }
-
-      if (!isPrevented) {
-        const prevBlade = blades.value[startIndex - 1];
-
-        if (startIndex > 0 && prevBlade?.props?.navigation?.isVisible === false) {
-          prevBlade.props.navigation.isVisible = true;
-        }
-
-        // Clear param of table blade when closing child blade to prevent table row selection from being preserved
-        if (
-          prevBlade &&
-          prevBlade.props?.navigation?.idx === 0 && // Is a workspace or first blade
-          toValue(prevBlade.props?.param) === toValue(blades.value[startIndex]?.props?.param)
-        ) {
-          prevBlade.props.param = undefined;
-        }
-        // Clear error of the parent blade if it was displaying an error related to the closing child
-        if (prevBlade?.props?.navigation?.error?.value && startIndex > 0) {
-          const childBladeName = blades.value[startIndex]?.type?.name;
-          if (childBladeName && prevBlade.props.navigation.error.value.message.includes(childBladeName)) {
-            prevBlade.props.navigation.error.value = null;
-          }
-        }
-
-        blades.value.splice(startIndex);
-        blades.value = [...blades.value]; // Trigger reactivity for watchers
-      }
-      return isPrevented;
-    } finally {
-      // Cleanup completed
-    }
-  }
-
-  function addBlade(bladeNode: BladeVNode): void {
-    if (bladeNode.props.navigation) {
-      bladeNode.props.navigation.error = shallowRef(null);
-    }
-    blades.value.push(bladeNode);
-    blades.value = [...blades.value];
-  }
-
-  function replaceAllBlades(newBlades: BladeVNode[]): void {
-    newBlades.forEach((b) => {
-      if (b.props.navigation) {
-        b.props.navigation.error = shallowRef(null);
-      }
-    });
-    blades.value = newBlades;
-  }
-
-  function setActiveWorkspaceBlade(workspaceBlade?: BladeVNode): void {
-    if (workspaceBlade && workspaceBlade.props?.navigation) {
-      workspaceBlade.props.navigation.idx = 0;
-      workspaceBlade.props.navigation.error = shallowRef(null);
-    }
-    activeWorkspace.value = workspaceBlade;
-    if (workspaceBlade) {
-      blades.value = [workspaceBlade];
-      // Ensure subsequent blades are closed if workspace changes directly
-      removeBladesStartingFrom(1);
-    } else {
-      blades.value = [];
-    }
-  }
-
-  function clearActiveWorkspaceState(): void {
-    activeWorkspace.value = undefined;
-    blades.value = [];
-  }
-
-  function setBladeError(bladeIdx: number, error: unknown): void {
-    if (blades.value[bladeIdx] && blades.value[bladeIdx].props.navigation) {
-      const parsed = parseError(error);
-      (blades.value[bladeIdx].props.navigation as { error: Ref<DisplayableError | null> }).error = shallowRef(parsed);
-      blades.value = [...blades.value]; // Trigger reactivity
-    }
-  }
-
-  function clearBladeError(bladeIdx: number): void {
-    if (blades.value[bladeIdx] && blades.value[bladeIdx].props.navigation) {
-      blades.value[bladeIdx].props.navigation.error = shallowRef(null);
-      blades.value = [...blades.value]; // Trigger reactivity
-    }
-  }
-
-  return {
-    blades: computed(() => blades.value), // Expose as computed for readonly reactive access outside
-    _bladesRef: blades, // Internal ref for mutation
-    activeWorkspace: computed(() => activeWorkspace.value),
-    _activeWorkspaceRef: activeWorkspace,
-    removeBladesStartingFrom,
-    addBlade,
-    replaceAllBlades,
-    setActiveWorkspaceBlade,
-    clearActiveWorkspaceState,
-    setBladeError,
-    clearBladeError,
-  };
-}

package/shared/components/blade-navigation/composables/useBladeNavigation/internal/bladeWatchers.ts

@@ -1,96 +0,0 @@
-import { watch, isVNode } from "vue";
-import { watchDebounced } from "@vueuse/core";
-import * as _ from "lodash-es";
-import { RouteLocationNormalized, Router } from "vue-router";
-import { useAppInsights } from "../../../../../../core/composables";
-import type { BladeVNode } from "../../../types";
-import type { _createBladeStateManagement } from "./bladeState";
-import type { _createRouterUtils } from "./routerUtils";
-
-// --- Watchers Module ---
-export function _createBladeWatchers(
-  router: Router,
-  route: RouteLocationNormalized,
-  bladeState: ReturnType<typeof _createBladeStateManagement>,
-  routerUtils: ReturnType<typeof _createRouterUtils>,
-  setupPageTracking: ReturnType<typeof useAppInsights>["setupPageTracking"],
-) {
-  watch(
-    () => route.path,
-    async (newPath, oldPath) => {
-      const newWorkspaceUrlSegment = routerUtils.parseWorkspaceUrlPath(newPath);
-      const currentActiveWorkspaceUrl = bladeState.activeWorkspace.value?.type.url;
-
-      if (newWorkspaceUrlSegment && newWorkspaceUrlSegment !== currentActiveWorkspaceUrl) {
-        const wsRouteComponent =
-          routerUtils.getResolvedRouteComponent(newWorkspaceUrlSegment) ||
-          (router.resolve({ path: newWorkspaceUrlSegment }).matched?.[1]?.components?.default as BladeVNode);
-
-        if (wsRouteComponent && isVNode(wsRouteComponent) && wsRouteComponent.type.isBlade) {
-          const isPrevented = await bladeState.removeBladesStartingFrom(0);
-          if (!isPrevented) {
-            bladeState.setActiveWorkspaceBlade(wsRouteComponent);
-          } else {
-            if (oldPath && oldPath !== newPath) router.push({ path: oldPath });
-          }
-        } else {
-          const isPrevented = await bladeState.removeBladesStartingFrom(0);
-          if (!isPrevented) {
-            bladeState.clearActiveWorkspaceState();
-          } else {
-            if (oldPath && oldPath !== newPath) router.push({ path: oldPath });
-          }
-        }
-      } else if (!newWorkspaceUrlSegment && bladeState.activeWorkspace.value) {
-        const isPrevented = await bladeState.removeBladesStartingFrom(0);
-        if (!isPrevented) {
-          bladeState.clearActiveWorkspaceState();
-        } else {
-          if (oldPath && oldPath !== newPath) router.push({ path: oldPath });
-        }
-      }
-    },
-    { immediate: true },
-  );
-
-  watchDebounced(
-    bladeState.blades,
-    (newBlades) => {
-      const workspace = newBlades[0];
-
-      const visibleBladesWithUrls = newBlades.filter(
-        (b): b is BladeVNode => !!(b && b.type && b.type.url && b.props?.navigation?.isVisible !== false),
-      );
-      const lastBladeWithUrl: BladeVNode | undefined =
-        visibleBladesWithUrls.length > 0 ? visibleBladesWithUrls[visibleBladesWithUrls.length - 1] : undefined;
-
-      if (workspace?.type?.url) {
-        const constructedPath = routerUtils.constructBladePath(workspace, lastBladeWithUrl);
-
-        if (constructedPath) {
-          const query = routerUtils.getURLQuery();
-          const pathPrefix =
-            routerUtils.mainRouteBaseParamURL.value &&
-            !constructedPath.startsWith(routerUtils.mainRouteBaseParamURL.value)
-              ? routerUtils.mainRouteBaseParamURL.value
-              : "";
-          const querySuffix = query.params ? "?" + query.params : "";
-
-          const finalFullPathToSet = pathPrefix + constructedPath + querySuffix;
-
-          router.options.history.replace(finalFullPathToSet);
-
-          if (lastBladeWithUrl && lastBladeWithUrl.type.name) {
-            setupPageTracking.afterEach({
-              name: lastBladeWithUrl.type.name!,
-              fullPath: finalFullPathToSet,
-            });
-          } else if (workspace.type.name) {
-            setupPageTracking.afterEach({ name: workspace.type.name, fullPath: finalFullPathToSet });
-          }
-        }
-      }
-    },
-    { deep: true, debounce: 10, flush: "post" },
-  );
-}

package/shared/components/blade-navigation/composables/useBladeNavigation/internal/routerUtils.ts

@@ -1,150 +0,0 @@
-import { computed, shallowRef, Ref, markRaw, watch } from "vue";
-import { RouteLocationNormalized, Router, LocationQuery, RouteRecordNameGeneric, RouteParamsGeneric } from "vue-router";
-import type { BladeVNode } from "../../../types";
-
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-
-// --- Router and URL Utilities Module ---
-export function _createRouterUtils(router: Router, route: RouteLocationNormalized) {
-  const mainRouteBaseParamURL: Ref<string | undefined> = shallowRef<string>();
-  const routes = markRaw(router.getRoutes());
-
-  function _updateMainRouteBaseParamURL() {
-    const firstParamValue = Object.values(route.params)?.[0] ?? "";
-    mainRouteBaseParamURL.value = "/" + firstParamValue;
-  }
-  // Initial calculation
-  _updateMainRouteBaseParamURL();
-  // Update when route params change, as this might affect the base URL
-  watch(() => route.params, _updateMainRouteBaseParamURL, { deep: true });
-
-  function parseUrlParams(
-    url: string,
-    currentRouteParams: RouteParamsGeneric,
-  ): { workspace?: string; blade?: string; param?: string } | undefined {
-    let pathSegments = url.split("/").filter(Boolean);
-
-    const firstParamFromCurrentRoute = Object.values(currentRouteParams)?.[0];
-    let basePathFromCurrentRoute: string | undefined;
-
-    if (typeof firstParamFromCurrentRoute === "string" && firstParamFromCurrentRoute) {
-      basePathFromCurrentRoute = "/" + firstParamFromCurrentRoute;
-    }
-
-    // If the URL starts with the determined base path (like a UUID tenant ID from currentRouteParams),
-    // we should parse the segments *after* it for workspace, blade, param.
-    if (basePathFromCurrentRoute && basePathFromCurrentRoute !== "/" && url.startsWith(basePathFromCurrentRoute)) {
-      const baseSegmentsCount = basePathFromCurrentRoute.split("/").filter(Boolean).length;
-      pathSegments = pathSegments.slice(baseSegmentsCount);
-    }
-    // Now, pathSegments should contain parts of the URL after the base parameter,
-    // e.g., ["workspace-name", "blade-name", "item-id"] or ["workspace-name"], etc.
-
-    if (pathSegments.length === 0) {
-      // This means the path was likely just the base parameter itself (e.g., "/some-uuid/")
-      // or an empty path "/".
-      // parseUrlParams returns undefined for workspace, blade, param in this case.
-      // routeResolver will handle this, typically by navigating to a default workspace or root.
-      return { workspace: undefined, blade: undefined, param: undefined };
-    }
-
-    // The first segment after the base is potentially the workspace.
-    // The second is potentially the blade.
-    // The third is potentially the param.
-    // Validation of these segments against actual components happens later in routeResolver.
-    const workspace = pathSegments[0];
-    const blade = pathSegments[1];
-    const param = pathSegments[2];
-
-    return { workspace, blade, param };
-  }
-
-  function parseWorkspaceUrlPath(path: string): string {
-    _updateMainRouteBaseParamURL(); // Ensure base URL is current
-    const pathWithoutBase = path.startsWith(mainRouteBaseParamURL.value || "###") // Use unlikely string if base is undefined
-      ? path.slice((mainRouteBaseParamURL.value || "").length)
-      : path;
-    const segments = pathWithoutBase.split("/").filter(Boolean);
-    const workspaceUrl = segments.slice(0, 1).join("/");
-    return "/" + workspaceUrl;
-  }
-
-  function getURLQuery(): { params: string; obj: LocationQuery } {
-    if (route.query && Object.keys(route.query).length) {
-      return {
-        params: new URLSearchParams(route.query as Record<string, string>).toString(),
-        obj: route.query,
-      };
-    }
-    // Fallback for scenarios where route.query might not be populated (e.g., initial load before router is fully ready)
-    const hash = window.location.hash || "#";
-    const queryPart = hash.split("?")[1] || "";
-    const params = new URLSearchParams(queryPart).toString();
-    return { params, obj: Object.fromEntries(new URLSearchParams(queryPart)) };
-  }
-
-  function constructBladePath(workspace: BladeVNode, lastBlade?: BladeVNode): string | undefined {
-    const wsBladeUrl = workspace?.type.url;
-
-    if (!wsBladeUrl) {
-      return undefined;
-    }
-
-    // Normalize workspace URL (e.g., "products" -> "/products")
-    // Ensure basePath starts with a slash and does not end with one (unless it's just "/")
-    let basePath = wsBladeUrl.startsWith("/") ? wsBladeUrl : "/" + wsBladeUrl;
-    if (basePath.endsWith("/") && basePath.length > 1) {
-      basePath = basePath.slice(0, -1);
-    }
-
-    if (lastBlade && lastBlade.type.url && lastBlade.type.url !== wsBladeUrl) {
-      // This is a child blade different from the workspace
-      let childPathSegment = lastBlade.type.url;
-      const param = lastBlade.props?.param;
-
-      // Normalize childPathSegment (e.g., "details" -> "/details")
-      if (!childPathSegment.startsWith("/")) {
-        childPathSegment = "/" + childPathSegment;
-      }
-
-      let fullPath = basePath + childPathSegment;
-
-      if (param) {
-        fullPath += "/" + String(param);
-      }
-      return fullPath;
-    } else {
-      // This is just the workspace, or lastBlade is the workspace itself, or lastBlade has no distinct URL.
-      // The param should be taken from lastBlade if it's the one defining the current end of the path,
-      // otherwise from the workspace's own props.
-      const param = lastBlade ? lastBlade.props?.param : workspace.props?.param;
-      if (param) {
-        return basePath + "/" + String(param);
-      }
-      return basePath;
-    }
-  }
-
-  function getResolvedRouteComponent(path: string): BladeVNode | undefined {
-    return router.resolve({ path })?.matched?.[1]?.components?.default as BladeVNode | undefined;
-  }
-
-  return {
-    mainRouteBaseParamURL: computed(() => mainRouteBaseParamURL.value),
-    parseUrlParams,
-    parseWorkspaceUrlPath,
-    getURLQuery,
-    constructBladePath,
-    getResolvedRouteComponent,
-    allRoutes: routes,
-    goToRoot: () => {
-      const mainRoute = routes.find((r) => r.meta?.root);
-      const mainRouteAlias = routes.find((r) => r.aliasOf?.path === mainRoute?.path) || mainRoute;
-      if (mainRouteAlias?.name) {
-        return { name: mainRouteAlias.name as RouteRecordNameGeneric, params: route.params as RouteParamsGeneric };
-      }
-      console.error("goToRoot: Main route or its alias with a name not found!");
-      return { path: "/" };
-    },
-  };
-}

package/shared/components/blade-navigation/plugin.ts

@@ -1,40 +0,0 @@
-import { Router } from "vue-router";
-import { App, ref } from "vue";
-import * as components from "./components";
-import { BladeNavigationPlugin } from "./types";
-
-// Declare globally
-declare module "@vue/runtime-core" {
-  export interface GlobalComponents {
-    VcBladeNavigation: (typeof components)["VcBladeNavigation"];
-  }
-}
-
-export let bladeNavigationInstance: BladeNavigationPlugin;
-
-export const VcBladeNavigationComponent = {
-  install(app: App, args: { router: Router }) {
-    // Register framework's own blade UI components like VcBladeNavigation
-    Object.entries(components).forEach(([componentName, component]) => {
-      app.component(componentName, component);
-    });
-
-    // The plugin instance primarily provides the router.
-    // Blade resolution is now handled by useBladeNavigation via useBladeRegistry.
-    const bladeNavigationPluginData: BladeNavigationPlugin = {
-      router: args.router,
-      // blades: ref([]), // This state was for useBladeNavigation, it should manage its own state internally or via its singleton.
-      // If blades ref is truly global and shared, it needs careful consideration.
-      // For now, assuming blade state management is within useBladeNavigationSingleton.
-    };
-
-    // This global instance is used as a fallback in useBladeNavigation.
-    // It should contain at least what useBladeNavigation might try to access from it.
-    // Primarily, the router.
-    bladeNavigationInstance = bladeNavigationPluginData;
-
-    // Provide the plugin instance (mainly for the router) for useBladeNavigation to inject.
-    // useBladeNavigation can then also useBladeRegistry() independently.
-    app.provide("bladeNavigationPlugin", bladeNavigationPluginData);
-  },
-};