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

package/core/types/services.ts

@@ -1,194 +0,0 @@
-import type { App, Ref } from "vue";
-
-/**
- * Service lifecycle interface for managing service creation and cleanup
- */
-export interface ServiceLifecycle<T> {
-  /**
-   * Creates a new instance of the service
-   */
-  create(): T;
-
-  /**
-   * Provides the service to the Vue application
-   */
-  provide(app: App): void;
-
-  /**
-   * Cleanup function called when the service is no longer needed
-   */
-  cleanup(): void;
-}
-
-/**
- * Interface for services that support pre-registration of items
- * before the service is fully initialized
- */
-export interface PreregistrationQueue<T> {
-  /**
-   * Items waiting to be registered
-   */
-  readonly items: readonly T[];
-
-  /**
-   * Register an item to be processed when the service initializes
-   */
-  register(item: T): void;
-
-  /**
-   * Flush all pending items and return them for processing
-   */
-  flush(): T[];
-
-  /**
-   * Clear the queue without processing
-   */
-  clear(): void;
-}
-
-/**
- * Base interface for registry-type services
- */
-export interface RegistryService<TKey, TItem> {
-  /**
-   * Register a new item in the registry
-   */
-  register(key: TKey, item: TItem): void;
-
-  /**
-   * Unregister an item from the registry
-   */
-  unregister(key: TKey): boolean;
-
-  /**
-   * Get an item by its key
-   */
-  get(key: TKey): TItem | undefined;
-
-  /**
-   * Check if an item exists in the registry
-   */
-  has(key: TKey): boolean;
-
-  /**
-   * Get all registered items
-   */
-  getAll(): Map<TKey, TItem>;
-
-  /**
-   * Clear all items from the registry
-   */
-  clear(): void;
-}
-
-/**
- * Interface for services that provide reactive lists
- */
-export interface ListService<T> {
-  /**
-   * Reactive reference to the list items
-   */
-  items: Ref<T[]>;
-
-  /**
-   * Add an item to the list
-   */
-  add(item: T): void;
-
-  /**
-   * Remove an item from the list
-   */
-  remove(item: T): boolean;
-
-  /**
-   * Find an item in the list
-   */
-  find(predicate: (item: T) => boolean): T | undefined;
-
-  /**
-   * Filter items in the list
-   */
-  filter(predicate: (item: T) => boolean): T[];
-}
-
-/**
- * Interface for services with ordered items
- */
-export interface OrderedListService<T> extends ListService<T> {
-  /**
-   * Reorder an item to a new position
-   */
-  reorder(fromIndex: number, toIndex: number): void;
-
-  /**
-   * Get items sorted by priority
-   */
-  getSorted(): T[];
-}
-
-/**
- * Result type for async service operations
- */
-export interface ServiceResult<T> {
-  success: boolean;
-  data?: T;
-  error?: {
-    code: string;
-    message: string;
-    details?: Record<string, unknown>;
-  };
-}
-
-/**
- * Interface for services that support subscription to changes
- */
-export interface ObservableService<T> {
-  /**
-   * Subscribe to changes
-   */
-  subscribe(callback: (value: T) => void): () => void;
-
-  /**
-   * Get the current value
-   */
-  getValue(): T;
-}
-
-/**
- * Type for widget registration
- */
-export interface WidgetRegistration<TProps = Record<string, unknown>> {
-  id: string;
-  component: unknown;
-  props?: TProps;
-  order?: number;
-  isVisible?: boolean | (() => boolean);
-}
-
-/**
- * Type for menu item registration
- */
-export interface MenuItemRegistration {
-  id: string;
-  title: string;
-  icon?: string;
-  priority?: number;
-  permissions?: string | string[];
-  routeId?: string;
-  url?: string;
-  group?: string;
-  children?: MenuItemRegistration[];
-}
-
-/**
- * Type for toolbar item registration
- */
-export interface ToolbarItemRegistration {
-  id: string;
-  title: string;
-  icon?: string;
-  order?: number;
-  disabled?: boolean;
-  clickHandler?: () => void;
-  permissions?: string | string[];
-}

package/core/utilities/camelToSnake.ts

@@ -1,7 +0,0 @@
-export function camelToSnake(str: string): string {
-  return str
-    .replace(/[\w]([A-Z])/g, function (m) {
-      return m[0] + "_" + m[1];
-    })
-    .toLowerCase();
-}

