@blac/core 2.0.0-rc-13 → 2.0.0-rc-16

package/src/__tests__/BlocBase.lifecycle.test.ts

@@ -1,441 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { BlocBase, BlocLifecycleState } from '../BlocBase';
-import { Blac } from '../Blac';
-
-// Test implementation of BlocBase
-class TestBloc extends BlocBase<number> {
-  constructor(initialState: number = 0) {
-    super(initialState);
-  }
-
-  increment() {
-    this._pushState(this.state + 1, this.state);
-  }
-}
-
-// Test bloc with static properties
-class KeepAliveBloc extends BlocBase<string> {
-  static keepAlive = true;
-
-  constructor() {
-    super('initial');
-  }
-}
-
-class IsolatedBloc extends BlocBase<string> {
-  static isolated = true;
-
-  constructor() {
-    super('isolated');
-  }
-}
-
-describe('BlocBase Lifecycle Management', () => {
-  let blac: Blac;
-
-  beforeEach(() => {
-    blac = new Blac({ __unsafe_ignore_singleton: true });
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.clearAllMocks();
-  });
-
-  describe('Atomic State Transitions', () => {
-    it('should transition through lifecycle states atomically', () => {
-      const bloc = new TestBloc();
-
-      // Initial state should be ACTIVE
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.ACTIVE);
-
-      // Transition to DISPOSAL_REQUESTED
-      const result1 = (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.ACTIVE,
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-      expect(result1.success).toBe(true);
-      expect((bloc as any)._disposalState).toBe(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-
-      // Transition to DISPOSING
-      const result2 = (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-        BlocLifecycleState.DISPOSING,
-      );
-      expect(result2.success).toBe(true);
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.DISPOSING);
-
-      // Transition to DISPOSED
-      const result3 = (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.DISPOSING,
-        BlocLifecycleState.DISPOSED,
-      );
-      expect(result3.success).toBe(true);
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.DISPOSED);
-    });
-
-    it('should reject invalid state transitions', () => {
-      const bloc = new TestBloc();
-
-      // Try to transition from ACTIVE to DISPOSED directly (should work in _dispose but not here)
-      const result = (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-        BlocLifecycleState.DISPOSED,
-      );
-      expect(result.success).toBe(false);
-      expect(result.currentState).toBe(BlocLifecycleState.ACTIVE); // Still in ACTIVE because expectedState didn't match
-    });
-
-    it('should handle concurrent transition attempts', () => {
-      const bloc = new TestBloc();
-
-      // First transition succeeds
-      const result1 = (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.ACTIVE,
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-      expect(result1.success).toBe(true);
-
-      // Second attempt with same expected state fails
-      const result2 = (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.ACTIVE,
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-      expect(result2.success).toBe(false);
-      expect(result2.currentState).toBe(BlocLifecycleState.DISPOSAL_REQUESTED);
-    });
-  });
-
-  describe('Consumer Management', () => {
-    it('should register and unregister consumers', () => {
-      const bloc = new TestBloc();
-      const consumerId = 'test-consumer-1';
-      const consumerRef = {};
-
-      // Add consumer
-      const added = bloc._addConsumer(consumerId, consumerRef);
-      expect(added).toBe(true);
-      expect(bloc._consumers.has(consumerId)).toBe(true);
-      expect(bloc._consumers.size).toBe(1);
-
-      // Remove consumer
-      bloc._removeConsumer(consumerId);
-      expect(bloc._consumers.has(consumerId)).toBe(false);
-      expect(bloc._consumers.size).toBe(0);
-    });
-
-    it('should prevent duplicate consumer registration', () => {
-      const bloc = new TestBloc();
-      const consumerId = 'test-consumer-1';
-
-      bloc._addConsumer(consumerId);
-      expect(bloc._consumers.size).toBe(1);
-
-      // Try to add same consumer again
-      bloc._addConsumer(consumerId);
-      expect(bloc._consumers.size).toBe(1); // Should still be 1
-    });
-
-    it('should schedule disposal when last consumer is removed', async () => {
-      const bloc = new TestBloc();
-      const consumerId = 'test-consumer-1';
-
-      // Register bloc with Blac instance
-      blac.registerBlocInstance(bloc as BlocBase<unknown>);
-
-      // Add and remove consumer
-      bloc._addConsumer(consumerId);
-      bloc._removeConsumer(consumerId);
-
-      // Should transition to DISPOSAL_REQUESTED immediately
-      expect((bloc as any)._disposalState).toBe(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-
-      // After microtask, should be disposed
-      await vi.runAllTimersAsync();
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.DISPOSED);
-    });
-
-    it('should cancel disposal if consumer is re-added during grace period', () => {
-      const bloc = new TestBloc();
-      const consumerId1 = 'test-consumer-1';
-      const consumerId2 = 'test-consumer-2';
-
-      // Register bloc
-      blac.registerBlocInstance(bloc as BlocBase<unknown>);
-
-      // Add and remove consumer to trigger disposal
-      bloc._addConsumer(consumerId1);
-      bloc._removeConsumer(consumerId1);
-
-      // State should transition to DISPOSAL_REQUESTED immediately
-      expect((bloc as any)._disposalState).toBe(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-
-      // Add new consumer before microtask runs - should fail
-      const added = bloc._addConsumer(consumerId2);
-      expect(added).toBe(false); // Should fail because bloc is in disposal process
-    });
-
-    it('should clean up dead WeakRef consumers', () => {
-      const bloc = new TestBloc();
-      const consumerId1 = 'consumer-1';
-      const consumerId2 = 'consumer-2';
-      let consumerRef1: any = { name: 'consumer1' };
-      const consumerRef2 = { name: 'consumer2' };
-
-      // Add consumers with refs first
-      bloc._addConsumer(consumerId1, consumerRef1);
-      bloc._addConsumer(consumerId2, consumerRef2);
-      expect(bloc._consumers.size).toBe(2);
-
-      // Now mock the WeakRef's deref method to simulate garbage collection
-      const consumerRefsMap = (bloc as any)._consumerRefs as Map<
-        string,
-        WeakRef<object>
-      >;
-      const weakRef1 = consumerRefsMap.get(consumerId1);
-      const weakRef2 = consumerRefsMap.get(consumerId2);
-
-      if (weakRef1) {
-        // Mock the deref method to return undefined (simulating GC)
-        vi.spyOn(weakRef1, 'deref').mockReturnValue(undefined);
-      }
-
-      // Validate consumers
-      bloc._validateConsumers();
-
-      // First consumer should be removed
-      expect(bloc._consumers.size).toBe(1);
-      expect(bloc._consumers.has(consumerId1)).toBe(false);
-      expect(bloc._consumers.has(consumerId2)).toBe(true);
-    });
-
-    it('should reject consumer additions when bloc is disposed', () => {
-      const bloc = new TestBloc();
-
-      // Force dispose
-      bloc._dispose();
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.DISPOSED);
-
-      // Try to add consumer
-      const added = bloc._addConsumer('new-consumer');
-      expect(added).toBe(false);
-      expect(bloc._consumers.size).toBe(0);
-    });
-  });
-
-  describe('Disposal Behavior', () => {
-    it('should properly dispose bloc and clean up resources', () => {
-      const bloc = new TestBloc();
-      const onDisposeSpy = vi.fn();
-      bloc.onDispose = onDisposeSpy;
-
-      // Add some consumers and observers
-      bloc._addConsumer('consumer-1');
-      const unsubscribe = bloc._observer.subscribe({
-        id: 'observer-1',
-        fn: vi.fn(),
-      });
-
-      // Dispose
-      const disposed = bloc._dispose();
-      expect(disposed).toBe(true);
-      expect(onDisposeSpy).toHaveBeenCalled();
-      expect(bloc._consumers.size).toBe(0);
-      expect(bloc._observer.size).toBe(0);
-      expect(bloc.isDisposed).toBe(true);
-    });
-
-    it('should handle disposal failures gracefully', () => {
-      const bloc = new TestBloc();
-      bloc.onDispose = () => {
-        throw new Error('Disposal error');
-      };
-
-      // Disposal should reset state on error
-      expect(() => bloc._dispose()).toThrow('Disposal error');
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.ACTIVE);
-    });
-
-    it('should schedule disposal with microtask deferral', () => {
-      const bloc = new TestBloc();
-      blac.registerBlocInstance(bloc as BlocBase<unknown>);
-
-      // Remove last consumer
-      bloc._addConsumer('consumer-1');
-      bloc._removeConsumer('consumer-1');
-
-      // Disposal should be scheduled immediately
-      expect((bloc as any)._disposalState).toBe(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-    });
-
-    it('should be idempotent - multiple dispose calls should be safe', () => {
-      const bloc = new TestBloc();
-
-      const result1 = bloc._dispose();
-      expect(result1).toBe(true);
-
-      const result2 = bloc._dispose();
-      expect(result2).toBe(false); // Already disposed
-    });
-  });
-
-  describe('keepAlive and isolated flags', () => {
-    it('should respect keepAlive flag and not dispose when consumers are removed', async () => {
-      const bloc = new KeepAliveBloc();
-      blac.registerBlocInstance(bloc as BlocBase<unknown>);
-
-      expect(bloc.isKeepAlive).toBe(true);
-
-      // Add and remove consumer
-      bloc._addConsumer('consumer-1');
-      bloc._removeConsumer('consumer-1');
-
-      // Should not schedule disposal
-      await vi.runAllTimersAsync();
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.ACTIVE);
-    });
-
-    it('should properly inherit isolated flag from static property', () => {
-      const bloc = new IsolatedBloc();
-      expect(bloc.isIsolated).toBe(true);
-    });
-
-    it('should handle missing static properties gracefully', () => {
-      class BlocWithoutStatics extends BlocBase<number> {
-        constructor() {
-          super(0);
-        }
-      }
-
-      const bloc = new BlocWithoutStatics();
-      expect(bloc.isKeepAlive).toBe(false);
-      expect(bloc.isIsolated).toBe(false);
-    });
-  });
-
-  describe('State Access During Lifecycle', () => {
-    it('should allow state access during all non-disposed states', () => {
-      const bloc = new TestBloc(42);
-
-      // ACTIVE state
-      expect(bloc.state).toBe(42);
-
-      // DISPOSAL_REQUESTED state
-      (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.ACTIVE,
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-      expect(bloc.state).toBe(42);
-
-      // DISPOSING state
-      (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-        BlocLifecycleState.DISPOSING,
-      );
-      expect(bloc.state).toBe(42);
-
-      // DISPOSED state - should return last known state
-      (bloc as any)._atomicStateTransition(
-        BlocLifecycleState.DISPOSING,
-        BlocLifecycleState.DISPOSED,
-      );
-      expect(bloc.state).toBe(42);
-    });
-
-    it('should correctly report isDisposed status', () => {
-      const bloc = new TestBloc();
-
-      expect(bloc.isDisposed).toBe(false);
-
-      bloc._dispose();
-      expect(bloc.isDisposed).toBe(true);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle rapid consumer additions and removals', async () => {
-      const bloc = new TestBloc();
-      blac.registerBlocInstance(bloc as BlocBase<unknown>);
-
-      // Rapidly add and remove consumers
-      for (let i = 0; i < 10; i++) {
-        bloc._addConsumer(`consumer-${i}`);
-        bloc._removeConsumer(`consumer-${i}`);
-      }
-
-      // Should be in DISPOSAL_REQUESTED state
-      expect((bloc as any)._disposalState).toBe(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-      );
-
-      // After microtask, should be disposed
-      await vi.runAllTimersAsync();
-      expect((bloc as any)._disposalState).toBe(BlocLifecycleState.DISPOSED);
-    });
-
-    it('should handle disposal during active state mutations', () => {
-      const bloc = new TestBloc();
-      const observer = vi.fn();
-
-      bloc._observer.subscribe({
-        id: 'observer-1',
-        fn: observer,
-      });
-
-      // Start a state mutation
-      bloc.increment();
-      expect(observer).toHaveBeenCalledWith(1, 0, undefined);
-
-      // Dispose during active usage
-      bloc._dispose();
-
-      // Further mutations should not notify (bloc is disposed)
-      observer.mockClear();
-      bloc.increment();
-      expect(observer).not.toHaveBeenCalled();
-    });
-
-    it('should prevent memory leaks via WeakRef cleanup', () => {
-      const bloc = new TestBloc();
-      const consumerCount = 100;
-      const refs: any[] = [];
-
-      // Add many consumers
-      for (let i = 0; i < consumerCount; i++) {
-        const ref = { id: i };
-        refs.push(ref);
-        bloc._addConsumer(`consumer-${i}`, ref);
-      }
-
-      expect(bloc._consumers.size).toBe(consumerCount);
-
-      // Mock half of the WeakRefs to return undefined (simulating GC)
-      const consumerRefsMap = (bloc as any)._consumerRefs as Map<
-        string,
-        WeakRef<object>
-      >;
-      let mockCount = 0;
-
-      for (const [consumerId, weakRef] of consumerRefsMap) {
-        if (mockCount < consumerCount / 2) {
-          vi.spyOn(weakRef, 'deref').mockReturnValue(undefined);
-          mockCount++;
-        }
-      }
-
-      // Validate should clean up dead refs
-      bloc._validateConsumers();
-
-      expect(bloc._consumers.size).toBe(consumerCount / 2);
-    });
-  });
-});

package/src/__tests__/props.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Bloc } from '../Bloc';
-import { Cubit } from '../Cubit';
-import { PropsUpdated } from '../events';
-import { BlacAdapter } from '../adapter/BlacAdapter';
-import { Blac } from '../Blac';
-
-// Test types
-interface TestProps {
-  query: string;
-  filters?: string[];
-}
-
-interface TestState {
-  data: string;
-  loading: boolean;
-}
-
-// Test Cubit with props
-class TestCubit extends Cubit<TestState, TestProps> {
-  onPropsChangedMock = vi.fn();
-
-  constructor() {
-    super({ data: '', loading: false });
-  }
-
-  protected onPropsChanged(oldProps: TestProps | undefined, newProps: TestProps): void {
-    this.onPropsChangedMock(oldProps, newProps);
-    if (oldProps?.query !== newProps.query) {
-      this.emit({ ...this.state, data: `Query: ${newProps.query}` });
-    }
-  }
-
-  loadData = () => {
-    const query = this.props?.query ?? 'default';
-    this.emit({ data: `Loaded: ${query}`, loading: false });
-  };
-}
-
-// Test Bloc with props
-class TestBloc extends Bloc<TestState, PropsUpdated<TestProps>> {
-  constructor() {
-    super({ data: '', loading: false });
-
-    this.on(PropsUpdated<TestProps>, (event, emit) => {
-      emit({ ...this.state, data: `Props: ${event.props.query}` });
-    });
-  }
-}
-
-describe('Props functionality', () => {
-  beforeEach(() => {
-    // Clear Blac instance between tests
-    Blac.resetInstance();
-  });
-
-  describe('PropsUpdated event', () => {
-    it('should create PropsUpdated event with correct props', () => {
-      const props = { query: 'test', filters: ['a', 'b'] };
-      const event = new PropsUpdated(props);
-      
-      expect(event.props).toEqual(props);
-      expect(event.props).toBe(props); // Should be the same reference
-    });
-  });
-
-  describe('Cubit props support', () => {
-    it('should support props getter', () => {
-      const cubit = new TestCubit();
-      expect(cubit.props).toBeNull();
-    });
-
-    it('should update props via _updateProps', () => {
-      const cubit = new TestCubit();
-      const props = { query: 'test' };
-      
-      (cubit as any)._updateProps(props);
-      
-      expect(cubit.props).toEqual(props);
-      expect(cubit.onPropsChangedMock).toHaveBeenCalledWith(null, props);
-    });
-
-    it('should emit state when props change', () => {
-      const cubit = new TestCubit();
-      const props1 = { query: 'test1' };
-      const props2 = { query: 'test2' };
-      
-      (cubit as any)._updateProps(props1);
-      expect(cubit.state.data).toBe('Query: test1');
-      
-      (cubit as any)._updateProps(props2);
-      expect(cubit.state.data).toBe('Query: test2');
-    });
-
-    it('should access props in methods', () => {
-      const cubit = new TestCubit();
-      
-      cubit.loadData();
-      expect(cubit.state.data).toBe('Loaded: default');
-      
-      (cubit as any)._updateProps({ query: 'custom' });
-      cubit.loadData();
-      expect(cubit.state.data).toBe('Loaded: custom');
-    });
-  });
-
-  describe('Bloc props support', () => {
-    it('should handle PropsUpdated events', async () => {
-      const bloc = new TestBloc();
-      const props = { query: 'search' };
-      
-      await bloc.add(new PropsUpdated(props));
-      
-      expect(bloc.state.data).toBe('Props: search');
-    });
-
-    it('should queue PropsUpdated events like any other event', async () => {
-      const bloc = new TestBloc();
-      
-      await bloc.add(new PropsUpdated({ query: 'first' }));
-      await bloc.add(new PropsUpdated({ query: 'second' }));
-      
-      expect(bloc.state.data).toBe('Props: second');
-    });
-  });
-
-  describe('BlacAdapter props ownership', () => {
-    it('should allow first adapter to own props', () => {
-      const Constructor = TestCubit as any;
-      const adapter1 = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        { props: { query: 'test1' } }
-      );
-      
-      expect(() => {
-        adapter1.updateProps({ query: 'test2' });
-      }).not.toThrow();
-    });
-
-    it('should prevent non-owner adapters from updating props', () => {
-      const warnSpy = vi.spyOn(Blac, 'warn').mockImplementation(() => {});
-      const Constructor = TestCubit as any;
-      
-      // First adapter becomes owner
-      const adapter1 = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        { props: { query: 'test1' } }
-      );
-      
-      // Second adapter tries to update props
-      const adapter2 = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        {}
-      );
-      
-      adapter2.updateProps({ query: 'hijack' });
-      
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('non-owner adapter')
-      );
-      
-      warnSpy.mockRestore();
-    });
-
-    it('should clear ownership on adapter unmount', () => {
-      const Constructor = TestCubit as any;
-      const adapter1 = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        { props: { query: 'test1' } }
-      );
-      
-      adapter1.mount();
-      adapter1.unmount();
-      
-      // New adapter should be able to take ownership
-      const adapter2 = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        { props: { query: 'test2' } }
-      );
-      
-      expect(() => {
-        adapter2.updateProps({ query: 'test3' });
-      }).not.toThrow();
-    });
-
-    it('should not update props if they are shallowly equal', () => {
-      const cubit = new TestCubit();
-      const Constructor = TestCubit as any;
-      const adapter = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        {}
-      );
-      
-      const props = { query: 'test' };
-      adapter.updateProps(props);
-      
-      // Reset mock
-      cubit.onPropsChangedMock.mockClear();
-      
-      // Update with same props
-      adapter.updateProps({ query: 'test' });
-      
-      // onPropsChanged should not have been called
-      expect(cubit.onPropsChangedMock).not.toHaveBeenCalled();
-    });
-
-    it('should ignore props updates during disposal', () => {
-      const Constructor = TestCubit as any;
-      const adapter = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        { props: { query: 'test1' } }
-      );
-      
-      // Force disposal state
-      (adapter.blocInstance as any)._disposalState = 'disposing';
-      
-      expect(() => {
-        adapter.updateProps({ query: 'test2' });
-      }).not.toThrow();
-      
-      // Props should not have been updated
-      expect((adapter.blocInstance as TestCubit).props?.query).toBe('test1');
-    });
-  });
-
-  describe('Props integration', () => {
-    it('should dispatch PropsUpdated for Bloc instances', async () => {
-      const Constructor = TestBloc as any;
-      const adapter = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        {}
-      );
-      
-      const bloc = adapter.blocInstance as TestBloc;
-      adapter.updateProps({ query: 'adapter-test' });
-      
-      // Wait for event processing
-      await new Promise(resolve => setTimeout(resolve, 50));
-      
-      expect(bloc.state.data).toBe('Props: adapter-test');
-    });
-
-    it('should call _updateProps for Cubit instances', () => {
-      const Constructor = TestCubit as any;
-      const adapter = new BlacAdapter(
-        { componentRef: { current: {} }, blocConstructor: Constructor },
-        {}
-      );
-      
-      adapter.updateProps({ query: 'adapter-test' });
-      
-      expect((adapter.blocInstance as TestCubit).props?.query).toBe('adapter-test');
-      expect((adapter.blocInstance as TestCubit).state.data).toBe('Query: adapter-test');
-    });
-  });
-});