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

package/shared/components/blade-navigation/components/vc-blade-navigation/vc-blade-navigation.vue

@@ -1,165 +0,0 @@
-<template>
-  <div class="tw-w-full tw-flex tw-flex-col tw-grow tw-basis-0">
-    <render></render>
-  </div>
-</template>
-
-<script lang="ts" setup>
-import { Ref, computed, inject, withDirectives, h, vShow, toRef, VNode, nextTick, provide } from "vue";
-import { RouterView, useRoute } from "vue-router";
-import { BladeVNode, IParentCallArgs, useBladeNavigation } from "./../../../../../shared";
-import { ErrorInterceptor } from "./../../../error-interceptor";
-import { useBreadcrumbs } from "./../../../../../core/composables/useBreadcrumbs";
-import { VcBladeView } from "./../vc-blade-view/vc-blade-view";
-import { watchDebounced } from "@vueuse/core";
-import VcMobileBackButton from "./_internal/vc-mobile-back-button.vue";
-
-const { blades, closeBlade, onParentCall, clearBladeError } = useBladeNavigation();
-const { breadcrumbs, push, remove } = useBreadcrumbs();
-const route = useRoute();
-
-const quantity = computed(() => {
-  return (
-    blades.value.filter((x) => x.props.navigation.isVisible || typeof x.props.navigation.isVisible === "undefined")
-      .length || 0
-  );
-});
-
-const isMobile = inject("isMobile") as Ref<boolean>;
-
-watchDebounced(
-  blades,
-  (newVal) => {
-    breadcrumbs.value.forEach((breadcrumb) => breadcrumb && remove([breadcrumb.id]));
-
-    newVal.forEach((blade) => {
-      push({
-        id: blade.props.navigation.idx.toString(),
-        title: toRef(blade.props.navigation.instance ?? { title: "" }, "title"),
-        clickHandler: async (id) => {
-          if (blade.props.navigation.isVisible === false) {
-            blade.props.navigation.isVisible = true;
-          }
-          const isPrevented = await closeBlade(parseInt(id) + 1);
-          return !isPrevented;
-        },
-      });
-    });
-  },
-  {
-    deep: true,
-    immediate: true,
-    flush: "post",
-    debounce: 10,
-  },
-);
-
-const render = () => {
-  if (!(route.matched[1]?.components?.default as BladeVNode)?.type?.isBlade) {
-    return h(RouterView);
-  }
-
-  return h("div", { class: "tw-w-full tw-overflow-hidden tw-flex tw-grow tw-basis-0 tw-relative" }, [
-    blades.value?.reduce(
-      (arr, bladeVNode, index) => {
-        if (bladeVNode.type.isBlade) {
-          const hiddenQuantity = blades.value.filter(
-            (x) => x.props.navigation.isVisible === false && x.props.navigation.idx < index,
-          ).length;
-
-          const filteredBreadcrumbs = breadcrumbs.value.slice(0, index);
-          arr.push(
-            h(
-              ErrorInterceptor,
-              {
-                key: index,
-                capture: true,
-              },
-              {
-                default: ({
-                  error: interceptorError,
-                  reset: resetInterceptor,
-                }: Parameters<InstanceType<typeof ErrorInterceptor>["$slots"]["default"]>["0"]) => {
-                  const bladeNavigation = bladeVNode.props.navigation;
-                  const activeError = computed(() => interceptorError || bladeNavigation.error?.value);
-                  const handleResetError = () => {
-                    if (interceptorError) {
-                      resetInterceptor();
-                    }
-                    if (bladeNavigation.error?.value) {
-                      clearBladeError(bladeNavigation.idx);
-                    }
-                  };
-
-                  return withDirectives(
-                    h(
-                      VcBladeView,
-                      {
-                        key: `${bladeVNode.type?.name}_${index}` || `blade_${index}`,
-                        blade: bladeVNode,
-                        expandable: quantity.value > 1,
-                        error: activeError.value,
-                        "onReset:error": handleResetError,
-                        breadcrumbs: filteredBreadcrumbs,
-                        backButton:
-                          quantity.value > 1
-                            ? h(VcMobileBackButton, {
-                                breadcrumbs: filteredBreadcrumbs,
-                                onBack: () => {
-                                  closeBlade(index);
-                                },
-                              })
-                            : undefined,
-                      },
-                      {
-                        default: ({ Component }: { Component: BladeVNode }) => {
-                          return h(Component, {
-                            closable: index >= 1,
-                            expanded: index - hiddenQuantity === quantity.value - 1,
-                            "onClose:blade": () => {
-                              if (index === 0) return;
-                              closeBlade(index);
-                            },
-                            "onParent:call": async (args: IParentCallArgs) => {
-                              await nextTick(async () => {
-                                // Use the centralized onParentCall with the current blade index
-                                await onParentCall(args, index);
-                              });
-                            },
-                            onVnodeUnmounted: resetInterceptor,
-                          });
-                        },
-                      },
-                    ),
-
-                    [
-                      [
-                        vShow,
-                        (bladeVNode.props.navigation.isVisible ||
-                          typeof bladeVNode.props.navigation.isVisible === "undefined") &&
-                          index >= quantity.value - (isMobile.value ? 1 : 2),
-                      ],
-                    ],
-                  );
-                },
-              },
-            ),
-          );
-        }
-
-        return arr;
-      },
-      [] as unknown as VNode[],
-    ),
-  ]);
-};
-</script>
-
-<style lang="scss">
-:root {
-  --blade-navigation-bg-color: var(--additional-50);
-  --blade-navigation-shadow-color: var(--additional-950);
-  --blade-navigation-shadow: 2px 2px 8px rgb(from var(--blade-navigation-shadow-color) r g b / 7%);
-  --blade-navigation-border-radius: var(--blade-border-radius);
-}
-</style>