package/core/utilities/camelize.ts

@@ -1,5 +0,0 @@
-export function camelize(str: string) {
-  return str.replace(/\W+(.)/g, function (match, chr) {
-    return chr.toUpperCase();
-  });
-}

package/core/utilities/date/convertMomentFormat.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { convertMomentFormat } from "./convertMomentFormat";
-
-describe("convertMomentFormat", () => {
-  describe("locale shortcuts", () => {
-    it("converts L to P", () => {
-      expect(convertMomentFormat("L")).toBe("P");
-    });
-
-    it("converts LT to p", () => {
-      expect(convertMomentFormat("LT")).toBe("p");
-    });
-
-    it("converts LTS to pp", () => {
-      expect(convertMomentFormat("LTS")).toBe("pp");
-    });
-
-    it("converts LL to PP", () => {
-      expect(convertMomentFormat("LL")).toBe("PP");
-    });
-
-    it("converts LLL to PPp", () => {
-      expect(convertMomentFormat("LLL")).toBe("PPp");
-    });
-
-    it("converts LLLL to PPPp", () => {
-      expect(convertMomentFormat("LLLL")).toBe("PPPp");
-    });
-
-    it("converts combined 'L LT' to 'P p'", () => {
-      expect(convertMomentFormat("L LT")).toBe("P p");
-    });
-  });
-
-  describe("token conversions", () => {
-    it("converts 'YYYY-MM-DD' to 'yyyy-MM-dd'", () => {
-      expect(convertMomentFormat("YYYY-MM-DD")).toBe("yyyy-MM-dd");
-    });
-
-    it("converts 'DD.MM.YYYY HH:mm' to 'dd.MM.yyyy HH:mm'", () => {
-      expect(convertMomentFormat("DD.MM.YYYY HH:mm")).toBe("dd.MM.yyyy HH:mm");
-    });
-
-    it("converts 'DD/MM/YY' to 'dd/MM/yy'", () => {
-      expect(convertMomentFormat("DD/MM/YY")).toBe("dd/MM/yy");
-    });
-
-    it("converts 'ddd, MMM Do YYYY' to 'EEE, MMM do yyyy'", () => {
-      expect(convertMomentFormat("ddd, MMM Do YYYY")).toBe("EEE, MMM do yyyy");
-    });
-
-    it("converts 'dddd' to 'EEEE'", () => {
-      expect(convertMomentFormat("dddd")).toBe("EEEE");
-    });
-
-    it("converts 'hh:mm A' to 'hh:mm a'", () => {
-      expect(convertMomentFormat("hh:mm A")).toBe("hh:mm a");
-    });
-  });
-});

package/core/utilities/date/convertMomentFormat.ts

@@ -1,30 +0,0 @@
-const LOCALE_SHORTCUTS: [string, string][] = [
-  ["LLLL", "PPPp"],
-  ["LLL", "PPp"],
-  ["LTS", "pp"],
-  ["LT", "p"],
-  ["LL", "PP"],
-  ["L", "P"],
-];
-
-const TOKEN_MAP: [RegExp, string][] = [
-  [/YYYY/g, "yyyy"],
-  [/YY/g, "yy"],
-  [/dddd/g, "EEEE"],
-  [/ddd/g, "EEE"],
-  [/DD/g, "dd"],
-  [/Do/g, "do"],
-  [/D(?![\w])/g, "d"],
-  [/A/g, "a"],
-];
-
-export function convertMomentFormat(momentFormat: string): string {
-  let result = momentFormat;
-  for (const [moment, dateFns] of LOCALE_SHORTCUTS) {
-    result = result.split(moment).join(dateFns);
-  }
-  for (const [pattern, replacement] of TOKEN_MAP) {
-    result = result.replace(pattern, replacement);
-  }
-  return result;
-}

