@blac/core 2.0.0-rc-16 → 2.0.0-rc.0

package/src/subscription/__tests__/SubscriptionManager.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { SubscriptionManager } from '../SubscriptionManager';
-import { BlocBase } from '../../BlocBase';
-import { Cubit } from '../../Cubit';
-
-class TestCubit extends Cubit<{ count: number; nested: { value: string } }> {
-  increment = () => {
-    this.emit({ ...this.state, count: this.state.count + 1 });
-  };
-
-  updateNested = (value: string) => {
-    this.emit({ ...this.state, nested: { value } });
-  };
-}
-
-describe('SubscriptionManager', () => {
-  let cubit: TestCubit;
-  let manager: SubscriptionManager<{
-    count: number;
-    nested: { value: string };
-  }>;
-
-  beforeEach(() => {
-    cubit = new TestCubit({ count: 0, nested: { value: 'initial' } });
-    manager = new SubscriptionManager(cubit);
-  });
-
-  describe('subscribe', () => {
-    it('should create a subscription and return unsubscribe function', () => {
-      const notify = vi.fn();
-      const unsubscribe = manager.subscribe({
-        type: 'observer',
-        notify,
-      });
-
-      expect(manager.size).toBe(1);
-
-      unsubscribe();
-      expect(manager.size).toBe(0);
-    });
-
-    it('should initialize selector value on subscription', () => {
-      const notify = vi.fn();
-      const selector = vi.fn((state) => state.count);
-
-      manager.subscribe({
-        type: 'consumer',
-        selector,
-        notify,
-      });
-
-      expect(selector).toHaveBeenCalledWith(cubit.state, cubit);
-    });
-
-    it('should handle selector errors gracefully', () => {
-      const notify = vi.fn();
-      const selector = vi.fn(() => {
-        throw new Error('Selector error');
-      });
-
-      // Should not throw
-      expect(() => {
-        manager.subscribe({
-          type: 'observer',
-          selector,
-          notify,
-        });
-      }).not.toThrow();
-    });
-  });
-
-  describe('notify', () => {
-    it('should notify subscriptions without selectors', () => {
-      const notify = vi.fn();
-      manager.subscribe({
-        type: 'observer',
-        notify,
-      });
-
-      const oldState = { count: 0, nested: { value: 'old' } };
-      const newState = { count: 1, nested: { value: 'new' } };
-
-      manager.notify(newState, oldState);
-
-      expect(notify).toHaveBeenCalledWith(newState, oldState, undefined);
-    });
-
-    it('should use selector for change detection', () => {
-      const notify = vi.fn();
-      const selector = (state: any) => state.count;
-
-      manager.subscribe({
-        type: 'consumer',
-        selector,
-        notify,
-      });
-
-      // Same count, should not notify
-      manager.notify(
-        { count: 0, nested: { value: 'new' } },
-        { count: 0, nested: { value: 'old' } },
-      );
-      expect(notify).not.toHaveBeenCalled();
-
-      // Different count, should notify
-      manager.notify(
-        { count: 1, nested: { value: 'new' } },
-        { count: 0, nested: { value: 'old' } },
-      );
-      expect(notify).toHaveBeenCalledWith(1, 0, undefined);
-    });
-
-    it('should use custom equality function', () => {
-      const notify = vi.fn();
-      const selector = (state: any) => state.nested;
-      const equalityFn = (a: any, b: any) => a.value === b.value;
-
-      manager.subscribe({
-        type: 'observer',
-        selector,
-        equalityFn,
-        notify,
-      });
-
-      // First notification to establish baseline
-      manager.notify(
-        { count: 0, nested: { value: 'initial' } },
-        { count: 0, nested: { value: 'initial' } },
-      );
-      notify.mockClear();
-
-      // Same nested value, should not notify
-      manager.notify(
-        { count: 1, nested: { value: 'initial' } },
-        { count: 0, nested: { value: 'initial' } },
-      );
-      expect(notify).not.toHaveBeenCalled();
-
-      // Different nested value, should notify
-      manager.notify(
-        { count: 1, nested: { value: 'new' } },
-        { count: 0, nested: { value: 'initial' } },
-      );
-      expect(notify).toHaveBeenCalled();
-    });
-
-    it('should respect priority order', () => {
-      const callOrder: string[] = [];
-
-      manager.subscribe({
-        type: 'observer',
-        priority: 1,
-        notify: () => callOrder.push('low'),
-      });
-
-      manager.subscribe({
-        type: 'observer',
-        priority: 10,
-        notify: () => callOrder.push('high'),
-      });
-
-      manager.subscribe({
-        type: 'observer',
-        priority: 5,
-        notify: () => callOrder.push('medium'),
-      });
-
-      manager.notify(
-        { count: 1, nested: { value: 'new' } },
-        { count: 0, nested: { value: 'old' } },
-      );
-
-      expect(callOrder).toEqual(['high', 'medium', 'low']);
-    });
-
-    it('should handle notify errors gracefully', () => {
-      const goodNotify = vi.fn();
-      const badNotify = vi.fn(() => {
-        throw new Error('Notify error');
-      });
-
-      manager.subscribe({ type: 'observer', notify: badNotify });
-      manager.subscribe({ type: 'observer', notify: goodNotify });
-
-      // Should not throw and should call good notify
-      expect(() => {
-        manager.notify(
-          { count: 1, nested: { value: 'new' } },
-          { count: 0, nested: { value: 'old' } },
-        );
-      }).not.toThrow();
-
-      expect(goodNotify).toHaveBeenCalled();
-    });
-  });
-
-  describe('trackAccess', () => {
-    it('should track path dependencies', () => {
-      const notify = vi.fn();
-      const unsubscribe = manager.subscribe({
-        type: 'consumer',
-        notify,
-      });
-
-      // Get subscription ID (hacky but works for testing)
-      const subscriptionId = Array.from(
-        (manager as any).subscriptions.keys(),
-      )[0] as string;
-
-      manager.trackAccess(subscriptionId, 'count');
-      manager.trackAccess(subscriptionId, 'nested.value');
-
-      const subscription = manager.getSubscription(subscriptionId);
-      expect(subscription?.dependencies).toContain('count');
-      expect(subscription?.dependencies).toContain('nested.value');
-    });
-
-    it('should update metadata on access', () => {
-      const notify = vi.fn();
-      manager.subscribe({ type: 'consumer', notify });
-
-      const subscriptionId = Array.from(
-        (manager as any).subscriptions.keys(),
-      )[0] as string;
-
-      manager.trackAccess(subscriptionId, 'count');
-
-      const subscription = manager.getSubscription(subscriptionId);
-      expect(subscription?.metadata?.accessCount).toBe(1);
-      expect(subscription?.metadata?.lastAccessTime).toBeGreaterThan(0);
-    });
-  });
-
-  describe('shouldNotifyForPaths', () => {
-    it('should return true for direct path match', () => {
-      const notify = vi.fn();
-      manager.subscribe({ type: 'consumer', notify });
-
-      const subscriptionId = Array.from(
-        (manager as any).subscriptions.keys(),
-      )[0] as string;
-      manager.trackAccess(subscriptionId, 'count');
-
-      const changedPaths = new Set(['count']);
-      expect(manager.shouldNotifyForPaths(subscriptionId, changedPaths)).toBe(
-        true,
-      );
-    });
-
-    it('should return true for nested path changes', () => {
-      const notify = vi.fn();
-      manager.subscribe({ type: 'consumer', notify });
-
-      const subscriptionId = Array.from(
-        (manager as any).subscriptions.keys(),
-      )[0] as string;
-      manager.trackAccess(subscriptionId, 'nested');
-
-      const changedPaths = new Set(['nested.value']);
-      expect(manager.shouldNotifyForPaths(subscriptionId, changedPaths)).toBe(
-        true,
-      );
-    });
-
-    it('should return false for unrelated path changes', () => {
-      const notify = vi.fn();
-      manager.subscribe({ type: 'consumer', notify });
-
-      const subscriptionId = Array.from(
-        (manager as any).subscriptions.keys(),
-      )[0] as string;
-      manager.trackAccess(subscriptionId, 'count');
-
-      const changedPaths = new Set(['nested.value']);
-      expect(manager.shouldNotifyForPaths(subscriptionId, changedPaths)).toBe(
-        false,
-      );
-    });
-  });
-
-  describe('weak reference handling', () => {
-    it('should clean up subscriptions with dead weak references', async () => {
-      let obj: any = { id: 'test' };
-      const weakRef = new WeakRef(obj);
-      const notify = vi.fn();
-
-      manager.subscribe({
-        type: 'consumer',
-        weakRef,
-        notify,
-      });
-
-      expect(manager.size).toBe(1);
-
-      // Clear strong reference
-      obj = null;
-
-      // Force garbage collection (this is platform-specific and may not work in all environments)
-      if ((global as any).gc) {
-        (global as any).gc();
-      }
-
-      // Trigger notification which should clean up dead refs
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      manager.notify(
-        { count: 1, nested: { value: 'new' } },
-        { count: 0, nested: { value: 'old' } },
-      );
-
-      // Wait for microtask
-      await new Promise((resolve) => queueMicrotask(resolve));
-
-      // Note: This test may not reliably pass in all environments due to GC timing
-      // In production, the cleanup will happen eventually
-    });
-  });
-
-  describe('getStats', () => {
-    it('should return correct statistics', () => {
-      manager.subscribe({ type: 'consumer', notify: vi.fn() });
-      manager.subscribe({ type: 'observer', notify: vi.fn() });
-      manager.subscribe({ type: 'observer', notify: vi.fn() });
-
-      const stats = manager.getStats();
-
-      expect(stats.activeSubscriptions).toBe(3);
-      expect(stats.consumerCount).toBe(1);
-      expect(stats.observerCount).toBe(2);
-      expect(stats.totalNotifications).toBe(0);
-
-      // Trigger a notification
-      manager.notify(
-        { count: 1, nested: { value: 'new' } },
-        { count: 0, nested: { value: 'old' } },
-      );
-
-      const updatedStats = manager.getStats();
-      expect(updatedStats.totalNotifications).toBe(3); // All 3 subscriptions notified
-    });
-  });
-
-  describe('clear', () => {
-    it('should remove all subscriptions', () => {
-      manager.subscribe({ type: 'consumer', notify: vi.fn() });
-      manager.subscribe({ type: 'observer', notify: vi.fn() });
-
-      expect(manager.size).toBe(2);
-
-      manager.clear();
-
-      expect(manager.size).toBe(0);
-      expect(manager.hasSubscriptions).toBe(false);
-    });
-  });
-});