package/shared/components/blade-navigation/composables/useBladeNavigation/index.ts

@@ -1,334 +0,0 @@
-import { computed, getCurrentInstance, inject, warn, Component, ComputedRef, Ref, shallowRef, unref } from "vue";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { createSharedComposable } from "@vueuse/core";
-import * as _ from "lodash-es";
-import { RouteLocationNormalized, useRoute, NavigationFailure, RouteLocationRaw } from "vue-router";
-import { bladeNavigationInstance as globalBladeNavigationPluginInstanceFallback } from "../../plugin";
-import { useBladeRegistry, IBladeRegistry } from "../../../../../core/composables/useBladeRegistry";
-import {
-  BladeComponentInternalInstance,
-  BladeNavigationPlugin,
-  BladeVNode,
-  IBladeEvent,
-  IParentCallArgs,
-  BladeInstanceConstructor,
-  CoreBladeAdditionalSettings,
-} from "../../types";
-import { navigationViewLocation } from "../../../../../injection-keys";
-import { useAppInsights, usePermissions } from "../../../../../core/composables";
-import { notification as notificationService } from "./../../../notifications";
-import "core-js/actual/array/find-last";
-import "core-js/actual/array/find-last-index";
-import { i18n } from "../../../../../core/plugins/i18n";
-
-// Internal modules
-import { _createBladeStateManagement } from "./internal/bladeState";
-import { _createRouterUtils } from "./internal/routerUtils";
-import { _createBladeActions } from "./internal/bladeActions";
-import { _createBladeRouteResolver } from "./internal/bladeRouteResolver";
-import { _createBladeWatchers } from "./internal/bladeWatchers";
-
-interface IUseBladeNavigation {
-  readonly blades: ComputedRef<BladeVNode[]>;
-  readonly activeWorkspace: ComputedRef<BladeVNode | undefined>;
-  readonly currentBladeNavigationData: ComputedRef<BladeVNode["props"]["navigation"] | undefined>;
-  openBlade: <Blade extends Component>(
-    args: IBladeEvent<Blade>,
-    isWorkspace?: boolean,
-  ) => Promise<void | NavigationFailure>;
-  closeBlade: (index: number) => Promise<boolean>;
-  goToRoot: () => RouteLocationRaw;
-  onParentCall: (args: IParentCallArgs, currentBladeIndex?: number) => void;
-  onBeforeClose: (cb: () => Promise<boolean | undefined>) => void;
-  resolveBladeByName: (name: string) => BladeInstanceConstructor | undefined;
-  routeResolver: (to: RouteLocationNormalized) => Promise<RouteLocationRaw | undefined> | RouteLocationRaw | undefined;
-  setNavigationQuery: (query: Record<string, string | number>) => void;
-  getNavigationQuery: () => Record<string, string | number> | undefined;
-
-  // TODO: add to docs
-  setBladeError: (bladeIdx: number, error: unknown) => void;
-  clearBladeError: (bladeIdx: number) => void;
-}
-
-// --- Singleton for useBladeNavigation ---
-const useBladeNavigationSingleton = createSharedComposable(() => {
-  const route = useRoute();
-  const injectedPlugin = inject<BladeNavigationPlugin>("bladeNavigationPlugin");
-  const router = injectedPlugin?.router || globalBladeNavigationPluginInstanceFallback.router;
-
-  if (!router) {
-    throw new Error("[@vc-shell/framework#useBladeNavigation] Vue Router instance is not available.");
-  }
-
-  const bladeRegistry: IBladeRegistry = useBladeRegistry();
-
-  // Base modules initialization
-  const bladeState = _createBladeStateManagement(router);
-  const routerUtils = _createRouterUtils(router, route);
-
-  const { setupPageTracking } = useAppInsights();
-  const { hasAccess } = usePermissions();
-  const currentInstance = getCurrentInstance() as BladeComponentInternalInstance | null;
-
-  function ensureBladeComponent<Blade extends Component>(
-    bladeInput: BladeInstanceConstructor<Blade> | { name: string } | null | undefined,
-  ): BladeInstanceConstructor<Blade> {
-    if (!bladeInput) {
-      throw new Error("ensureBladeComponent: bladeInput cannot be null or undefined.");
-    }
-    if (typeof bladeInput === "object" && "name" in bladeInput) {
-      if (!bladeInput.name) {
-        throw new Error("ensureBladeComponent: bladeInput.name cannot be empty when resolving by name.");
-      }
-      const resolvedComponent = bladeRegistry.getBladeComponent(bladeInput.name);
-      if (!resolvedComponent) {
-        throw new Error(
-          `ensureBladeComponent: Failed to resolve blade by name '${bladeInput.name}' via BladeRegistry. Blade component not registered or plugin issue.`,
-        );
-      }
-      return resolvedComponent as BladeInstanceConstructor<Blade>;
-    }
-    return bladeInput as BladeInstanceConstructor<Blade>;
-  }
-
-  const bladeActions = _createBladeActions(
-    router,
-    route,
-    bladeState,
-    routerUtils,
-    ensureBladeComponent,
-    hasAccess,
-    notificationService,
-    i18n,
-    setupPageTracking,
-  );
-
-  const routeResolverInstance = _createBladeRouteResolver(
-    router,
-    route,
-    bladeRegistry,
-    routerUtils,
-    bladeActions,
-    bladeState,
-    ensureBladeComponent,
-    hasAccess,
-  );
-
-  _createBladeWatchers(router, route, bladeState, routerUtils, setupPageTracking);
-
-  return {
-    blades: bladeState.blades,
-    activeWorkspace: bladeState.activeWorkspace,
-    _internal_openBlade: bladeActions.openBlade,
-    closeBlade: bladeState.removeBladesStartingFrom,
-    goToRoot: routerUtils.goToRoot,
-    routeResolver: routeResolverInstance,
-    setBladeError: bladeState.setBladeError,
-    clearBladeError: bladeState.clearBladeError,
-    onBeforeClose: (cb: () => Promise<boolean | undefined>) => {
-      const targetBlade = bladeState.activeWorkspace.value;
-      if (targetBlade && targetBlade.props.navigation) {
-        targetBlade.props.navigation.onBeforeClose = cb;
-      } else {
-        warn("Singleton onBeforeClose: Could not identify a target blade (e.g., active workspace).");
-      }
-    },
-    setNavigationQuery: (query: Record<string, string | number>) => {
-      if (!currentInstance) {
-        warn("Singleton's setNavigationQuery called in a context without a component instance.");
-        return;
-      }
-      const typeName = (currentInstance.vnode.type as CoreBladeAdditionalSettings).name?.toLowerCase();
-      if (
-        typeName &&
-        bladeState.activeWorkspace.value &&
-        bladeState.activeWorkspace.value.props.navigation?.idx === 0
-      ) {
-        const namedQuery = _.mapKeys(_.mapValues(query, String), (v, k) => `${typeName}_${k}`);
-        const cleanQuery = _.omitBy(namedQuery, _.isNil);
-        router.options.history.replace(
-          decodeURIComponent(
-            `${window.location.hash.substring(1).split("?")[0]}?${new URLSearchParams(cleanQuery).toString()}`,
-          ),
-        );
-      }
-    },
-    getNavigationQuery: () => {
-      if (!currentInstance) {
-        warn("Singleton's getNavigationQuery called in a context without a component instance.");
-        return undefined;
-      }
-      const typeName = (currentInstance.vnode.type as CoreBladeAdditionalSettings).name?.toLowerCase();
-      if (
-        typeName &&
-        bladeState.activeWorkspace.value &&
-        bladeState.activeWorkspace.value.props.navigation?.idx === 0
-      ) {
-        const queryKeys = Object.keys(route.query);
-        const bladeQueryKeys = queryKeys.filter((key) => key.startsWith(typeName));
-        const namedQuery = _.mapKeys(_.pick(route.query, bladeQueryKeys), (v, k) => k.replace(`${typeName}_`, ""));
-
-        const result: Record<string, string | number> = {};
-        for (const [key, value] of Object.entries(namedQuery)) {
-          const numValue = Number(value);
-          result[key] = isNaN(numValue) ? (value as string) : numValue;
-        }
-        return result;
-      }
-      return undefined;
-    },
-    currentBladeNavigationData: computed(() => {
-      return bladeState.activeWorkspace.value?.props?.navigation ?? undefined;
-    }),
-  };
-});
-
-export function useBladeNavigation(): IUseBladeNavigation {
-  const singleton = useBladeNavigationSingleton() as typeof useBladeNavigationSingleton extends () => infer R
-    ? R
-    : never;
-  const currentCallingInstance = getCurrentInstance() as BladeComponentInternalInstance | null;
-  const bladeRegistry = useBladeRegistry();
-
-  // Find the closest parent blade in the component hierarchy
-  const findParentBlade = (instance: BladeComponentInternalInstance | null): BladeVNode | undefined => {
-    if (!instance) return undefined;
-
-    // Check if current instance provides navigationViewLocation
-    const viewNode = (instance as any).provides[navigationViewLocation as any] as BladeVNode | undefined;
-    if (viewNode) {
-      return viewNode;
-    }
-
-    // Check if current instance is a blade itself
-    if (
-      instance.vnode &&
-      singleton.activeWorkspace.value &&
-      _.isEqual(instance.vnode.type, singleton.activeWorkspace.value.type)
-    ) {
-      return singleton.activeWorkspace.value;
-    }
-
-    // Check if current instance is in the blades list
-    const matchingBlade = singleton.blades.value.find(
-      (blade) => blade && instance.vnode && _.isEqual(blade.type, instance.vnode.type),
-    );
-    if (matchingBlade) {
-      return matchingBlade;
-    }
-
-    // Recursively check parent instance
-    return findParentBlade(instance.parent as BladeComponentInternalInstance | null);
-  };
-
-  const currentBladeNavigationData = computed(() => {
-    const parentBlade = findParentBlade(currentCallingInstance);
-    return parentBlade?.props?.navigation;
-  });
-
-  const onBeforeClose = (cb: () => Promise<boolean | undefined>) => {
-    if (!currentCallingInstance) {
-      warn("onBeforeClose called outside of a component setup context.");
-      return;
-    }
-    const parentBlade = findParentBlade(currentCallingInstance);
-    if (parentBlade && parentBlade.props.navigation) {
-      parentBlade.props.navigation.onBeforeClose = cb;
-    } else {
-      warn("Context-specific onBeforeClose: Could not identify the target blade in the global list.");
-    }
-  };
-
-  const onParentCall = async (args: IParentCallArgs, currentBladeIndex?: number) => {
-    let bladeIndex = currentBladeIndex;
-
-    // If currentBladeIndex is not provided, try to find it from the component hierarchy
-    if (bladeIndex === undefined) {
-      if (!currentCallingInstance) {
-        warn("onParentCall called outside of a component setup context and without currentBladeIndex.");
-        return;
-      }
-
-      // Find current blade in the blades list
-      const currentBlade = findParentBlade(currentCallingInstance);
-      if (!currentBlade) {
-        console.error("onParentCall: Could not identify current blade in the global list.");
-        return;
-      }
-
-      bladeIndex = currentBlade.props.navigation?.idx ?? -1;
-    }
-
-    if (bladeIndex <= 0) {
-      console.error("onParentCall: Current blade is workspace (index 0) or invalid, no parent blade available.");
-      return;
-    }
-
-    // Find parent blade (blade with index bladeIndex - 1)
-    const parentBlade = singleton.blades.value.find((blade) => blade && blade.props.navigation?.idx === bladeIndex - 1);
-
-    if (!parentBlade) {
-      console.error(`onParentCall: Parent blade with index ${bladeIndex - 1} not found.`);
-      return;
-    }
-
-    const parentExposedMethods = parentBlade.props.navigation?.instance;
-
-    if (!parentExposedMethods) {
-      console.error("onParentCall: Parent blade has no exposed methods (navigation.instance is undefined).");
-      return;
-    }
-
-    // Try to get the method from exposed methods with Vue refs handling
-    const targetMethod = parentExposedMethods[args.method];
-
-    if (args.method && typeof targetMethod === "function") {
-      const result = await targetMethod(args.args);
-      if (typeof args.callback === "function") args.callback(result);
-    } else {
-      console.error(
-        `onParentCall: Method '${args.method}' is not available or not a function in parent blade '${parentBlade.type?.name}'.`,
-      );
-      console.error("Available properties:", Object.keys(parentExposedMethods));
-      console.error(`Requested method '${args.method}' type:`, typeof targetMethod);
-      console.error(`Requested method '${args.method}' value:`, targetMethod);
-      console.error(
-        `Please ensure that the method '${args.method}' is defined and exposed using defineExpose() in the parent blade component.`,
-      );
-    }
-  };
-
-  return {
-    blades: singleton.blades,
-    activeWorkspace: singleton.activeWorkspace,
-    openBlade: <Blade extends Component>(
-      args: IBladeEvent<Blade>,
-      isWorkspace?: boolean,
-    ): Promise<void | NavigationFailure> => {
-      // Find the closest parent blade in the component hierarchy
-      let sourceBladeInstanceForOpening: BladeVNode | undefined = findParentBlade(currentCallingInstance);
-
-      if (!sourceBladeInstanceForOpening) {
-        sourceBladeInstanceForOpening = singleton.activeWorkspace.value;
-      }
-
-      if (typeof singleton._internal_openBlade === "function") {
-        return singleton._internal_openBlade(args, isWorkspace, sourceBladeInstanceForOpening);
-      } else {
-        console.error("Internal _internal_openBlade method not found on singleton.");
-        return Promise.reject(new Error("Blade navigation internal error."));
-      }
-    },
-    closeBlade: singleton.closeBlade,
-    goToRoot: singleton.goToRoot,
-    onParentCall,
-    resolveBladeByName: (name: string) => bladeRegistry.getBladeComponent(name),
-    routeResolver: singleton.routeResolver,
-    currentBladeNavigationData,
-    onBeforeClose,
-    setNavigationQuery: singleton.setNavigationQuery,
-    getNavigationQuery: singleton.getNavigationQuery,
-    setBladeError: singleton.setBladeError,
-    clearBladeError: singleton.clearBladeError,
-  };
-}

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

