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

package/core/composables/useBladeRegistry/index.ts

@@ -1,5 +1,8 @@
 import { App, inject, shallowRef, computed, ComputedRef, readonly as vueReadonly } from "vue";
 import { BladeInstanceConstructor } from "../../../shared/components/blade-navigation/types";
+import { createLogger } from "../../utilities";
+
+const logger = createLogger("blade-registry");
 
 /**
  * Interface for blade registration data
@@ -8,6 +11,7 @@ export interface IBladeRegistrationData {
   component: BladeInstanceConstructor;
   route?: string;
   isWorkspace?: boolean;
+  routable?: boolean;
   // ... other metadata
 }
 
@@ -26,13 +30,15 @@ export interface IBladeRegistry {
   getBlade: (name: string) => IBladeRegistrationData | undefined;
   /** Get blade component by name */
   getBladeComponent: (name: string) => BladeInstanceConstructor | undefined;
+  /** Reverse lookup: find blade name + data by URL route segment (O(1)) */
+  getBladeByRoute: (route: string) => { name: string; data: IBladeRegistrationData } | undefined;
 }
 
 /**
  * Extended interface for blade registry instance with internal registration function
  */
 export interface IBladeRegistryInstance extends IBladeRegistry {
-  _registerBladeFn: (name: string, registrationData: IBladeRegistrationData) => void;
+  _registerBladeFn: (name: string, registrationData: IBladeRegistrationData, allowOverwrite?: boolean) => void;
 }
 
 /**
@@ -58,13 +64,29 @@ function isValidBladeComponent(component: unknown): component is BladeInstanceCo
 export function createBladeRegistry(app: App): IBladeRegistryInstance {
   const registeredBladesInternal = shallowRef<Map<string, IBladeRegistrationData>>(new Map());
 
+  // Reverse index: normalized route → blade name (rebuilt on every registration)
+  const _routeIndex = new Map<string, string>();
+
+  function _normalizeRoute(route: string): string {
+    return route.startsWith("/") ? route : `/${route}`;
+  }
+
   /**
    * Registers a blade component in the registry
    *
    * @param name - Unique name for the blade
    * @param registrationData - Blade registration data including component and metadata
    */
