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

package/core/plugins/signalR/index.ts

@@ -1,126 +0,0 @@
-import { App, watch, ref, InjectionKey } from "vue";
-import { HubConnection, HubConnectionBuilder, LogLevel } from "@microsoft/signalr";
-import { PushNotification } from "@core/api/platform";
-import { useNotifications } from "@core/composables/useNotifications";
-import { useUserManagement } from "@core/composables/useUserManagement";
-import { useCypressSignalRMock } from "cypress-signalr-mock";
-import { createLogger } from "@core/utilities";
-
-const logger = createLogger("signalR");
-
-const { addNotification } = useNotifications();
-const currentCreator = ref<string | undefined>();
-
-let mountComplete = false;
-let pendingStart = false;
-let _startFn: (() => void) | null = null;
-
-export const updateSignalRCreatorSymbol: InjectionKey<(creator: string | undefined) => void> =
-  Symbol("updateSignalRCreator");
-
-function setupSystemEventsHandler(connection: any, creator?: string) {
-  // Unsubscribe from the previous handler if it was
-  connection.off("SendSystemEvents");
-
-  // Subscribe to events with the new creator
-  if (creator) {
-    logger.debug("Setup handler for creator: ", creator);
-    connection.on("SendSystemEvents", (message: PushNotification) => {
-      if (message.creator === creator) {
-        addNotification(message);
-      }
-    });
-  }
-}
-
-export const signalR = {
-  install(
-    app: App,
-    options?: {
-      creator?: string;
-    },
-  ) {
-    currentCreator.value = options?.creator;
-    const { isAuthenticated } = useUserManagement();
-    let reconnect = false;
-    const connection =
-      useCypressSignalRMock("pushNotificationHub", { enableForVitest: true }) ??
-      new HubConnectionBuilder()
-        .withUrl("/pushNotificationHub")
-        .withAutomaticReconnect()
-        .configureLogging(LogLevel.Information)
-        .build();
-
-    const start = () => {
-      if (!mountComplete) {
-        pendingStart = true;
-        return;
-      }
-      connection
-        .start()
-        .then(() => {
-          logger.info("Connected.");
-          setupSystemEventsHandler(connection, currentCreator.value);
-        })
-        .catch((err) => {
-          logger.error("Connection Error: ", err);
-          setTimeout(() => start(), 5000);
-        });
-    };
-
-    _startFn = start;
-
-    async function stop() {
-      await connection.stop();
-    }
-
-    connection.onclose(() => {
-      if (reconnect) start();
-    });
-
-    connection.on("Send", (message: PushNotification) => {
-      addNotification(message);
-    });
-
-    // Watch for changes in the creator
-    watch(
-      currentCreator,
-      (newCreator) => {
-        if (newCreator && connection.state === "Connected") {
-          setupSystemEventsHandler(connection, newCreator);
-        }
-      },
-      { immediate: true },
-    );
-
-    watch(
-      isAuthenticated,
-      async (value) => {
-        if (value) {
-          reconnect = true;
-          start();
-        } else {
-          reconnect = false;
-          pendingStart = false; // Cancel any pending deferred start
-          await stop();
-        }
-      },
-      { immediate: true },
-    );
-
-    app.config.globalProperties.$updateSignalRCreator = (creator: string | undefined) => {
-      currentCreator.value = creator;
-    };
-    app.provide(updateSignalRCreatorSymbol, (creator: string | undefined) => {
-      currentCreator.value = creator;
-    });
-  },
-};
-
-export function notifyMountComplete(): void {
-  mountComplete = true;
-  if (pendingStart && _startFn) {
-    pendingStart = false;
-    _startFn();
-  }
-}

package/core/plugins/validation/index.ts

@@ -1 +0,0 @@
-export * from "@core/plugins/validation/rules";

package/core/plugins/validation/rules.ts