package/core/utilities/date/formatDate.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { formatDateRelative, formatDateWithPattern } from "./formatDate";
-
-describe("formatDateRelative", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("returns relative time for a past date", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2024-06-15T12:00:00Z"));
-
-    const pastDate = new Date("2024-06-15T11:00:00Z");
-    const result = formatDateRelative(pastDate);
-    expect(result).toContain("ago");
-  });
-
-  it("handles ISO string input", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2024-06-15T12:00:00Z"));
-
-    const result = formatDateRelative("2024-06-15T11:30:00Z");
-    expect(result).toContain("ago");
-  });
-
-  it('returns "" for null', () => {
-    expect(formatDateRelative(null)).toBe("");
-  });
-
-  it('returns "" for undefined', () => {
-    expect(formatDateRelative(undefined)).toBe("");
-  });
-
-  it('returns "" for empty string', () => {
-    expect(formatDateRelative("")).toBe("");
-  });
-});
-
-describe("formatDateWithPattern", () => {
-  it("formats with 'YYYY-MM-DD HH:mm' pattern", () => {
-    const date = new Date("2024-03-15T14:30:00Z");
-    const result = formatDateWithPattern(date, "YYYY-MM-DD HH:mm");
-    expect(result).toMatch(/2024-03-15 \d{2}:30/);
-  });
-
-  it("formats with 'DD.MM.YYYY' pattern", () => {
-    const date = new Date("2024-03-15T00:00:00Z");
-    const result = formatDateWithPattern(date, "DD.MM.YYYY");
-    expect(result).toMatch(/15\.03\.2024/);
-  });
-
-  it("accepts string date input", () => {
-    const result = formatDateWithPattern("2024-01-01T00:00:00Z", "YYYY-MM-DD");
-    expect(result).toMatch(/2024-01-01/);
-  });
-
-  it('returns "" for null', () => {
-    expect(formatDateWithPattern(null, "YYYY-MM-DD")).toBe("");
-  });
-});

package/core/utilities/date/formatDate.ts

@@ -1,31 +0,0 @@
-import { formatDistanceToNow, format } from "date-fns";
-import { convertMomentFormat } from "./convertMomentFormat";
-import { resolveLocaleSync } from "./resolveLocale";
-
-type DateInput = string | number | Date | null | undefined;
-
-function toDate(value: DateInput): Date | null {
-  if (value == null || value === "") return null;
-  if (value instanceof Date) return isNaN(value.getTime()) ? null : value;
-  const d = new Date(value);
-  return isNaN(d.getTime()) ? null : d;
-}
-
-export function formatDateRelative(value: DateInput, localeCode?: string): string {
-  const date = toDate(value);
-  if (!date) return "";
-  const locale = localeCode ? resolveLocaleSync(localeCode) : undefined;
-  return formatDistanceToNow(date, { addSuffix: true, locale });
-}
-
-export function formatDateWithPattern(
-  value: DateInput,
-  momentFormatStr: string,
-  localeCode?: string,
-): string {
-  const date = toDate(value);
-  if (!date) return "";
-  const dateFnsFormat = convertMomentFormat(momentFormatStr);
-  const locale = localeCode ? resolveLocaleSync(localeCode) : undefined;
-  return format(date, dateFnsFormat, { locale });
-}

package/core/utilities/date/index.ts

@@ -1,3 +0,0 @@
-export { formatDateRelative, formatDateWithPattern } from "./formatDate";
-export { convertMomentFormat } from "./convertMomentFormat";
-export { resolveLocale, resolveLocaleSync } from "./resolveLocale";

package/core/utilities/date/resolveLocale.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { resolveLocale, resolveLocaleSync } from "./resolveLocale";
-import { enUS } from "date-fns/locale";
-
-describe("resolveLocale", () => {
-  it("returns enUS for 'en-US'", async () => {
-    const locale = await resolveLocale("en-US");
-    expect(locale).toBe(enUS);
-  });
-
-  it("returns enUS for 'en'", async () => {
-    const locale = await resolveLocale("en");
-    expect(locale).toBe(enUS);
-  });
-
-  it("returns enUS as fallback for unknown locale 'xx-XX'", async () => {
-    const locale = await resolveLocale("xx-XX");
-    expect(locale).toBe(enUS);
-  });
-
-  it("returns correct locale for 'de' (dynamic load)", async () => {
-    const locale = await resolveLocale("de");
-    expect(locale).toBeDefined();
-    expect(locale).not.toBe(enUS);
-  });
-
-  it("returns correct locale for 'fr-CA' (compound, dynamic load)", async () => {
-    const locale = await resolveLocale("fr-CA");
-    expect(locale).toBeDefined();
-    expect(locale).not.toBe(enUS);
-  });
-});
-
-describe("resolveLocaleSync", () => {
-  it("returns cached enUS for 'en-US'", () => {
-    const locale = resolveLocaleSync("en-US");
-    expect(locale).toBe(enUS);
-  });
-
-  it("returns enUS fallback for uncached locale", () => {
-    const locale = resolveLocaleSync("zz-ZZ");
-    expect(locale).toBe(enUS);
-  });
-});

