@vc-shell/framework 1.2.4-beta.8 → 2.0.0-alpha.0

package/core/services/toolbar-service.ts

@@ -1,111 +0,0 @@
-import type { IBladeToolbar } from "@core/types";
-import { createBladeScopedRegistry, createPreregistrationBus } from "@core/services/_internal";
-
-export interface IToolbarItem extends IBladeToolbar {
-  id: string;
-  bladeId?: string;
-  priority?: number;
-}
-
-export interface IToolbarRegistration {
-  bladeId: string;
-  toolbarItem: IToolbarItem;
-}
-
-export interface IToolbarService {
-  registerToolbarItem: (toolbarItem: IToolbarItem, bladeId: string) => void;
-  unregisterToolbarItem: (toolbarItemId: string, bladeId: string) => void;
-  getToolbarItems: (bladeId: string) => IToolbarItem[];
-  clearBladeToolbarItems: (bladeId: string) => void;
-  registeredToolbarItems: IToolbarRegistration[];
-  isToolbarItemRegistered: (id: string) => boolean;
-  updateToolbarItem: ({
-    id,
-    bladeId,
-    toolbarItem,
-  }: {
-    id: string;
-    bladeId: string;
-    toolbarItem: Partial<IToolbarItem>;
-  }) => void;
-}
-
-export const toolbarBus = createPreregistrationBus<IToolbarRegistration, IToolbarService>({
-  name: "toolbar-service",
-  getKey: (reg) => `${reg.bladeId.toLowerCase()}::${reg.toolbarItem.id}`,
-  registerIntoService: (service, reg) => service.registerToolbarItem(reg.toolbarItem, reg.bladeId),
-});
-
-/**
- * Registers a toolbar button before the service is initialized.
- */
-export function registerToolbarItem(toolbarItem: IToolbarItem, bladeId: string): void {
-  const normalizedBladeId = bladeId.toLowerCase();
-  toolbarBus.preregister({
-    bladeId: normalizedBladeId,
-    toolbarItem,
-  });
-}
-
-export function createToolbarService(): IToolbarService {
-  const bladeRegistry = createBladeScopedRegistry<IToolbarItem, IToolbarRegistration>({
-    createRegistration: (bladeId, item) => ({ bladeId, toolbarItem: item }),
-    getRegistrationBladeId: (r) => r.bladeId,
-    getRegistrationItemId: (r) => r.toolbarItem.id,
-  });
-
-  const registerToolbarItem = (toolbarItem: IToolbarItem, bladeId: string): void => {
-    bladeRegistry.register(toolbarItem, bladeId);
-  };
-
-  const unregisterToolbarItem = (toolbarItemId: string, bladeId: string): void => {
-    bladeRegistry.unregister(toolbarItemId, bladeId);
-  };
-
-  const getToolbarItems = (bladeId: string): IToolbarItem[] => {
-    const normalizedBladeId = bladeId ? bladeId.toLowerCase() : "";
-    const bladeItems = bladeRegistry.get(normalizedBladeId);
-    const globalItems = bladeRegistry.get("*");
-
-    const result: IToolbarItem[] = [...bladeItems];
-    const existingIds = new Set(result.map((item) => item.id));
-
-    globalItems.forEach((item) => {
-      if (!existingIds.has(item.id)) {
-        result.push(item);
-      }
-    });
-
-    return [...result];
-  };
-
-  const clearBladeToolbarItems = (bladeId: string): void => {
-    bladeRegistry.clear(bladeId);
-  };
-
-  const updateToolbarItem = ({
-    id,
-    bladeId,
-    toolbarItem,
-  }: {
-    id: string;
-    bladeId: string;
-    toolbarItem: Partial<IToolbarItem>;
-  }): void => {
-    bladeRegistry.update(id, bladeId, toolbarItem);
-  };
-
-  const service: IToolbarService = {
-    registerToolbarItem,
-    unregisterToolbarItem,
-    getToolbarItems,
-    clearBladeToolbarItems,
-    registeredToolbarItems: bladeRegistry.registrations,
-    isToolbarItemRegistered: (id) => bladeRegistry.isRegistered(id),
-    updateToolbarItem,
-  };
-
-  toolbarBus.replayInto(service);
-
-  return service;
-}

