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

package/core/services/_internal/createPreregistrationBus.test.ts

@@ -1,227 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createPreregistrationBus, type PreregistrationBus } from "@core/services/_internal/createPreregistrationBus";
-
-interface TestItem {
-  id: string;
-  value: number;
-}
-
-interface TestService {
-  items: TestItem[];
-  register(item: TestItem): void;
-  unregister?(id: string): void;
-}
-
-function createTestService(): TestService {
-  const items: TestItem[] = [];
-  return {
-    items,
-    register(item: TestItem) {
-      items.push(item);
-    },
-  };
-}
-
-function createTestBus(): PreregistrationBus<TestItem, TestService> {
-  return createPreregistrationBus<TestItem, TestService>({
-    name: "test",
-    getKey: (item) => item.id,
-    registerIntoService: (service, item) => service.register(item),
-  });
-}
-
-describe("createPreregistrationBus", () => {
-  let bus: PreregistrationBus<TestItem, TestService>;
-
-  beforeEach(() => {
-    bus = createTestBus();
-  });
-
-  it("stores preregistered items before any service exists", () => {
-    bus.preregister({ id: "a", value: 1 });
-    bus.preregister({ id: "b", value: 2 });
-
-    expect(bus.getPreregistered()).toHaveLength(2);
-  });
-
-  it("deduplicates items with the same key", () => {
-    bus.preregister({ id: "a", value: 1 });
-    bus.preregister({ id: "a", value: 2 });
-
-    const items = bus.getPreregistered();
-    expect(items).toHaveLength(1);
-    expect(items[0].value).toBe(2);
-  });
-
-  it("replays all preregistered items into a service", () => {
-    bus.preregister({ id: "a", value: 1 });
-    bus.preregister({ id: "b", value: 2 });
-
-    const service = createTestService();
-    bus.replayInto(service);
-
-    expect(service.items).toHaveLength(2);
-    expect(service.items.map((i) => i.id)).toEqual(["a", "b"]);
-  });
-
-  it("live-broadcasts to existing instances when preregistering after service creation", () => {
-    const service = createTestService();
-    bus.replayInto(service);
-
-    bus.preregister({ id: "late", value: 99 });
-
-    expect(service.items).toHaveLength(1);
-    expect(service.items[0].id).toBe("late");
-  });
-
-  it("broadcasts to multiple instances", () => {
-    const service1 = createTestService();
-    const service2 = createTestService();
-    bus.replayInto(service1);
-    bus.replayInto(service2);
-
-    bus.preregister({ id: "multi", value: 42 });
-
-    expect(service1.items).toHaveLength(1);
-    expect(service2.items).toHaveLength(1);
-  });
-
-  it("dispose removes service from instance tracking", () => {
-    const service = createTestService();
-    bus.replayInto(service);
-    expect(bus.instanceCount).toBe(1);
-
-    bus.dispose(service);
-    expect(bus.instanceCount).toBe(0);
-
-    // Items preregistered after dispose should not reach disposed service
-    bus.preregister({ id: "after-dispose", value: 0 });
-    expect(service.items).toHaveLength(0);
-  });
-
-  it("getFirstInstance returns the first tracked instance", () => {
-    expect(bus.getFirstInstance()).toBeUndefined();
-
-    const service = createTestService();
-    bus.replayInto(service);
-
-    expect(bus.getFirstInstance()).toBe(service);
-  });
-
-  it("removePreregistered removes matching items from store", () => {
-    bus.preregister({ id: "keep", value: 1 });
-    bus.preregister({ id: "remove", value: 2 });
-
-    bus.removePreregistered((item) => item.id === "remove");
-
-    expect(bus.getPreregistered()).toHaveLength(1);
-    expect(bus.getPreregistered()[0].id).toBe("keep");
-  });
-
-  it("handles registration errors gracefully during replay", () => {
-    bus.preregister({ id: "bad", value: -1 });
-
-    const brokenService: TestService = {
-      items: [],
-      register() {
-        throw new Error("boom");
-      },
-    };
-
-    // Should not throw
-    expect(() => bus.replayInto(brokenService)).not.toThrow();
-  });
-
-  it("handles registration errors gracefully during live broadcast", () => {
-    const brokenService: TestService = {
-      items: [],
-      register() {
-        throw new Error("boom");
-      },
-    };
-    bus.replayInto(brokenService);
-
-    // Should not throw
-    expect(() => bus.preregister({ id: "late", value: 1 })).not.toThrow();
-  });
-
-  it("broadcast calls callback on all tracked instances", () => {
-    const service1 = createTestService();
-    const service2 = createTestService();
-    bus.replayInto(service1);
-    bus.replayInto(service2);
-
-    const cb = vi.fn();
-    bus.broadcast(cb);
-
-    expect(cb).toHaveBeenCalledTimes(2);
-    expect(cb).toHaveBeenCalledWith(service1);
-    expect(cb).toHaveBeenCalledWith(service2);
-  });
-
-  it("instanceCount reflects current number of tracked instances", () => {
-    expect(bus.instanceCount).toBe(0);
-
-    const s1 = createTestService();
-    const s2 = createTestService();
-    bus.replayInto(s1);
-    expect(bus.instanceCount).toBe(1);
-
-    bus.replayInto(s2);
-    expect(bus.instanceCount).toBe(2);
-
-    bus.dispose(s1);
-    expect(bus.instanceCount).toBe(1);
-  });
-
-  describe("unregister", () => {
-    it("removes item from store by id", () => {
-      bus.preregister({ id: "a", value: 1 });
-      bus.preregister({ id: "b", value: 2 });
-
-      bus.unregister("a");
-
-      expect(bus.getPreregistered()).toHaveLength(1);
-      expect(bus.getPreregistered()[0].id).toBe("b");
-    });
-
-    it("is a no-op for non-existent id", () => {
-      bus.preregister({ id: "a", value: 1 });
-
-      bus.unregister("does-not-exist");
-
-      expect(bus.getPreregistered()).toHaveLength(1);
-    });
-
-    it("works without unregisterFromService callback (store-only)", () => {
-      bus.preregister({ id: "a", value: 1 });
-      const service = createTestService();
-      bus.replayInto(service);
-
-      // Bus without unregisterFromService — only removes from store
-      bus.unregister("a");
-
-      expect(bus.getPreregistered()).toHaveLength(0);
-    });
-
-    it("broadcasts removal to live service instances when unregisterFromService is provided", () => {
-      const busWithUnregister = createPreregistrationBus<TestItem, TestService>({
-        name: "test-with-unregister",
-        getKey: (item) => item.id,
-        registerIntoService: (service, item) => service.register(item),
-        unregisterFromService: (service, id) => service.unregister?.(id),
-      });
-
-      const unregisterSpy = vi.fn();
-      const service = createTestService();
-      service.unregister = unregisterSpy;
-      busWithUnregister.replayInto(service);
-      busWithUnregister.preregister({ id: "a", value: 1 });
-
-      busWithUnregister.unregister("a");
-
-      expect(unregisterSpy).toHaveBeenCalledWith("a");
-      expect(busWithUnregister.getPreregistered()).toHaveLength(0);
-    });
-  });
-});