@@ -1,145 +0,0 @@
-import { i18n } from "..";
-import { defineRule } from "vee-validate";
-import { all } from "@vee-validate/rules";
-
-Object.keys(all).forEach((rule: string) => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  defineRule(rule, (all as Record<string, any>)[rule]);
-});
-
-/**
- * Check if an image dimension larger than a given size.
- */
-export const mindimensions = (images: HTMLInputElement, [width, height]: [string | number, string | number]) => {
-  // The field is empty so it should pass
-  if (!images?.files || !images.files?.length) {
-    return true;
-  }
-
-  const validateImage = (file: File, width: string | number, height: string | number) => {
-    const URL = window.URL || window.webkitURL;
-    return new Promise((resolve) => {
-      const image = new Image();
-      image.onerror = () => resolve(false);
-      image.onload = () => {
-        const isValid = image.width >= Number(width) && image.height >= Number(height);
-        if (isValid) {
-          resolve(true);
-        } else {
-          resolve(i18n.global.t("messages.min_dimensions.error", { width, height }));
-        }
-      };
-
-      image.src = URL.createObjectURL(file);
-    });
-  };
-  const list = [];
-  const fileList = images.files;
-  for (let i = 0; i < fileList.length; i++) {
-    if (!/\.(jpg|svg|jpeg|png|bmp|gif)$/i.test(fileList[i].name)) {
-      return Promise.resolve(i18n.global.t("messages.min_dimensions.not_image_error"));
-    }
-
-    list.push(fileList[i]);
-  }
-  return Promise.all(list.map((file) => validateImage(file, width, height))).then((res) => {
-    const isInvalid = res.find((x) => x !== true);
-    if (isInvalid === false || typeof isInvalid === "string") {
-      return isInvalid;
-    } else {
-      return true;
-    }
-  });
-};
-
-defineRule("mindimensions", mindimensions);
-
-/**
- * Check if image not exceeding a given size in kilobytes
- */
-export const fileWeight = (file: HTMLInputElement, [size]: [number]) => {
-  if (!file?.files || !file.files?.length) {
-    return true;
-  }
-
-  const maxSize = size * 1000;
-
-  const fileSizeChecker = (file: File) => {
-    return file.size > maxSize;
-  };
-
-  const list = [];
-  for (let i = 0; i < file.files.length; i++) {
-    list.push(file.files[i]);
-  }
-
-  const checker = list.map((x) => fileSizeChecker(x));
-
-  const isInvalid = checker.find((x) => x === true);
-  if (isInvalid) {
-    return i18n.global.t("messages.file_weight", { size });
-  } else {
-    return true;
-  }
-};
-
-defineRule("fileWeight", fileWeight);
-
-const compare = (
-  value: string | Date,
-  [target]: string[] | Date[],
-  comparer: (first: number, second: number) => boolean,
-  errorMessage: string,
-): boolean | string => {
-  // The field is empty so it should pass
-  if (!value || (typeof value == "string" && !value.length)) {
-    return true;
-  }
-
-  let first_date;
-  let second_date;
-  if (value instanceof Date) {
-    first_date = value;
-  }
-
-  if (target instanceof Date) {
-    second_date = target;
-  }
-
-  if (typeof value === "string") {
-    first_date = new Date(value);
-  }
-
-  if (typeof target === "string") {
-    second_date = new Date(target);
-  }
-
-  if (first_date?.getTime && first_date?.getTime() > 0 && second_date?.getTime && second_date?.getTime() > 0) {
-    if (comparer(second_date.getTime(), first_date.getTime())) {
-      return errorMessage;
-    }
-  }
-
-  return true;
-};
-
-// before
-export const before = (value: string, [target]: string[]) =>
-  compare(value, [target], (first, second) => first < second, i18n.global.t("messages.before"));
-defineRule("before", before);
-
-// after
-export const after = (value: string, [target]: string[]) =>
-  compare(value, [target], (first, second) => first > second, i18n.global.t("messages.after"));
-
-defineRule("after", after);
-
-export const bigInt = (value: string) => {
-  if (Number.isSafeInteger(parseInt(value))) {
-    return true;
-  } else {
-    return i18n.global.t("messages.bigint");
-  }
-};
-
-defineRule("bigint", bigInt);

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