package/core/services/toolbar-widget-service.test.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-async function loadToolbarServiceModule() {
-  vi.resetModules();
-  return import("@core/services/toolbar-service");
-}
-
-async function loadWidgetServiceModule() {
-  vi.resetModules();
-  return import("@core/services/widget-service");
-}
-
-describe("toolbar-service", () => {
-  it("keeps registration flag true while the same id is still registered in another blade", async () => {
-    const { createToolbarService } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    service.registerToolbarItem({ id: "duplicate" } as any, "blade-a");
-    service.registerToolbarItem({ id: "duplicate" } as any, "blade-b");
-
-    service.unregisterToolbarItem("duplicate", "blade-a");
-
-    expect(service.getToolbarItems("blade-b")).toHaveLength(1);
-    expect(service.isToolbarItemRegistered("duplicate")).toBe(true);
-  });
-
-  it("registers and retrieves toolbar items by blade", async () => {
-    const { createToolbarService } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    service.registerToolbarItem({ id: "btn-1", title: "Save" } as any, "blade-1");
-    service.registerToolbarItem({ id: "btn-2", title: "Delete" } as any, "blade-1");
-
-    const items = service.getToolbarItems("blade-1");
-    expect(items).toHaveLength(2);
-    expect(items.map((i) => i.id)).toEqual(["btn-1", "btn-2"]);
-  });
-
-  it("merges global * items into blade-specific items", async () => {
-    const { createToolbarService } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    service.registerToolbarItem({ id: "global-btn" } as any, "*");
-    service.registerToolbarItem({ id: "blade-btn" } as any, "blade-1");
-
-    const items = service.getToolbarItems("blade-1");
-    expect(items).toHaveLength(2);
-    expect(items.map((i) => i.id)).toContain("global-btn");
-    expect(items.map((i) => i.id)).toContain("blade-btn");
-  });
-
-  it("does not duplicate global items when blade has same id", async () => {
-    const { createToolbarService } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    service.registerToolbarItem({ id: "shared" } as any, "*");
-    service.registerToolbarItem({ id: "shared" } as any, "blade-1");
-
-    expect(service.getToolbarItems("blade-1")).toHaveLength(1);
-  });
-
-  it("clears all items for a blade", async () => {
-    const { createToolbarService } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    service.registerToolbarItem({ id: "a" } as any, "blade-1");
-    service.registerToolbarItem({ id: "b" } as any, "blade-1");
-    service.registerToolbarItem({ id: "c" } as any, "blade-2");
-
-    service.clearBladeToolbarItems("blade-1");
-
-    expect(service.getToolbarItems("blade-1")).toHaveLength(0);
-    expect(service.getToolbarItems("blade-2")).toHaveLength(1);
-    expect(service.isToolbarItemRegistered("a")).toBe(false);
-  });
-
-  it("updates a toolbar item in-place", async () => {
-    const { createToolbarService } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    service.registerToolbarItem({ id: "btn", title: "Old" } as any, "blade-1");
-    service.updateToolbarItem({ id: "btn", bladeId: "blade-1", toolbarItem: { title: "New" } as any });
-
-    const items = service.getToolbarItems("blade-1");
-    expect(items[0].title).toBe("New");
-  });
-
-  it("preregistration deduplicates by bladeId::itemId key", async () => {
-    const { registerToolbarItem, createToolbarService } = await loadToolbarServiceModule();
-
-    registerToolbarItem({ id: "pre", title: "V1" } as any, "blade-1");
-    registerToolbarItem({ id: "pre", title: "V2" } as any, "blade-1");
-
-    const service = createToolbarService();
-    const items = service.getToolbarItems("blade-1");
-    expect(items).toHaveLength(1);
-    expect(items[0].title).toBe("V2");
-  });
-
-  it("disposes service instance via bus", async () => {
-    const { createToolbarService, toolbarBus } = await loadToolbarServiceModule();
-    const service = createToolbarService();
-
-    expect(toolbarBus.instanceCount).toBe(1);
-    toolbarBus.dispose(service);
-    expect(toolbarBus.instanceCount).toBe(0);
-  });
-});
-
-describe("widget-service", () => {
-  it("keeps registration flag true while the same id is still registered in another blade", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    service.registerWidget({ id: "duplicate", component: {} as any }, "blade-a");
-    service.registerWidget({ id: "duplicate", component: {} as any }, "blade-b");
-
-    service.unregisterWidget("duplicate", "blade-a");
-
-    expect(service.getWidgets("blade-b")).toHaveLength(1);
-    expect(service.isWidgetRegistered("duplicate")).toBe(true);
-  });
-
-  it("returns a copy from getWidgets to prevent external mutations", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    service.registerWidget({ id: "widget-1", component: {} as any }, "blade-a");
-
-    const widgets = service.getWidgets("blade-a");
-    widgets.push({ id: "fake", component: {} as any });
-
-    expect(service.getWidgets("blade-a")).toHaveLength(1);
-  });
-
-  it("registers and retrieves widgets by blade", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    service.registerWidget({ id: "w1", component: {} as any }, "blade-1");
-    service.registerWidget({ id: "w2", component: {} as any }, "blade-1");
-
-    expect(service.getWidgets("blade-1")).toHaveLength(2);
-    expect(service.getWidgets("blade-2")).toHaveLength(0);
-  });
-
-  it("clears all widgets for a blade", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    service.registerWidget({ id: "w1", component: {} as any }, "blade-1");
-    service.registerWidget({ id: "w2", component: {} as any }, "blade-1");
-    service.clearBladeWidgets("blade-1");
-
-    expect(service.getWidgets("blade-1")).toHaveLength(0);
-    expect(service.isWidgetRegistered("w1")).toBe(false);
-  });
-
-  it("updates a widget in-place", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    service.registerWidget({ id: "w1", component: {} as any, title: "Old" }, "blade-1");
-    service.updateWidget({ id: "w1", bladeId: "blade-1", widget: { title: "New" } });
-
-    expect(service.getWidgets("blade-1")[0].title).toBe("New");
-  });
-
-  it("resolves widget props from blade data", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    const widget = {
-      id: "w1",
-      component: {} as any,
-      config: {
-        requiredData: ["userId"],
-        optionalData: ["role"],
-        fieldMapping: { userId: "currentUserId" },
-      },
-    };
-
-    const props = service.resolveWidgetProps(widget, { currentUserId: "42", role: "admin" });
-    expect(props).toEqual({ userId: "42", role: "admin" });
-  });
-
-  it("preregistration deduplicates by bladeId::widgetId key", async () => {
-    const { registerWidget, createWidgetService } = await loadWidgetServiceModule();
-
-    registerWidget({ id: "pre", component: {} as any, title: "V1" }, "blade-1");
-    registerWidget({ id: "pre", component: {} as any, title: "V2" }, "blade-1");
-
-    const service = createWidgetService();
-    const widgets = service.getWidgets("blade-1");
-    expect(widgets).toHaveLength(1);
-    expect(widgets[0].title).toBe("V2");
-  });
-
-  it("disposes service instance via bus", async () => {
-    const { createWidgetService, widgetBus } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    expect(widgetBus.instanceCount).toBe(1);
-    widgetBus.dispose(service);
-    expect(widgetBus.instanceCount).toBe(0);
-  });
-});