package/core/services/_internal/createPreregistrationBus.ts

@@ -1,106 +0,0 @@
-import { createLogger } from "@core/utilities";
-
-export interface PreregistrationBusOptions<TItem, TService> {
-  name: string;
-  getKey: (item: TItem) => string;
-  registerIntoService: (service: TService, item: TItem) => void;
-  unregisterFromService?: (service: TService, id: string) => void;
-}
-
-export interface PreregistrationBus<TItem, TService> {
-  preregister(item: TItem): void;
-  unregister(id: string): void;
-  removePreregistered(predicate: (item: TItem) => boolean): void;
-  getPreregistered(): TItem[];
-  replayInto(service: TService): void;
-  dispose(service: TService): void;
-  broadcast(cb: (service: TService) => void): void;
-  getFirstInstance(): TService | undefined;
-  readonly instanceCount: number;
-}
-
-export function createPreregistrationBus<TItem, TService>(
-  options: PreregistrationBusOptions<TItem, TService>,
-): PreregistrationBus<TItem, TService> {
-  const logger = createLogger(`${options.name}-bus`);
-  const store = new Map<string, TItem>();
-  const instances = new Set<TService>();
-
-  function preregister(item: TItem): void {
-    const key = options.getKey(item);
-    store.set(key, item);
-
-    if (instances.size > 0) {
-      broadcast((service) => {
-        try {
-          options.registerIntoService(service, item);
-        } catch (e) {
-          logger.warn(`Failed to live-register item (key=${key}):`, e);
-        }
-      });
-    }
-  }
-
-  function unregister(id: string): void {
-    store.delete(id);
-
-    if (options.unregisterFromService && instances.size > 0) {
-      instances.forEach((service) => {
-        try {
-          options.unregisterFromService!(service, id);
-        } catch (e) {
-          logger.warn(`Failed to live-unregister item (id=${id}):`, e);
-        }
-      });
-    }
-  }
-
-  function removePreregistered(predicate: (item: TItem) => boolean): void {
-    for (const [key, item] of store) {
-      if (predicate(item)) {
-        store.delete(key);
-      }
-    }
-  }
-
-  function getPreregistered(): TItem[] {
-    return Array.from(store.values());
-  }
-
-  function replayInto(service: TService): void {
-    instances.add(service);
-    store.forEach((item, key) => {
-      try {
-        options.registerIntoService(service, item);
-      } catch (e) {
-        logger.warn(`Failed to replay item (key=${key}):`, e);
-      }
-    });
-  }
-
-  function dispose(service: TService): void {
-    instances.delete(service);
-  }
-
-  function broadcast(cb: (service: TService) => void): void {
-    instances.forEach((service) => cb(service));
-  }
-
-  function getFirstInstance(): TService | undefined {
-    return instances.values().next().value;
-  }
-
-  return {
-    preregister,
-    unregister,
-    removePreregistered,
-    getPreregistered,
-    replayInto,
-    dispose,
-    broadcast,
-    getFirstInstance,
-    get instanceCount() {
-      return instances.size;
-    },
-  };
-}