-  function registerBlade(name: string, registrationData: IBladeRegistrationData): void {
+  /**
+   * Registers a blade component in the registry.
+   *
+   * @param name - Unique name for the blade
+   * @param registrationData - Blade registration data including component and metadata
+   * @param allowOverwrite - If true, allows overwriting an existing blade (default: false).
+   *   Use for dynamic module hot-reload scenarios only.
+   * @throws Error if blade name is already registered and allowOverwrite is false
+   */
+  function registerBlade(name: string, registrationData: IBladeRegistrationData, allowOverwrite = false): void {
     if (!name || typeof name !== "string") {
       throw new Error("BladeRegistry: Blade name must be a non-empty string");
     }
@@ -81,15 +103,24 @@ export function createBladeRegistry(app: App): IBladeRegistryInstance {
     const newMap = new Map(registeredBladesInternal.value);
 
     if (newMap.has(name)) {
-      console.warn(`BladeRegistry: Blade '${name}' is already registered. It will be overwritten.`);
+      if (!allowOverwrite) {
+        throw new Error(
+          `BladeRegistry: Blade '${name}' is already registered. ` +
+            `Use allowOverwrite=true if intentional (e.g. dynamic module hot-reload).`,
+        );
+      }
+      logger.warn(`Blade '${name}' is already registered. Overwriting (allowOverwrite=true).`);
     }
 
     // Register component globally if not already registered or different
     const existingGlobalComponent = app.component(name);
     if (!existingGlobalComponent || existingGlobalComponent !== registrationData.component) {
       if (existingGlobalComponent && existingGlobalComponent !== registrationData.component) {
-        console.warn(
-          `BladeRegistry: Global component '${name}' already exists and is different. Overwriting with new blade component.`,
+        logger.warn(
+          `Global component '${name}' already exists and is different. Overwriting with new blade component.`,
+        );
+        logger.warn(
+          `Global component '${name}' already exists and is different. Overwriting with new blade component.`,
         );
       }
       app.component(name, registrationData.component);
@@ -97,6 +128,11 @@ export function createBladeRegistry(app: App): IBladeRegistryInstance {
 
     newMap.set(name, registrationData);
     registeredBladesInternal.value = newMap;
+
+    // Maintain reverse route index
+    if (registrationData.route) {
+      _routeIndex.set(_normalizeRoute(registrationData.route), name);
+    }
   }
 
   /**
@@ -137,12 +173,30 @@ export function createBladeRegistry(app: App): IBladeRegistryInstance {
         return globalComponent;
       }
     } catch (error) {
-      console.warn(`BladeRegistry: Error accessing global component '${name}':`, error);
+      logger.warn(`Error accessing global component '${name}':`, error);
+      logger.warn(`Error accessing global component '${name}':`, error);
     }
 
     return undefined;
   }
 
+  /**
+   * Reverse lookup: find a blade by its URL route segment.
+   * Uses O(1) index maintained during registration.
+   *
+   * @param route - URL segment (e.g. "orders" or "/orders")
+   * @returns Blade name and registration data, or undefined if not found
+   */
+  function getBladeByRoute(route: string): { name: string; data: IBladeRegistrationData } | undefined {
+    if (!route) return undefined;
+    const normalized = _normalizeRoute(route);
+    const name = _routeIndex.get(normalized);
+    if (!name) return undefined;
+    const data = registeredBladesInternal.value.get(name);
+    if (!data) return undefined;
+    return { name, data };
+  }
+
   // Cache the readonly map to avoid recreating it on every access
   const readonlyBladesMap = computed(() => vueReadonly(registeredBladesInternal.value));
 
@@ -150,6 +204,7 @@ export function createBladeRegistry(app: App): IBladeRegistryInstance {
     registeredBladesMap: readonlyBladesMap,
     getBlade,
     getBladeComponent,
+    getBladeByRoute,
   };
 
   return {

package/core/composables/useBreadcrumbs/index.ts

@@ -1,6 +1,9 @@
 import { Breadcrumbs } from "./../../../ui/types/index";
 import { ComputedRef, computed, reactive, toValue } from "vue";
 import * as _ from "lodash-es";
+import { createLogger } from "../../utilities";
+
+const logger = createLogger("use-breadcrumbs");
 
 interface HistoryRecord {
   records: Breadcrumbs[];
@@ -45,7 +48,7 @@ export function useBreadcrumbs() {
               removeNext(id);
             }
           } catch (e) {
-            console.error(e);
+            logger.error("Breadcrumb click handler failed:", e);
           }
         }
       },

package/core/composables/useDashboard/index.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { defineComponent, h, inject } from "vue";
+import { mount } from "@vue/test-utils";
+import { DashboardServiceKey } from "../../../injection-keys";
+import { provideDashboardService, useDashboard } from "./index";
+import { createDashboardService } from "../../services/dashboard-service";
+
+describe("useDashboard", () => {
+  it("throws InjectionError when no service is provided", () => {
+    const TestComp = defineComponent({
+      setup() {
+        expect(() => useDashboard()).toThrow("DashboardService");
+        return () => h("div");
+      },
+    });
+
+    mount(TestComp);
+  });
+
+  it("returns injected service", () => {
+    const service = createDashboardService();
+
+    const TestComp = defineComponent({
+      setup() {
+        const result = useDashboard();
+        expect(result).toBe(service);
+        return () => h("div");
+      },
+    });
+
+    mount(TestComp, {
+      global: {
+        provide: { [DashboardServiceKey as symbol]: service },
+      },
+    });
+  });
+});
+
+describe("provideDashboardService", () => {
+  it("creates and provides a service", () => {
+    let providedService: any;
+    let injectedService: any;
+
+    const Parent = defineComponent({
+      setup() {
+        providedService = provideDashboardService();
+        return () => h(Child);
+      },
+    });
+
+    const Child = defineComponent({
+      setup() {
+        injectedService = inject(DashboardServiceKey);
+        return () => h("div");
+      },
+    });
+
+    mount(Parent);
+
+    expect(providedService).toBeDefined();
+    expect(injectedService).toBe(providedService);
+  });
+
+  it("is idempotent — returns existing service if already provided", () => {
+    let firstResult: any;
+    let secondResult: any;
+
+    const GrandParent = defineComponent({
+      setup() {
+        firstResult = provideDashboardService();
+        return () => h(Parent);
+      },
+    });
+
+    const Parent = defineComponent({
+      setup() {
+        secondResult = provideDashboardService();
+        return () => h("div");
+      },
+    });
+
+    mount(GrandParent);
+
+    expect(firstResult).toBe(secondResult);
+  });
+});

package/core/composables/useDashboard/index.ts

@@ -1,17 +1,49 @@
-import { createDashboardService, IDashboardService, registerDashboardWidget } from "../../services/dashboard-service";
-import { provide, inject } from "vue";
+import {
+  createDashboardService,
+  IDashboardService,
+  registerDashboardWidget,
+  dashboardBus,
+} from "../../services/dashboard-service";
+import { provide, inject, getCurrentScope, onScopeDispose } from "vue";
 import { DashboardServiceKey } from "../../../injection-keys";
+import { usePermissions } from "../usePermissions";
+import { createLogger, InjectionError } from "../../utilities";
+
+const logger = createLogger("use-dashboard");
 
 export function provideDashboardService(): IDashboardService {
-  const service = createDashboardService();
+  const existingService = inject(DashboardServiceKey, null);
+  if (existingService) {
+    return existingService;
+  }
+
+  let hasAccessResolver: (permissions: string[] | undefined) => boolean = () => true;
+
+  try {
+    const { hasAccess } = usePermissions();
+    hasAccessResolver = (permissions) => hasAccess(permissions);
+  } catch (error) {
+    logger.warn("Permissions composable unavailable, dashboard falls back to allow-all access check", error);
+  }
+
+  const service = createDashboardService({
+    hasAccess: hasAccessResolver,
+  });
+
   provide(DashboardServiceKey, service);
+
+  if (getCurrentScope()) {
+    onScopeDispose(() => dashboardBus.dispose(service));
+  }
+
   return service;
 }
 
 export function useDashboard(): IDashboardService {
   const service = inject(DashboardServiceKey);
   if (!service) {
-    throw new Error("DashboardService not provided");
+    logger.error("Dashboard service not found");
+    throw new InjectionError("DashboardService");
   }
   return service;
 }

package/core/composables/useErrorHandler/index.ts

@@ -2,6 +2,9 @@ import { onErrorCaptured, getCurrentInstance, ref, Ref, nextTick } from "vue";
 import { useAppInsights } from "..";
 import { useUserManagement } from "../useUserManagement";
 import { DisplayableError, parseError } from "../../utilities/error";
+import { createLogger } from "../../utilities";
+
+const logger = createLogger("use-error-handler");
 
 interface IUseErrorHandler {
   error: Ref<DisplayableError | null>;
@@ -51,7 +54,7 @@ export function useErrorHandler(capture?: boolean): IUseErrorHandler {
       });
     }
 
-    console.error("Captured Error:", capturedError.originalError);
+    logger.error("Captured Error:", capturedError.originalError);
 
     if (instance) {
       instance.emit("error", capturedError);

package/core/composables/useFunctions/debounce.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export default function debounce(func: (...args: any[]) => void, delay: number): (...args: unknown[]) => void {
-  console.debug(`[@vc-shell/framework#useFunctions:debounce] - Entry point`);
   let timer: number | null = null;
 
   return function (...args: unknown[]): void {

package/core/composables/useFunctions/delay.ts

@@ -1,4 +1,3 @@
 export default function delay(func: (...args: unknown[]) => void, delay = 0): void {
-  console.debug(`[@vc-shell/framework#useFunctions:delay] - Entry point`);
   setTimeout(func, delay);
 }

package/core/composables/useFunctions/index.ts

@@ -11,7 +11,6 @@ interface IUseFunctions {
 }
 
 export function useFunctions(): IUseFunctions {
-  console.debug("useFunctions entry point");
   return {
     debounce,
     delay,

package/core/composables/useFunctions/once.ts

@@ -1,7 +1,6 @@
 const resultsMap = new WeakMap();
 
 export default function once(func: (...args: unknown[]) => void): (...args: unknown[]) => unknown {
-  console.debug(`[@vc-shell/framework#useFunctions:once] - Entry point`);
   return function (...args: unknown[]): unknown {
     if (!resultsMap.has(func)) {
       const result = func(...args);

package/core/composables/useFunctions/sleep.ts

@@ -1,4 +1,3 @@
 export default function sleep(ms: number): Promise<void> {
-  console.debug(`[@vc-shell/framework#useFunctions:sleep] - Entry point`);
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/core/composables/useFunctions/throttle.ts

@@ -1,5 +1,4 @@
 export default function throttle(func: (...args: unknown[]) => void, delay: number): (...args: unknown[]) => void {
-  console.debug(`[@vc-shell/framework#useFunctions:throttle] - Entry point`);
   let wasThrottled = false;
 
   return function (...args: unknown[]): void {

package/core/composables/useGlobalSearch/index.ts

@@ -1,18 +1,27 @@
 import { inject, provide } from "vue";
 import { GlobalSearchKey } from "../../../injection-keys";
 import { GlobalSearchState, createGlobalSearchService } from "../../services/global-search-service";
+import { createLogger, InjectionError } from "../../utilities";
+
+const logger = createLogger("use-global-search");
+
+export function provideGlobalSearch(): GlobalSearchState {
+  const existingState = inject(GlobalSearchKey, null);
+  if (existingState) {
+    return existingState;
+  }
 
-export function provideGlobalSearch() {
   const state = createGlobalSearchService();
   provide(GlobalSearchKey, state);
   return state;
 }
 
-export function useGlobalSearch() {
+export function useGlobalSearch(): GlobalSearchState {
   const state = inject<GlobalSearchState>(GlobalSearchKey);
 
   if (!state) {
-    throw new Error("useGlobalSearch must be used within a component that has called createGlobalSearch");
+    logger.error("Global search service not found");
+    throw new InjectionError("GlobalSearchService");
   }
 
   return state;

package/core/composables/useLanguages/index.ts

@@ -1,21 +1,47 @@
-import { inject, provide } from "vue";
+import { hasInjectionContext, inject, provide } from "vue";
 import { LanguageServiceKey } from "../../../injection-keys";
 import { ILanguageService, createLanguageService } from "../../services/language-service";
+import { createLogger, InjectionError } from "../../utilities";
+
+const logger = createLogger("use-languages");
+let fallbackLanguageService: ILanguageService | null = null;
 
 export interface IUseLanguages extends ILanguageService {}
 
+function getOrCreateFallbackLanguageService(): ILanguageService {
+  if (!fallbackLanguageService) {
+    fallbackLanguageService = createLanguageService();
+  }
+
+  return fallbackLanguageService;
+}
+
 export function provideLanguages(): ILanguageService {
+  if (!hasInjectionContext()) {
+    logger.warn("No injection context for provideLanguages; using fallback language service");
+    return getOrCreateFallbackLanguageService();
+  }
+
+  const existingService = inject(LanguageServiceKey, null);
+  if (existingService) {
+    return existingService;
+  }
+
   const service = createLanguageService();
   provide(LanguageServiceKey, service);
   return service;
 }
 
 export function useLanguages(): IUseLanguages {
-  let languageService = inject(LanguageServiceKey);
+  if (!hasInjectionContext()) {
+    return getOrCreateFallbackLanguageService();
+  }
+
+  const languageService = inject(LanguageServiceKey, null);
 
   if (!languageService) {
-    languageService = provideLanguages();
-    // throw new Error("Language service not found. Make sure the framework is properly initialized.");
+    logger.error("Language service not found");
+    throw new InjectionError("LanguageService");
   }
 
   return languageService;

package/core/composables/useMenuService/index.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { defineComponent, h, inject } from "vue";
+import { mount } from "@vue/test-utils";
+import { MenuServiceKey } from "../../../injection-keys";
+import { provideMenuService, useMenuService } from "./index";
+import { createMenuService } from "../../services/menu-service";
+
+describe("useMenuService", () => {
+  it("throws InjectionError when no service is provided", () => {
+    const TestComp = defineComponent({
+      setup() {
+        expect(() => useMenuService()).toThrow("MenuService");
+        return () => h("div");
+      },
+    });
+
+    mount(TestComp);
+  });
+
+  it("returns injected service", () => {
+    const service = createMenuService();
+
+    const TestComp = defineComponent({
+      setup() {
+        const result = useMenuService();
+        expect(result).toBe(service);
+        return () => h("div");
+      },
+    });
+
+    mount(TestComp, {
+      global: {
+        provide: { [MenuServiceKey as symbol]: service },
+      },
+    });
+  });
+});
+
+describe("provideMenuService", () => {
+  it("creates and provides a service", () => {
+    let providedService: any;
+    let injectedService: any;
+
+    const Parent = defineComponent({
+      setup() {
+        providedService = provideMenuService();
+        return () => h(Child);
+      },
+    });
+
+    const Child = defineComponent({
+      setup() {
+        injectedService = inject(MenuServiceKey);
+        return () => h("div");
+      },
+    });
+
+    mount(Parent);
+
+    expect(providedService).toBeDefined();
+    expect(injectedService).toBe(providedService);
+  });
+
+  it("is idempotent — returns existing service if already provided", () => {
+    let firstResult: any;
+    let secondResult: any;
+
+    const GrandParent = defineComponent({
+      setup() {
+        firstResult = provideMenuService();
+        return () => h(Parent);
+      },
+    });
+
+    const Parent = defineComponent({
+      setup() {
+        secondResult = provideMenuService();
+        return () => h("div");
+      },
+    });
+
+    mount(GrandParent);
+
+    expect(firstResult).toBe(secondResult);
+  });
+});

package/core/composables/useMenuService/index.ts

@@ -1,4 +1,4 @@
-import { provide, inject, getCurrentInstance } from "vue";
+import { provide, inject, getCurrentInstance, getCurrentScope, onScopeDispose } from "vue";
 import {
   MenuService,
   createMenuService,
@@ -7,20 +7,34 @@ import {
   getMenuBadge,
   removeMenuBadge,
   getMenuBadges,
+  menuServiceBus,
 } from "../../services/menu-service";
 import { MenuServiceKey } from "../../../injection-keys";
+import { createLogger, InjectionError } from "../../utilities";
+
+const logger = createLogger("use-menu-service");
 
 export function provideMenuService(): MenuService {
+  const existingService = inject(MenuServiceKey, null);
+  if (existingService) {
+    return existingService;
+  }
+
   const service = createMenuService();
   provide(MenuServiceKey, service);
+
+  if (getCurrentScope()) {
+    onScopeDispose(() => menuServiceBus.dispose(service));
+  }
+
   return service;
 }
 
 export function useMenuService(): MenuService {
   const service = inject(MenuServiceKey);
   if (!service) {
-    console.error("Menu service not found in current context. Injection chain:", getCurrentInstance());
-    throw new Error("MenuService not provided");
+    logger.error("Menu service not found in current context. Injection chain:", getCurrentInstance());
+    throw new InjectionError("MenuService");
   }
   return service;
 }

package/core/composables/useNotifications/index.ts

@@ -1,6 +1,9 @@
 import { PushNotification, PushNotificationClient } from "./../../api/platform";
 import { computed, ComputedRef, ref, onUnmounted } from "vue";
 import * as _ from "lodash-es";
+import { createLogger } from "../../utilities";
+
+const logger = createLogger("use-notifications");
 
 const notificationsClient = new PushNotificationClient();
 
@@ -64,7 +67,7 @@ export function useNotifications(notifyType?: string | string[]): INotifications
         notifications.value = <PushNotification[]>JSON.parse(response).notifyEvents ?? [];
       });
     } catch (e) {
-      console.error(e);
+      logger.error("loadFromHistory failed:", e);
       throw e;
     }
   }
@@ -121,7 +124,7 @@ export function useNotifications(notifyType?: string | string[]): INotifications
       });
       await notificationsClient.markAllAsRead();
     } catch (e) {
-      console.error(e);
+      logger.error("markAllAsRead failed:", e);
       throw e;
     }
   }