package/src/subscription/types.ts

@@ -1,90 +0,0 @@
-import { BlocBase } from '../BlocBase';
-
-/**
- * Unified subscription interface that replaces the dual consumer/observer system
- */
-export interface Subscription<S = unknown> {
-  /** Unique identifier for the subscription */
-  id: string;
-
-  /** Type of subscription for backward compatibility */
-  type: 'consumer' | 'observer';
-
-  /** Optional selector function to derive values from state */
-  selector?: (state: S, bloc?: BlocBase<S>) => unknown;
-
-  /** Custom equality function for selector results (defaults to Object.is) */
-  equalityFn?: (prev: unknown, next: unknown) => boolean;
-
-  /** Notification callback when state changes */
-  notify: (value: unknown, oldValue?: unknown, action?: unknown) => void;
-
-  /** Priority for notification order (higher = earlier) */
-  priority?: number;
-
-  /** WeakRef to the subscriber for automatic cleanup (React components) */
-  weakRef?: WeakRef<object>;
-
-  /** Last computed selector value for comparison */
-  lastValue?: unknown;
-
-  /** Tracked state path dependencies */
-  dependencies?: Set<string>;
-
-  /** Metadata for tracking and debugging */
-  metadata?: SubscriptionMetadata;
-}
-
-export interface SubscriptionMetadata {
-  /** Timestamp of last notification */
-  lastNotified?: number;
-
-  /** Whether the subscriber has rendered (React-specific) */
-  hasRendered?: boolean;
-
-  /** Number of times this subscription accessed state */
-  accessCount?: number;
-
-  /** First access timestamp */
-  firstAccessTime?: number;
-
-  /** Last access timestamp */
-  lastAccessTime?: number;
-}
-
-export interface SubscriptionOptions<S> {
-  /** Type of subscription */
-  type: 'consumer' | 'observer';
-
-  /** Optional selector function */
-  selector?: (state: S, bloc?: BlocBase<S>) => unknown;
-
-  /** Custom equality function */
-  equalityFn?: (prev: unknown, next: unknown) => boolean;
-
-  /** Notification callback */
-  notify: (value: unknown, oldValue?: unknown, action?: unknown) => void;
-
-  /** Priority for notifications */
-  priority?: number;
-
-  /** WeakRef to subscriber */
-  weakRef?: WeakRef<object>;
-}
-
-export interface SubscriptionManagerStats {
-  /** Total number of active subscriptions */
-  activeSubscriptions: number;
-
-  /** Number of consumer subscriptions */
-  consumerCount: number;
-
-  /** Number of observer subscriptions */
-  observerCount: number;
-
-  /** Total notifications sent */
-  totalNotifications: number;
-
-  /** Number of tracked dependencies */
-  trackedDependencies: number;
-}