package/core/services/_internal/createSimpleMapRegistry.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { createSimpleMapRegistry, type SimpleMapRegistry } from "@core/services/_internal/createSimpleMapRegistry";
-
-interface TestItem {
-  id: string;
-  order?: number;
-  label: string;
-}
-
-interface TestOptions {
-  id?: string;
-  order?: number;
-  label: string;
-}
-
-function createTestRegistry(): SimpleMapRegistry<TestItem, TestOptions> {
-  return createSimpleMapRegistry<TestItem, TestOptions>({
-    createItem: (opts, currentSize) => ({
-      id: opts.id || "",
-      order: opts.order ?? currentSize,
-      label: opts.label,
-    }),
-    getId: (opts) => opts.id || "",
-  });
-}
-
-describe("createSimpleMapRegistry", () => {
-  let registry: SimpleMapRegistry<TestItem, TestOptions>;
-
-  beforeEach(() => {
-    registry = createTestRegistry();
-  });
-
-  it("registers items and returns them sorted by order", () => {
-    registry.register({ id: "b", order: 2, label: "B" });
-    registry.register({ id: "a", order: 1, label: "A" });
-    registry.register({ id: "c", order: 3, label: "C" });
-
-    const sorted = registry.sortedItems.value;
-    expect(sorted.map((i) => i.id)).toEqual(["a", "b", "c"]);
-  });
-
-  it("auto-generates id when none provided", () => {
-    const id = registry.register({ label: "No ID" });
-    expect(id).toBeTruthy();
-    expect(registry.sortedItems.value).toHaveLength(1);
-  });
-
-  it("unregister removes the item", () => {
-    registry.register({ id: "x", label: "X" });
-    expect(registry.sortedItems.value).toHaveLength(1);
-
-    registry.unregister("x");
-    expect(registry.sortedItems.value).toHaveLength(0);
-  });
-
-  it("uses currentSize as default order", () => {
-    registry.register({ id: "first", label: "First" });
-    registry.register({ id: "second", label: "Second" });
-
-    const items = registry.sortedItems.value;
-    expect(items[0].order).toBe(0);
-    expect(items[1].order).toBe(1);
-  });
-
-  it("overwrites item with same id", () => {
-    registry.register({ id: "a", label: "Original", order: 1 });
-    registry.register({ id: "a", label: "Updated", order: 1 });
-
-    expect(registry.sortedItems.value).toHaveLength(1);
-    expect(registry.sortedItems.value[0].label).toBe("Updated");
-  });
-
-  it("sorts items with undefined order as 0", () => {
-    registry.register({ id: "a", order: 5, label: "A" });
-    registry.register({ id: "b", label: "B" }); // order defaults to currentSize=1
-
-    const sorted = registry.sortedItems.value;
-    expect(sorted[0].id).toBe("b");
-    expect(sorted[1].id).toBe("a");
-  });
-});