@@ -1,130 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { createBladeScopedRegistry, type BladeScopedRegistry } from "@core/services/_internal/createBladeScopedRegistry";
-
-interface TestItem {
-  id: string;
-  bladeId?: string;
-  label?: string;
-}
-
-interface TestRegistration {
-  bladeId: string;
-  item: TestItem;
-}
-
-function createTestRegistry(): BladeScopedRegistry<TestItem, TestRegistration> {
-  return createBladeScopedRegistry<TestItem, TestRegistration>({
-    createRegistration: (bladeId, item) => ({ bladeId, item }),
-    getRegistrationBladeId: (r) => r.bladeId,
-    getRegistrationItemId: (r) => r.item.id,
-  });
-}
-
-describe("createBladeScopedRegistry", () => {
-  let registry: BladeScopedRegistry<TestItem, TestRegistration>;
-
-  beforeEach(() => {
-    registry = createTestRegistry();
-  });
-
-  it("registers and retrieves items by bladeId", () => {
-    registry.register({ id: "a", label: "A" }, "blade-1");
-    registry.register({ id: "b", label: "B" }, "blade-1");
-
-    const items = registry.get("blade-1");
-    expect(items).toHaveLength(2);
-    expect(items.map((i) => i.id)).toEqual(["a", "b"]);
-  });
-
-  it("normalizes bladeId to lowercase", () => {
-    registry.register({ id: "a" }, "Blade-1");
-    expect(registry.get("blade-1")).toHaveLength(1);
-    expect(registry.get("BLADE-1")).toHaveLength(1);
-  });
-
-  it("returns empty array for unknown bladeId", () => {
-    expect(registry.get("nonexistent")).toEqual([]);
-  });
-
-  it("returns defensive copy from get()", () => {
-    registry.register({ id: "a" }, "blade-1");
-    const copy = registry.get("blade-1");
-    copy.push({ id: "fake" });
-    expect(registry.get("blade-1")).toHaveLength(1);
-  });
-
-  it("upserts existing items instead of duplicating", () => {
-    registry.register({ id: "a", label: "original" }, "blade-1");
-    registry.register({ id: "a", label: "updated" }, "blade-1");
-
-    const items = registry.get("blade-1");
-    expect(items).toHaveLength(1);
-    expect(items[0].label).toBe("updated");
-  });
-
-  it("tracks registrations in the registrations array", () => {
-    registry.register({ id: "a" }, "blade-1");
-    registry.register({ id: "b" }, "blade-2");
-
-    expect(registry.registrations).toHaveLength(2);
-  });
-
-  it("unregister removes item and registration", () => {
-    registry.register({ id: "a" }, "blade-1");
-    registry.register({ id: "b" }, "blade-1");
-
-    registry.unregister("a", "blade-1");
-
-    expect(registry.get("blade-1")).toHaveLength(1);
-    expect(registry.get("blade-1")[0].id).toBe("b");
-    expect(registry.registrations).toHaveLength(1);
-  });
-
-  it("clear removes all items for a blade", () => {
-    registry.register({ id: "a" }, "blade-1");
-    registry.register({ id: "b" }, "blade-1");
-    registry.register({ id: "c" }, "blade-2");
-
-    registry.clear("blade-1");
-
-    expect(registry.get("blade-1")).toHaveLength(0);
-    expect(registry.get("blade-2")).toHaveLength(1);
-    expect(registry.registrations).toHaveLength(1);
-  });
-
-  it("update modifies an existing item in-place", () => {
-    registry.register({ id: "a", label: "original" }, "blade-1");
-    registry.update("a", "blade-1", { label: "modified" });
-
-    expect(registry.get("blade-1")[0].label).toBe("modified");
-  });
-
-  it("update is a no-op for non-existent item", () => {
-    registry.update("nonexistent", "blade-1", { label: "x" });
-    expect(registry.get("blade-1")).toHaveLength(0);
-  });
-
-  it("isRegistered tracks cross-blade registration count", () => {
-    registry.register({ id: "dup" }, "blade-a");
-    registry.register({ id: "dup" }, "blade-b");
-
-    expect(registry.isRegistered("dup")).toBe(true);
-
-    registry.unregister("dup", "blade-a");
-    expect(registry.isRegistered("dup")).toBe(true);
-
-    registry.unregister("dup", "blade-b");
-    expect(registry.isRegistered("dup")).toBe(false);
-  });
-
-  it("clear decrements registration counts", () => {
-    registry.register({ id: "a" }, "blade-1");
-    registry.register({ id: "a" }, "blade-2");
-
-    registry.clear("blade-1");
-    expect(registry.isRegistered("a")).toBe(true);
-
-    registry.clear("blade-2");
-    expect(registry.isRegistered("a")).toBe(false);
-  });
-});

package/core/services/_internal/createBladeScopedRegistry.ts