@@ -1,151 +0,0 @@
-import { h, Component, isVNode } from "vue";
-import { reactifyObject, reactiveComputed } from "@vueuse/core";
-import * as _ from "lodash-es";
-import { RouteLocationNormalized, Router, LocationQuery, NavigationFailure, RouteParams } from "vue-router";
-import { useAppInsights } from "../../../../../../core/composables";
-import { i18n } from "../../../../../../core/plugins/i18n";
-import type { notification as NotificationServiceType } from "../../../../notifications";
-import type { BladeVNode, IBladeEvent, BladeInstanceConstructor } from "../../../types";
-import type { _createBladeStateManagement } from "./bladeState";
-import type { _createRouterUtils } from "./routerUtils";
-
-// --- Blade Actions Module ---
-export function _createBladeActions(
-  router: Router,
-  route: RouteLocationNormalized,
-  bladeState: ReturnType<typeof _createBladeStateManagement>,
-  routerUtils: ReturnType<typeof _createRouterUtils>,
-  ensureBladeComponent: <Blade extends Component>(
-    bladeInput: BladeInstanceConstructor<Blade> | { name: string } | null | undefined,
-  ) => BladeInstanceConstructor<Blade>,
-  hasAccess: (permissions?: string | string[]) => boolean,
-  notificationServiceInstance: typeof NotificationServiceType,
-  i18nInstance: typeof i18n,
-  setupPageTrackingInstance: ReturnType<typeof useAppInsights>["setupPageTracking"],
-) {
-  async function openWorkspace<Blade extends Component>(
-    { blade: bladeInput, param, options }: IBladeEvent<Blade>,
-    query: LocationQuery | undefined = undefined,
-    routeParams: RouteParams = {},
-    replace = false,
-  ): Promise<NavigationFailure | void> {
-    const bladeComponent = ensureBladeComponent(bladeInput);
-    const componentProps = reactifyObject({
-      param,
-      options,
-      navigation: { idx: 0 },
-    });
-    const createdComponent = h(bladeComponent, componentProps) as BladeVNode;
-
-    try {
-      const isPrevented = await bladeState.removeBladesStartingFrom(0);
-      if (isPrevented) {
-        return;
-      }
-
-      if (createdComponent.type?.url) {
-        if (hasAccess(bladeComponent.permissions)) {
-          if (bladeState.blades.value.length > 0 && bladeState.blades.value[0].type.url === createdComponent.type.url) {
-            return;
-          }
-          bladeState.setActiveWorkspaceBlade(createdComponent);
-
-          const targetRoute = routerUtils.allRoutes.find((r) => r.path.endsWith(createdComponent.type?.url as string));
-          if (targetRoute && targetRoute.components) {
-            (targetRoute.components as Record<string, Component | BladeVNode>).default = createdComponent;
-          }
-
-          return router.push({
-            name: targetRoute?.name,
-            params: { ...routeParams, ...route.params },
-            query,
-            replace,
-          });
-        } else {
-          notificationServiceInstance.error(i18nInstance.global.t("PERMISSION_MESSAGES.ACCESS_RESTRICTED"), {
-            timeout: 3000,
-          });
-        }
-      }
-    } catch (e) {
-      console.error(e);
-      const bladeNameForError =
-        bladeComponent?.type?.name ||
-        (typeof bladeInput === "object" && "name" in bladeInput ? bladeInput.name : "Unknown");
-      throw new Error(`Opening workspace '${bladeNameForError}' is prevented or failed.`);
-    }
-  }
-
-  async function openBlade<Blade extends Component>(
-    args: IBladeEvent<Blade>,
-    isWorkspaceTarget = false,
-    sourceBladeInstance?: BladeVNode,
-  ): Promise<void | NavigationFailure> {
-    const { blade: bladeInput, param, options, onOpen, onClose, replaceCurrentBlade = false } = args;
-    const bladeComponent = ensureBladeComponent(bladeInput);
-
-    if (isWorkspaceTarget) {
-      return openWorkspace({ blade: bladeComponent, param, options });
-    }
-
-    try {
-      const instanceComponent = sourceBladeInstance || bladeState.activeWorkspace.value;
-
-      if (!instanceComponent) {
-        console.error("No active workspace or source blade instance provided to open a blade into.");
-        throw new Error("No workspace or source blade context to open blade.");
-      }
-      if (!isVNode(instanceComponent)) {
-        console.error("Source blade instance or active workspace is not a valid VNode.", instanceComponent);
-        throw new Error("Internal error: Invalid instanceComponent for opening blade.");
-      }
-
-      const instanceComponentIndex = _.findLastIndex(bladeState.blades.value, (x): x is BladeVNode => {
-        if (!x) return false;
-        return _.isEqual(x.type, instanceComponent.type);
-      });
-
-      const parentBladeIndex = instanceComponentIndex >= 0 ? instanceComponentIndex : -1;
-      const childBladeIndex = parentBladeIndex + 1;
-
-      let isPrevented = false;
-      if (bladeState.blades.value[childBladeIndex]) {
-        isPrevented = await bladeState.removeBladesStartingFrom(childBladeIndex);
-      }
-
-      const currentBladeIdx = parentBladeIndex;
-
-      const bladeNode = h(
-        bladeComponent,
-        Object.assign(
-          {},
-          reactiveComputed(() => ({ options, param })),
-          { navigation: { onOpen, onClose, idx: currentBladeIdx + 1, isVisible: true } },
-        ),
-      ) as BladeVNode;
-
-      if (!isPrevented) {
-        if (hasAccess(bladeComponent.permissions)) {
-          if (replaceCurrentBlade && currentBladeIdx >= 0 && bladeState.blades.value[currentBladeIdx]) {
-            if (bladeState.blades.value[currentBladeIdx]) {
-              bladeState.blades.value[currentBladeIdx].props.navigation.isVisible = false;
-            }
-          }
-          setupPageTrackingInstance.beforeEach({ name: bladeNode.type.name! });
-          bladeState.addBlade(bladeNode);
-        } else {
-          notificationServiceInstance.error(i18nInstance.global.t("PERMISSION_MESSAGES.ACCESS_RESTRICTED"), {
-            timeout: 3000,
-          });
-        }
-      }
-    } catch (e) {
-      console.error("Error in openBlade:", e);
-    }
-  }
-
-  return {
-    openWorkspace,
-    openBlade,
-  };
-}