package/core/services/_internal/createSimpleMapRegistry.ts

@@ -1,41 +0,0 @@
-import { ref, computed, type Ref, type ComputedRef } from "vue";
-
-export interface SimpleMapRegistryOptions<TItem, TOptions> {
-  createItem: (options: TOptions, currentSize: number) => TItem;
-  getId: (options: TOptions) => string;
-}
-
-export interface SimpleMapRegistry<TItem extends { id: string; order?: number }, TOptions> {
-  readonly itemsMap: Ref<Map<string, TItem>>;
-  readonly sortedItems: ComputedRef<TItem[]>;
-  register(options: TOptions): string;
-  unregister(id: string): void;
-}
-
-export function createSimpleMapRegistry<TItem extends { id: string; order?: number }, TOptions>(
-  options: SimpleMapRegistryOptions<TItem, TOptions>,
-): SimpleMapRegistry<TItem, TOptions> {
-  const itemsMap = ref<Map<string, TItem>>(new Map()) as Ref<Map<string, TItem>>;
-
-  const sortedItems = computed<TItem[]>(() => {
-    return Array.from(itemsMap.value.values()).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-  });
-
-  function register(opts: TOptions): string {
-    const id = options.getId(opts) || crypto.randomUUID();
-    const item = options.createItem(opts, itemsMap.value.size);
-    itemsMap.value.set(id, { ...item, id } as TItem);
-    return id;
-  }
-
-  function unregister(id: string): void {
-    itemsMap.value.delete(id);
-  }
-
-  return {
-    itemsMap,
-    sortedItems,
-    register,
-    unregister,
-  };
-}

package/core/services/_internal/index.ts

@@ -1,3 +0,0 @@
-export { createPreregistrationBus, type PreregistrationBus, type PreregistrationBusOptions } from "@core/services/_internal/createPreregistrationBus";
-export { createBladeScopedRegistry, type BladeScopedRegistry, type BladeScopedRegistryOptions } from "@core/services/_internal/createBladeScopedRegistry";
-export { createSimpleMapRegistry, type SimpleMapRegistry, type SimpleMapRegistryOptions } from "@core/services/_internal/createSimpleMapRegistry";

package/core/services/app-bar-menu-service.ts