package/core/utilities/date/resolveLocale.ts

@@ -1,41 +0,0 @@
-import { type Locale } from "date-fns";
-import { enUS } from "date-fns/locale";
-
-const localeCache = new Map<string, Locale>();
-localeCache.set("en-US", enUS);
-localeCache.set("en", enUS);
-
-export async function resolveLocale(localeCode: string): Promise<Locale> {
-  if (localeCache.has(localeCode)) {
-    return localeCache.get(localeCode)!;
-  }
-  try {
-    const mod = await import(/* @vite-ignore */ `date-fns/locale/${localeCode}`);
-    const dateFnsKey = localeCode.replace("-", "");
-    const locale = mod.default ?? mod[dateFnsKey] ?? enUS;
-    localeCache.set(localeCode, locale);
-    return locale;
-  } catch {
-    const base = localeCode.split("-")[0];
-    if (base !== localeCode) {
-      try {
-        const mod = await import(/* @vite-ignore */ `date-fns/locale/${base}`);
-        const locale = mod.default ?? mod[base] ?? enUS;
-        localeCache.set(localeCode, locale);
-        return locale;
-      } catch {
-        /* fall through */
-      }
-    }
-    localeCache.set(localeCode, enUS);
-    return enUS;
-  }
-}
-
-export function resolveLocaleSync(localeCode: string): Locale {
-  if (localeCache.has(localeCode)) {
-    return localeCache.get(localeCode)!;
-  }
-  void resolveLocale(localeCode);
-  return enUS;
-}

package/core/utilities/error.ts

@@ -1,89 +0,0 @@
-// A custom error class to normalize different error types for display.
-export class DisplayableError extends Error {
-  details: string;
-  originalError: unknown;
-
-  constructor(shortMessage: string, details: string, originalError: unknown) {
-    super(shortMessage);
-    this.name = "DisplayableError";
-    this.details = details;
-    this.originalError = originalError;
-  }
-}
-// TODO: add to docs?
-/**
- * Parses an unknown error type into a standardized DisplayableError.
- * This function handles nested errors, API responses, and various error formats.
- * @param errorToParse The error to analyze.
- * @returns A DisplayableError instance.
- */
-export function parseError(errorToParse: unknown): DisplayableError {
-  if (errorToParse instanceof DisplayableError) {
-    return errorToParse;
-  }
-
-  // Handle Axios-style errors, which are instances of Error but have a `response` property.
-  if (errorToParse instanceof Error && "response" in errorToParse && errorToParse.response) {
-    // Delegate to parse the nested response object.
-    return parseError(errorToParse.response);
-  }
-
-  // Handle standard Error objects.
-  if (errorToParse instanceof Error) {
-    return new DisplayableError(errorToParse.message, errorToParse.stack || String(errorToParse), errorToParse);
-  }
-
-  // Handle strings, which might be JSON.
-  if (typeof errorToParse === "string") {
-    try {
-      const parsed = JSON.parse(errorToParse);
-      return parseError(parsed);
-    } catch {
-      // Not a JSON string, treat as a plain message.
-      return new DisplayableError(errorToParse, errorToParse, errorToParse);
-    }
-  }
-
-  // Handle plain objects, which are likely API responses.
-  if (typeof errorToParse === "object" && errorToParse !== null) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const errorObject = errorToParse as Record<string, any>;
-
-    // Check if it conforms to the expected API error response structure.
-    if ("status" in errorObject && "data" in errorObject) {
-      const status = errorObject.status;
-      const statusText = errorObject.statusText || "Error"; // TODO: i18n
-      const shortMessage = `${status}: ${statusText}`;
-
-      const data = errorObject.data;
-      let details = "";
-
-      if (data) {
-        if (typeof data.exceptionMessage === "string") {
-          details = data.exceptionMessage;
-        } else if (typeof data.message === "string") {
-          details = data.message;
-        } else if (Array.isArray(data.errors)) {
-          details = data.errors.join("\n");
-        } else if (typeof data === "string") {
-          details = data;
-        } else {
-          details = JSON.stringify(data, null, 2);
-        }
-      } else {
-        // Fallback if data is null/undefined.
-        details = JSON.stringify(errorObject, null, 2);
-      }
-
-      return new DisplayableError(shortMessage, details, errorToParse);
-    }
-
-    // Fallback for other object structures.
-    const shortMessage = (errorObject.message as string) || "An unexpected error occurred.";
-    const details = (errorObject.stack as string) || JSON.stringify(errorObject, null, 2);
-    return new DisplayableError(shortMessage, details, errorToParse);
-  }
-
-  // Fallback for any other type (null, number, etc.).
-  return new DisplayableError("An unknown error occurred.", String(errorToParse), errorToParse);
-}