package/core/services/widget-service.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-async function loadWidgetServiceModule() {
-  vi.resetModules();
-  return import("@core/services/widget-service");
-}
-
-describe("widget-service: trigger contract", () => {
-  it("accepts a widget with trigger and stores it", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    const onRefresh = vi.fn();
-    const onClick = vi.fn();
-
-    service.registerWidget(
-      {
-        id: "trigger-widget",
-        component: {} as any,
-        title: "Test",
-        trigger: {
-          icon: "lucide-box",
-          title: "Test Widget",
-          onRefresh,
-          onClick,
-        },
-      },
-      "blade-1",
-    );
-
-    const widgets = service.getWidgets("blade-1");
-    expect(widgets).toHaveLength(1);
-    expect(widgets[0].trigger).toBeDefined();
-    expect(widgets[0].trigger?.icon).toBe("lucide-box");
-  });
-});
-
-describe("widget-service: setActiveWidget", () => {
-  it("accepts trigger-only call (no exposed)", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    // Should not throw when called without exposed
-    service.setActiveWidget({ widgetId: "my-widget" });
-    expect(service.isActiveWidget("my-widget")).toBe(true);
-  });
-
-  it("accepts legacy call with exposed", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    const exposed = { updateActiveWidgetCount: vi.fn() };
-    service.setActiveWidget({ widgetId: "legacy-widget", exposed });
-    expect(service.isActiveWidget("legacy-widget")).toBe(true);
-  });
-});
-
-describe("widget-service: updateActiveWidget", () => {
-  it("calls trigger.onRefresh when available (priority over exposed)", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    const onRefresh = vi.fn();
-    const exposedFn = vi.fn();
-
-    service.registerWidget(
-      {
-        id: "hybrid-widget",
-        component: {} as any,
-        updateFunctionName: "refresh",
-        trigger: { onRefresh },
-      },
-      "blade-1",
-    );
-
-    // Set active with exposed that also has the function
-    service.setActiveWidget({
-      widgetId: "hybrid-widget",
-      exposed: { refresh: exposedFn },
-    });
-
-    service.updateActiveWidget();
-
-    expect(onRefresh).toHaveBeenCalledOnce();
-    expect(exposedFn).not.toHaveBeenCalled();
-  });
-
-  it("falls back to exposed when no trigger.onRefresh", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    const exposedFn = vi.fn();
-
-    service.registerWidget(
-      {
-        id: "legacy-widget",
-        component: {} as any,
-        updateFunctionName: "updateCount",
-      },
-      "blade-1",
-    );
-
-    service.setActiveWidget({
-      widgetId: "legacy-widget",
-      exposed: { updateCount: exposedFn },
-    });
-
-    service.updateActiveWidget();
-
-    expect(exposedFn).toHaveBeenCalledOnce();
-  });
-
-  it("works with trigger-only (no exposed at all)", async () => {
-    const { createWidgetService } = await loadWidgetServiceModule();
-    const service = createWidgetService();
-
-    const onRefresh = vi.fn();
-
-    service.registerWidget(
-      {
-        id: "trigger-only",
-        component: {} as any,
-        trigger: { onRefresh },
-      },
-      "blade-1",
-    );
-
-    service.setActiveWidget({ widgetId: "trigger-only" });
-    service.updateActiveWidget();
-
-    expect(onRefresh).toHaveBeenCalledOnce();
-  });
-});