@@ -1,127 +0,0 @@
-import { reactive } from "vue";
-
-export interface BladeScopedRegistryOptions<TItem extends { id: string }, TRegistration> {
-  createRegistration: (bladeId: string, item: TItem) => TRegistration;
-  getRegistrationBladeId: (registration: TRegistration) => string;
-  getRegistrationItemId: (registration: TRegistration) => string;
-}
-
-export interface BladeScopedRegistry<TItem extends { id: string }, TRegistration> {
-  readonly registry: Record<string, TItem[]>;
-  readonly registrations: TRegistration[];
-  register(item: TItem, bladeId: string): void;
-  unregister(itemId: string, bladeId: string): void;
-  get(bladeId: string): TItem[];
-  clear(bladeId: string): void;
-  update(id: string, bladeId: string, partial: Partial<TItem>): void;
-  isRegistered(id: string): boolean;
-}
-
-export function createBladeScopedRegistry<TItem extends { id: string }, TRegistration>(
-  options: BladeScopedRegistryOptions<TItem, TRegistration>,
-): BladeScopedRegistry<TItem, TRegistration> {
-  const registry = reactive<Record<string, TItem[]>>({});
-  // Cast needed: reactive() unwraps refs in generics, but our TRegistration types are plain objects
-  const registrations = reactive([]) as TRegistration[];
-  const registrationCountById = reactive(new Map<string, number>());
-
-  function incrementCount(id: string): void {
-    registrationCountById.set(id, (registrationCountById.get(id) ?? 0) + 1);
-  }
-
-  function decrementCount(id: string): void {
-    const count = registrationCountById.get(id);
-    if (!count || count <= 1) {
-      registrationCountById.delete(id);
-      return;
-    }
-    registrationCountById.set(id, count - 1);
-  }
-
-  function register(item: TItem, bladeId: string): void {
-    const normalizedBladeId = bladeId.toLowerCase();
-
-    if (!registry[normalizedBladeId]) {
-      registry[normalizedBladeId] = [];
-    }
-
-    const existing = registry[normalizedBladeId].find((i) => i.id === item.id);
-    if (existing) {
-      Object.assign(existing, item, { bladeId: normalizedBladeId });
-      return;
-    }
-
-    const registryItem: TItem = { ...item, bladeId: normalizedBladeId } as TItem;
-    registry[normalizedBladeId].push(registryItem);
-    registrations.push(options.createRegistration(normalizedBladeId, registryItem));
-    incrementCount(item.id);
-  }
-
-  function unregister(itemId: string, bladeId: string): void {
-    const normalizedBladeId = bladeId.toLowerCase();
-
-    const bladeItems = registry[normalizedBladeId];
-    if (bladeItems) {
-      const itemIndex = bladeItems.findIndex((i) => i.id === itemId);
-      if (itemIndex !== -1) {
-        const [removedItem] = bladeItems.splice(itemIndex, 1);
-        if (removedItem) {
-          decrementCount(removedItem.id);
-        }
-      }
-    }
-
-    const registrationIndex = registrations.findIndex(
-      (r) => options.getRegistrationBladeId(r) === normalizedBladeId && options.getRegistrationItemId(r) === itemId,
-    );
-    if (registrationIndex !== -1) {
-      registrations.splice(registrationIndex, 1);
-    }
-  }
-
-  function get(bladeId: string): TItem[] {
-    const normalizedBladeId = bladeId ? bladeId.toLowerCase() : "";
-    return [...(registry[normalizedBladeId] || [])];
-  }
-
-  function clear(bladeId: string): void {
-    const normalizedBladeId = bladeId.toLowerCase();
-    const bladeItems = registry[normalizedBladeId];
-
-    if (bladeItems) {
-      bladeItems.forEach((item) => decrementCount(item.id));
-      delete registry[normalizedBladeId];
-    }
-
-    const registrationIndexes = registrations
-      .map((r, index) => (options.getRegistrationBladeId(r) === normalizedBladeId ? index : -1))
-      .filter((index) => index !== -1)
-      .reverse();
-
-    registrationIndexes.forEach((index) => {
-      registrations.splice(index, 1);
-    });
-  }
-
-  function update(id: string, bladeId: string, partial: Partial<TItem>): void {
-    const normalizedBladeId = bladeId.toLowerCase();
-    const existing = registry[normalizedBladeId]?.find((i) => i.id === id);
-    if (!existing) return;
-    Object.assign(existing, partial, { bladeId: normalizedBladeId });
-  }
-
-  function isRegistered(id: string): boolean {
-    return registrationCountById.has(id);
-  }
-
-  return {
-    registry,
-    registrations,
-    register,
-    unregister,
-    get,
-    clear,
-    update,
-    isRegistered,
-  };
-}