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

package/src/__tests__/Cubit.test.ts

@@ -69,11 +69,11 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       cubit.increment();
 
-      expect(observer).toHaveBeenCalledWith(1, 0, undefined);
+      expect(observer).toHaveBeenCalledWith(1);
       expect(cubit.state).toBe(1);
     });
 
@@ -81,7 +81,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit(5);
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Try to emit same value
       cubit.set(5);
@@ -94,7 +94,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit(NaN);
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // NaN === NaN is false, but Object.is(NaN, NaN) is true
       cubit.set(NaN);
@@ -106,28 +106,28 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit(0);
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Object.is can distinguish +0 and -0
       cubit.set(-0);
 
-      expect(observer).toHaveBeenCalledWith(-0, 0, undefined);
+      expect(observer).toHaveBeenCalledWith(-0);
     });
 
     it('should emit multiple state changes sequentially', () => {
       const cubit = new CounterCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       cubit.increment();
       cubit.increment();
       cubit.decrement();
 
       expect(observer).toHaveBeenCalledTimes(3);
-      expect(observer).toHaveBeenNthCalledWith(1, 1, 0, undefined);
-      expect(observer).toHaveBeenNthCalledWith(2, 2, 1, undefined);
-      expect(observer).toHaveBeenNthCalledWith(3, 1, 2, undefined);
+      expect(observer).toHaveBeenNthCalledWith(1, 1);
+      expect(observer).toHaveBeenNthCalledWith(2, 2);
+      expect(observer).toHaveBeenNthCalledWith(3, 1);
       expect(cubit.state).toBe(1);
     });
   });
@@ -137,23 +137,15 @@ describe('Cubit State Emissions', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       cubit.updateName('Jane Doe');
 
-      expect(observer).toHaveBeenCalledWith(
-        {
-          name: 'Jane Doe',
-          age: 30,
-          email: 'john@example.com',
-        },
-        {
-          name: 'John Doe',
-          age: 30,
-          email: 'john@example.com',
-        },
-        undefined,
-      );
+      expect(observer).toHaveBeenCalledWith({
+        name: 'Jane Doe',
+        age: 30,
+        email: 'john@example.com',
+      });
       expect(cubit.state.name).toBe('Jane Doe');
       expect(cubit.state.age).toBe(30); // Unchanged
     });
@@ -162,7 +154,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       cubit.updateMultiple({ name: 'Jane Smith', age: 25 });
 
@@ -178,7 +170,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Patch with same values
       cubit.patch({ name: 'John Doe', age: 30 });
@@ -190,7 +182,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // One value different
       cubit.patch({ name: 'John Doe', age: 31 });
@@ -203,7 +195,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       cubit.setPreferences('dark', true);
 
@@ -218,7 +210,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Force emit even with same values
       cubit.patch({ name: 'John Doe' }, true);
@@ -278,7 +270,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new ArrayCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // New array reference should trigger update
       cubit.add(4);