package/src/testing.ts

@@ -1,246 +0,0 @@
-import { Blac } from './Blac';
-import { Bloc } from './Bloc';
-import { BlocBase } from './BlocBase';
-import { Cubit } from './Cubit';
-import { BlocEventConstraint } from './types';
-
-/**
- * Test utilities for Blac state management
- */
-export class BlocTest {
-  private static originalInstance: Blac;
-
-  /**
-   * Sets up a clean test environment
-   */
-  static setUp(): void {
-    this.originalInstance = Blac.instance;
-    Blac.resetInstance();
-    Blac.enableLog = false; // Disable logging in tests by default
-  }
-
-  /**
-   * Tears down the test environment and restores original state
-   */
-  static tearDown(): void {
-    Blac.resetInstance();
-    // Note: Cannot restore original instance due to singleton pattern
-    // Tests should use setUp/tearDown properly to manage state
-  }
-
-  /**
-   * Creates a test bloc with automatic cleanup
-   */
-  static createBloc<T extends BlocBase<any>>(
-    BlocClass: new (...args: any[]) => T,
-    ...args: any[]
-  ): T {
-    const bloc = new BlocClass(...args);
-    Blac.activateBloc(bloc);
-    return bloc;
-  }
-
-  /**
-   * Waits for a bloc to emit a specific state
-   */
-  static async waitForState<T extends BlocBase<S>, S>(
-    bloc: T,
-    predicate: (state: S) => boolean,
-    timeout = 5000,
-  ): Promise<S> {
-    return new Promise<S>((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(
-          new Error(
-            `Timeout waiting for state matching predicate after ${timeout}ms`,
-          ),
-        );
-      }, timeout);
-
-      const unsubscribe = bloc.subscribe((newState: S) => {
-        if (predicate(newState)) {
-          clearTimeout(timeoutId);
-          unsubscribe();
-          resolve(newState);
-        }
-      });
-
-      // Check current state immediately
-      if (predicate(bloc.state)) {
-        clearTimeout(timeoutId);
-        unsubscribe();
-        resolve(bloc.state);
-      }
-    });
-  }
-
-  /**
-   * Expects a bloc to emit specific states in order
-   */
-  static async expectStates<T extends BlocBase<S>, S>(
-    bloc: T,
-    expectedStates: S[],
-    timeout = 5000,
-  ): Promise<void> {
-    const receivedStates: S[] = [];
-
-    return new Promise<void>((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(
-          new Error(
-            `Timeout waiting for states. Expected: ${JSON.stringify(expectedStates)}, ` +
-              `Received: ${JSON.stringify(receivedStates)}`,
-          ),
-        );
-      }, timeout);
-
-      const unsubscribe = bloc.subscribe((newState: S) => {
-        receivedStates.push(newState);
-
-        // Check if we have all expected states
-        if (receivedStates.length === expectedStates.length) {
-          clearTimeout(timeoutId);
-          unsubscribe();
-
-          // Verify all states match using deep equality
-          for (let i = 0; i < expectedStates.length; i++) {
-            const expected = expectedStates[i];
-            const received = receivedStates[i];
-
-            // Use JSON comparison for deep equality
-            if (JSON.stringify(expected) !== JSON.stringify(received)) {
-              reject(
-                new Error(
-                  `State mismatch at index ${i}. Expected: ${JSON.stringify(expected)}, ` +
-                    `Received: ${JSON.stringify(received)}`,
-                ),
-              );
-              return;
-            }
-          }
-
-          resolve();
-        }
-      });
-    });
-  }
-}
-
-/**
- * Mock Bloc for testing
- */
-export class MockBloc<
-  S,
-  A extends BlocEventConstraint = BlocEventConstraint,
-> extends Bloc<S, A> {
-  private mockHandlers = new Map<
-    string,
-    (event: A, emit: (newState: S) => void) => void | Promise<void>
-  >();
-
-  constructor(initialState: S) {
-    super(initialState);
-  }
-
-  /**
-   * Mock an event handler for testing
-   */
-  mockEventHandler<E extends A>(
-    eventConstructor: new (...args: any[]) => E,
-    handler: (event: E, emit: (newState: S) => void) => void | Promise<void>,
-  ): void {
-    // Use the on method to register the mock handler
-    this.on(eventConstructor, handler);
-  }
-
-  /**
-   * Get the number of registered handlers
-   */
-  getHandlerCount(): number {
-    return this.eventHandlers.size;
-  }
-
-  /**
-   * Check if a handler is registered for an event type
-   */
-  hasHandler(eventConstructor: new (...args: any[]) => A): boolean {
-    return this.eventHandlers.has(eventConstructor);
-  }
-}
-
-/**
- * Mock Cubit for testing
- */
-export class MockCubit<S> extends Cubit<S> {
-  private stateHistory: S[] = [];
-
-  constructor(initialState: S) {
-    super(initialState);
-    this.stateHistory.push(initialState);
-  }
-
-  /**
-   * Override emit to track state history
-   */
-  emit(newState: S): void {
-    this.stateHistory.push(newState);
-    super.emit(newState);
-  }
-
-  /**
-   * Get the history of all states
-   */
-  getStateHistory(): S[] {
-    return [...this.stateHistory];
-  }
-
-  /**
-   * Clear state history
-   */
-  clearStateHistory(): void {
-    this.stateHistory = [this.state];
-  }
-}
-
-/**
- * Memory leak detector for tests
- */
-export class MemoryLeakDetector {
-  private initialStats: ReturnType<typeof Blac.getMemoryStats>;
-
-  constructor() {
-    this.initialStats = Blac.getMemoryStats();
-  }
-
-  /**
-   * Check for memory leaks and return a report
-   */
-  checkForLeaks(): {
-    hasLeaks: boolean;
-    report: string;
-    stats: ReturnType<typeof Blac.getMemoryStats>;
-  } {
-    const currentStats = Blac.getMemoryStats();
-    const hasLeaks =
-      currentStats.registeredBlocs > this.initialStats.registeredBlocs ||
-      currentStats.isolatedBlocs > this.initialStats.isolatedBlocs ||
-      currentStats.keepAliveBlocs > this.initialStats.keepAliveBlocs;
-
-    const report = `
-Memory Leak Detection Report:
-- Initial registered blocs: ${this.initialStats.registeredBlocs}
-- Current registered blocs: ${currentStats.registeredBlocs}
-- Initial isolated blocs: ${this.initialStats.isolatedBlocs}  
-- Current isolated blocs: ${currentStats.isolatedBlocs}
-- Initial keep-alive blocs: ${this.initialStats.keepAliveBlocs}
-- Current keep-alive blocs: ${currentStats.keepAliveBlocs}
-- Potential leaks detected: ${hasLeaks ? 'YES' : 'NO'}
-    `.trim();
-
-    return {
-      hasLeaks,
-      report,
-      stats: currentStats,
-    };
-  }
-}