package/core/utilities/errorTypes.ts

@@ -1,126 +0,0 @@
-/**
- * Base error class for VC-Shell framework
- * Provides structured error handling with error codes and context
- */
-export class FrameworkError extends Error {
-  constructor(
-    message: string,
-    public readonly code: string,
-    public readonly context?: Record<string, unknown>,
-  ) {
-    super(message);
-    this.name = "FrameworkError";
-
-    // Maintains proper stack trace for where our error was thrown (only available on V8)
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, FrameworkError);
-    }
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      context: this.context,
-      stack: this.stack,
-    };
-  }
-}
-
-/**
- * Error thrown when validation fails
- */
-export class ValidationError extends FrameworkError {
-  constructor(message: string, context?: Record<string, unknown>) {
-    super(message, "VALIDATION_ERROR", context);
-    this.name = "ValidationError";
-  }
-}
-
-/**
- * Error thrown when a service operation fails
- */
-export class ServiceError extends FrameworkError {
-  constructor(message: string, context?: Record<string, unknown>) {
-    super(message, "SERVICE_ERROR", context);
-    this.name = "ServiceError";
-  }
-}
-
-/**
- * Error thrown when a required dependency is not provided
- */
-export class InjectionError extends FrameworkError {
-  constructor(serviceName: string, context?: Record<string, unknown>) {
-    super(`${serviceName} not provided. Make sure to call the corresponding 'provide' function.`, "INJECTION_ERROR", {
-      serviceName,
-      ...context,
-    });
-    this.name = "InjectionError";
-  }
-}
-
-/**
- * Error thrown when component registration fails
- */
-export class RegistrationError extends FrameworkError {
-  constructor(componentName: string, reason: string, context?: Record<string, unknown>) {
-    super(`Failed to register '${componentName}': ${reason}`, "REGISTRATION_ERROR", {
-      componentName,
-      ...context,
-    });
-    this.name = "RegistrationError";
-  }
-}
-
-/**
- * Error thrown when a blade operation fails
- */
-export class BladeError extends FrameworkError {
-  constructor(message: string, bladeId?: string, context?: Record<string, unknown>) {
-    super(message, "BLADE_ERROR", {
-      bladeId,
-      ...context,
-    });
-    this.name = "BladeError";
-  }
-}
-
-/**
- * Error thrown when module loading fails
- */
-export class ModuleLoadError extends FrameworkError {
-  constructor(moduleId: string, reason: string, context?: Record<string, unknown>) {
-    super(`Failed to load module '${moduleId}': ${reason}`, "MODULE_LOAD_ERROR", {
-      moduleId,
-      ...context,
-    });
-    this.name = "ModuleLoadError";
-  }
-}
-
-/**
- * Type guard to check if an error is a FrameworkError
- */
-export function isFrameworkError(error: unknown): error is FrameworkError {
-  return error instanceof FrameworkError;
-}
-
-/**
- * Wraps an unknown error into a FrameworkError
- */
-export function wrapError(error: unknown, code = "UNKNOWN_ERROR"): FrameworkError {
-  if (isFrameworkError(error)) {
-    return error;
-  }
-
-  if (error instanceof Error) {
-    return new FrameworkError(error.message, code, {
-      originalError: error.name,
-      stack: error.stack,
-    });
-  }
-
-  return new FrameworkError(String(error), code);
-}