@@ -1,71 +0,0 @@
-import { ComputedRef } from "vue";
-import { createSimpleMapRegistry, createPreregistrationBus } from "@core/services/_internal";
-
-export interface AppBarWidget {
-  id: string;
-  order?: number;
-  title?: string;
-  icon?: import("vue").Component | string;
-  component?: import("vue").Component;
-  props?: Record<string, unknown>;
-  onClick?: () => void;
-  slot?: string;
-  badge?: boolean | (() => boolean);
-  searchTerms?: string[];
-}
-
-export interface registerAppBarWidgetOptions extends Omit<AppBarWidget, "id"> {
-  id?: string;
-}
-
-export interface IAppBarWidgetService {
-  register: (options: registerAppBarWidgetOptions) => string;
-  unregister: (id: string) => void;
-  items: ComputedRef<AppBarWidget[]>;
-}
-
-export const appBarWidgetBus = createPreregistrationBus<registerAppBarWidgetOptions, IAppBarWidgetService>({
-  name: "app-bar-menu-service",
-  getKey: (item) => item.id || crypto.randomUUID(),
-  registerIntoService: (service, item) => service.register(item),
-  unregisterFromService: (service, id) => service.unregister(id),
-});
-
-/**
- * Registers an AppBar menu item before the service is initialized
- */
-export function addAppBarWidget(item: registerAppBarWidgetOptions): void {
-  appBarWidgetBus.preregister(item);
-}
-
-/**
- * Creates an AppBar menu service
- * Manages the registration and organization of AppBar menu items
- */
-export function createAppBarWidgetService(): IAppBarWidgetService {
-  const mapRegistry = createSimpleMapRegistry<AppBarWidget, registerAppBarWidgetOptions>({
-    createItem: (options, currentSize) => ({
-      id: options.id || "",
-      order: options.order ?? currentSize,
-      title: options.title,
-      icon: options.icon,
-      component: options.component,
-      props: options.props,
-      onClick: options.onClick,
-      slot: options.slot,
-      badge: options.badge,
-      searchTerms: options.searchTerms,
-    }),
-    getId: (options) => options.id || "",
-  });
-
-  const service: IAppBarWidgetService = {
-    register: (options) => mapRegistry.register(options),
-    unregister: (id) => mapRegistry.unregister(id),
-    items: mapRegistry.sortedItems,
-  };
-
-  appBarWidgetBus.replayInto(service);
-
-  return service;
-}

package/core/services/app-bar-mobile-buttons-service.ts

@@ -1,62 +0,0 @@
-import { ComputedRef, ref, computed, Component, MaybeRef, Ref, toValue } from "vue";
-
-export interface AppBarButtonContent {
-  id: string;
-  component?: Component;
-  props?: Record<string, unknown>;
-  icon?: Component | string;
-  onClick?: () => void;
-  order?: number;
-  onClose?: () => void;
-  isVisible?: MaybeRef<boolean> | ComputedRef<boolean>;
-  badge?: MaybeRef<boolean> | ComputedRef<boolean>;
-}
-
-export interface IAppBarMobileButtonsService {
-  registeredButtons: ComputedRef<AppBarButtonContent[]>;
-  register: (button: AppBarButtonContent) => void;
-  unregister: (buttonId: string) => void;
-  getButton: (buttonId: string) => AppBarButtonContent | undefined;
-  getButtons: ComputedRef<AppBarButtonContent[]>;
-}
-
-/**
- * Creates a service for managing mobile AppBar buttons
- * Handles button registration and retrieval for mobile app bar
- */
-export function createAppBarMobileButtonsService(): IAppBarMobileButtonsService {
-  const registeredButtonsState = ref<AppBarButtonContent[]>([]) as Ref<AppBarButtonContent[]>;
-  const registeredButtons = computed(() => registeredButtonsState.value);
-
-  const register = (button: AppBarButtonContent) => {
-    const existingButtonIndex = registeredButtonsState.value.findIndex((b) => b.id === button.id);
-
-    if (existingButtonIndex >= 0) {
-      registeredButtonsState.value[existingButtonIndex] = button;
-    } else {
-      registeredButtonsState.value.push(button);
-    }
-  };
-
-  const unregister = (buttonId: string) => {
-    registeredButtonsState.value = registeredButtonsState.value.filter((button) => button.id !== buttonId);
-  };
-
-  const getButton = (buttonId: string) => {
-    return registeredButtonsState.value.find((button) => button.id === buttonId);
-  };
-
-  const getButtons = computed(() =>
-    [...registeredButtonsState.value]
-      .filter((button) => toValue(button.isVisible) !== false)
-      .sort((a, b) => (a.order || 0) - (b.order || 0)),
-  );
-
-  return {
-    registeredButtons,
-    register,
-    unregister,
-    getButton,
-    getButtons,
-  };
-}