@@ -306,13 +298,13 @@ describe('Cubit State Emissions', () => {
       const cubit = new NullableCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // null and undefined are different according to Object.is
       expect(Object.is(null, undefined)).toBe(false);
 
       cubit.setNull();
-      expect(observer).toHaveBeenCalledWith(null, 'initial', undefined);
+      expect(observer).toHaveBeenCalledWith(null);
       expect(cubit.state).toBe(null);
 
       observer.mockClear();
@@ -328,7 +320,7 @@ describe('Cubit State Emissions', () => {
 
       observer.mockClear();
       cubit.setString('value');
-      expect(observer).toHaveBeenCalledWith('value', null, undefined);
+      expect(observer).toHaveBeenCalledWith('value');
       expect(cubit.state).toBe('value');
     });
 
@@ -354,7 +346,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new ComplexCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Different object reference with same values
       cubit.updateData({ id: 1, values: [1, 2, 3] });
@@ -369,19 +361,18 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit();
 
       // Should have BlocBase properties and methods
-      expect(cubit._state).toBe(0);
-      expect(cubit._observer).toBeDefined();
-      expect(cubit._consumers).toBeDefined();
-      expect(typeof cubit._addConsumer).toBe('function');
+      expect(cubit.state).toBe(0);
+      expect(cubit._subscriptionManager).toBeDefined();
+      expect(typeof cubit.subscribe).toBe('function');
     });
 
     it('should work with state batching', () => {
       const cubit = new CounterCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
-      cubit.batch(() => {
+      cubit._batchUpdates(() => {
         cubit.increment(); // 0 -> 1
         cubit.increment(); // 1 -> 2
         cubit.increment(); // 2 -> 3
@@ -390,7 +381,7 @@ describe('Cubit State Emissions', () => {
       // Should only notify once with final state
       // The oldState in the batch notification is from the last update (2 -> 3)
       expect(observer).toHaveBeenCalledTimes(1);
-      expect(observer).toHaveBeenCalledWith(3, 2, undefined);
+      expect(observer).toHaveBeenCalledWith(3);
       expect(cubit.state).toBe(3);
     });
 
@@ -398,12 +389,11 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit();
 
       cubit.increment();
-      expect(cubit._oldState).toBe(0);
-      expect(cubit._state).toBe(1);
+      // Old state tracking was removed in new model
+      expect(cubit.state).toBe(1);
 
       cubit.increment();
-      expect(cubit._oldState).toBe(1);
-      expect(cubit._state).toBe(2);
+      expect(cubit.state).toBe(2);
     });
   });
 
@@ -412,7 +402,7 @@ describe('Cubit State Emissions', () => {
       const cubit = new CounterCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Rapid emissions
       for (let i = 0; i < 1000; i++) {
@@ -422,16 +412,15 @@ describe('Cubit State Emissions', () => {
       expect(cubit.state).toBe(1000);
       expect(observer).toHaveBeenCalledTimes(1000);
 
-      // Check no accumulation of state
-      expect(cubit._state).toBe(1000);
-      expect(cubit._oldState).toBe(999);
+      // Check final state
+      expect(cubit.state).toBe(1000);
     });
 
     it('should handle concurrent patch operations', () => {
       const cubit = new UserCubit();
       const observer = vi.fn();
 
-      cubit._observer.subscribe({ id: 'test', fn: observer });
+      cubit.subscribe(observer);
 
       // Multiple patches in quick succession
       cubit.patch({ name: 'Name1' });

package/src/__tests__/memory-leaks.test.ts

@@ -0,0 +1,383 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Blac } from '../Blac';
+import { Cubit } from '../Cubit';
+import { Bloc } from '../Bloc';
+import { BlacAdapter } from '../adapter/BlacAdapter';
+
+// Helper to force garbage collection if available
+const forceGC = () => {
+  if ((global as any).gc) {
+    (global as any).gc();
+  }
+};
+
+// Helper to wait for WeakRef cleanup
+const waitForCleanup = async (checkFn: () => boolean, maxWait = 1000) => {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    forceGC();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    if (checkFn()) return true;
+  }
+  return false;
+};
+
+// Test state class
+class TestState {
+  constructor(public value: number) {}
+}
+
+// Test Cubit
+class TestCubit extends Cubit<TestState> {
+  constructor() {
+    super(new TestState(0));
+  }
+
+  increment = () => {
+    this.emit(new TestState(this.state.value + 1));
+  };
+}
+
+// Test event
+class IncrementEvent {
+  constructor(public amount: number) {}
+}
+
+// Test Bloc
+class TestBloc extends Bloc<TestState, IncrementEvent> {
+  constructor() {
+    super(new TestState(0));
+    this.on(IncrementEvent, this.handleIncrement);
+  }
+
+  handleIncrement = (
+    event: IncrementEvent,
+    emit: (state: TestState) => void,
+  ) => {
+    emit(new TestState(this.state.value + event.amount));
+  };
+}
+
+describe('Memory Leak Tests', () => {
+  let blac: Blac;
+
+  beforeEach(() => {
+    blac = Blac.getInstance();
+    Blac.enableLog = false; // Disable logging for tests
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    Blac.resetInstance();
+  });
+
+  describe('WeakRef Cleanup', () => {
+    it('should support component WeakRefs for automatic cleanup', async () => {
+      const cubit = blac.getBloc(TestCubit);
+      let component: any = { id: 'test-component' };
+      const weakRef = new WeakRef(component);
+
+      // Subscribe with component reference
+      const unsubscribe = cubit.subscribeComponent(weakRef, () => {});
+      expect(cubit.subscriptionCount).toBe(1);
+
+      // Verify the subscription works
+      const callback = vi.fn();
+      cubit.subscribeComponent(weakRef, callback);
+      cubit.increment();
+      expect(callback).toHaveBeenCalled();
+
+      // Clean up
+      unsubscribe();
+    });
+
+    it('should handle multiple subscriptions with weak references', async () => {
+      const cubit = blac.getBloc(TestCubit);
+      const component1 = { id: 'component-1' };
+      const component2 = { id: 'component-2' };
+      const component3 = { id: 'component-3' };
+
+      // Add subscriptions with weak refs
+      const unsub1 = cubit.subscribeComponent(
+        new WeakRef(component1),
+        () => {},
+      );
+      const unsub2 = cubit.subscribeComponent(
+        new WeakRef(component2),
+        () => {},
+      );
+      const unsub3 = cubit.subscribeComponent(
+        new WeakRef(component3),
+        () => {},
+      );
+
+      expect(cubit.subscriptionCount).toBe(3);
+
+      // Remove some subscriptions
+      unsub1();
+      unsub2();
+
+      expect(cubit.subscriptionCount).toBe(1);
+
+      // Clean up remaining
+      unsub3();
+      expect(cubit.subscriptionCount).toBe(0);
+    });
+  });
+
+  describe('Bloc Instance Disposal', () => {
+    it('should dispose non-keepAlive blocs when no consumers remain', async () => {
+      const cubit = blac.getBloc(TestCubit);
+      const adapter = new BlacAdapter(
+        { blocConstructor: TestCubit, componentRef: { current: {} } },
+        {},
+      );
+
+      // Subscribe and unsubscribe
+      adapter.mount();
+      const unsubscribe = adapter.createSubscription({ onChange: () => {} });
+      expect(cubit.subscriptionCount).toBe(1);
+
+      unsubscribe();
+      adapter.unmount();
+
+      // Wait for disposal
+      await vi.runAllTimersAsync();
+
+      // Bloc should be disposed
+      expect(cubit.isDisposed).toBe(true);
+    });
+
+    it('should not dispose keepAlive blocs when no consumers remain', async () => {
+      class KeepAliveCubit extends TestCubit {
+        static keepAlive = true;
+      }
+
+      const cubit = blac.getBloc(KeepAliveCubit);
+      const adapter = new BlacAdapter(
+        { blocConstructor: KeepAliveCubit, componentRef: { current: {} } },
+        {},
+      );
+
+      // Subscribe and unsubscribe
+      adapter.mount();
+      const unsubscribe = adapter.createSubscription({ onChange: () => {} });
+      expect(cubit.subscriptionCount).toBe(1);
+
+      unsubscribe();
+
+      // Wait for potential disposal
+      await vi.runAllTimersAsync();
+
+      // Bloc should still be active
+      expect(cubit.isDisposed).toBe(false);
+    });
+  });
+
+  describe('Memory Pressure Scenarios', () => {
+    it('should handle rapid subscription addition/removal without leaks', async () => {
+      const cubit = blac.getBloc(TestCubit);
+      const unsubscribes: (() => void)[] = [];
+
+      // Add many subscriptions
+      for (let i = 0; i < 1000; i++) {
+        const unsub = cubit.subscribe(() => {});
+        unsubscribes.push(unsub);
+      }
+
+      expect(cubit.subscriptionCount).toBe(1000);
+
+      // Remove half the subscriptions
+      for (let i = 0; i < 500; i++) {
+        unsubscribes[i]();
+      }
+
+      expect(cubit.subscriptionCount).toBe(500);
+
+      // Remove remaining subscriptions
+      for (let i = 500; i < 1000; i++) {
+        unsubscribes[i]();
+      }
+
+      expect(cubit.subscriptionCount).toBe(0);
+    });
+
+    it('should handle concurrent bloc creation and disposal', async () => {
+      const adapters: BlacAdapter<typeof TestBloc>[] = [];
+      const unsubscribes: (() => void)[] = [];
+
+      // Create many blocs through adapters
+      for (let i = 0; i < 100; i++) {
+        const adapter = new BlacAdapter(
+          { blocConstructor: TestBloc, componentRef: { current: {} } },
+          { instanceId: `test-bloc-${i}` },
+        );
+        adapters.push(adapter);
+        adapter.mount();
+        const unsub = adapter.createSubscription({ onChange: () => {} });
+        unsubscribes.push(unsub);
+      }
+
+      // Unsubscribe all and unmount
+      unsubscribes.forEach((unsub) => unsub());
+      adapters.forEach((adapter) => adapter.unmount());
+
+      // Wait for disposal
+      await vi.runAllTimersAsync();
+
+      // All blocs should be disposed
+      for (const adapter of adapters) {
+        expect(adapter.blocInstance.isDisposed).toBe(true);
+      }
+    });
+  });
+
+  describe('Proxy and Cache Cleanup', () => {
+    it('should not leak memory through proxy caches', async () => {
+      const { ProxyFactory } = await import('../adapter/ProxyFactory');
+      const { createStateProxy, getStats, resetStats } = ProxyFactory;
+      const stats = getStats();
+      const initialProxyCount = stats.stateProxiesCreated || 0;
+
+      // Create many proxied states
+      for (let i = 0; i < 100; i++) {
+        const cubit = new TestCubit();
+        const proxy = createStateProxy({
+          target: cubit.state,
+          consumerRef: { current: {} },
+          consumerTracker: {
+            trackAccess: () => {},
+          } as any,
+        });
+        // Access properties to trigger proxy creation
+        const _ = proxy.value;
+      }
+
+      // Proxies should have been created
+      const newStats = getStats();
+      expect(newStats.stateProxiesCreated || 0).toBeGreaterThan(
+        initialProxyCount,
+      );
+
+      // Clear stats
+      resetStats();
+      const clearedStats = getStats();
+      expect(clearedStats.stateProxiesCreated || 0).toBe(0);
+    });
+  });
+
+  describe('Event Queue Memory Management', () => {
+    it('should not accumulate events in queue indefinitely', async () => {
+      const bloc = blac.getBloc(TestBloc);
+
+      // Add many events rapidly
+      for (let i = 0; i < 1000; i++) {
+        bloc.add(new IncrementEvent(1));
+      }
+
+      // Wait for processing
+      await vi.runAllTimersAsync();
+
+      // Queue should be empty after processing
+      expect((bloc as any)._eventQueue.length).toBe(0);
+    });
+
+    it('should handle disposal during event processing', async () => {
+      const bloc = blac.getBloc(TestBloc);
+      const adapter = new BlacAdapter(
+        { blocConstructor: TestBloc, componentRef: { current: {} } },
+        {},
+      );
+
+      // Subscribe
+      adapter.mount();
+      const unsubscribe = adapter.createSubscription({ onChange: () => {} });
+
+      // Add events and immediately dispose
+      for (let i = 0; i < 10; i++) {
+        bloc.add(new IncrementEvent(1));
+      }
+
+      unsubscribe();
+      adapter.unmount();
+
+      // Wait for disposal
+      await vi.runAllTimersAsync();
+
+      // Bloc should be disposed and queue cleared
+      expect(bloc.isDisposed).toBe(true);
+      expect((bloc as any)._eventQueue.length).toBe(0);
+    });
+  });
+
+  describe('Disposal State Transitions', () => {
+    it('should handle concurrent disposal requests safely', async () => {
+      const cubit = blac.getBloc(TestCubit);
+      const adapter = new BlacAdapter(
+        { blocConstructor: TestCubit, componentRef: { current: {} } },
+        {},
+      );
+
+      // Add multiple consumers
+      adapter.mount();
+      const unsub1 = adapter.createSubscription({ onChange: () => {} });
+      const adapter2 = new BlacAdapter(
+        { blocConstructor: TestCubit, componentRef: { current: {} } },
+        {},
+      );
+      adapter2.mount();
+      const unsub2 = adapter2.createSubscription({ onChange: () => {} });
+
+      // Remove consumers concurrently
+      await Promise.all([
+        (async () => {
+          unsub1();
+          adapter.unmount();
+        })(),
+        (async () => {
+          unsub2();
+          adapter2.unmount();
+        })(),
+      ]);
+
+      // Wait for disposal
+      await vi.runAllTimersAsync();
+
+      // Should be disposed exactly once
+      expect(cubit.isDisposed).toBe(true);
+    });
+
+    it('should prevent state updates after disposal', async () => {
+      const cubit = blac.getBloc(TestCubit);
+      const adapter = new BlacAdapter(
+        { blocConstructor: TestCubit, componentRef: { current: {} } },
+        {},
+      );
+
+      // Subscribe and start disposal
+      adapter.mount();
+      const unsub = adapter.createSubscription({ onChange: () => {} });
+      unsub();
+      adapter.unmount();
+
+      // Wait for disposal to complete
+      await vi.runAllTimersAsync();
+
+      expect(cubit.isDisposed).toBe(true);
+
+      // Try to update state after disposal
+      const callback = vi.fn();
+      const unsubscribe = cubit.subscribe(callback);
+
+      // State should not change
+      const initialState = cubit.state;
+      cubit.increment();
+
+      // State should remain unchanged
+      expect(cubit.state).toBe(initialState);
+      expect(callback).not.toHaveBeenCalled();
+      unsubscribe();
+    });
+  });
+});