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

package/src/Cubit.ts

@@ -5,23 +5,8 @@ import { BlocBase } from './BlocBase';
  * A Cubit is a simpler version of a Bloc that doesn't handle events.
  * It manages state and provides methods to update it.
  * @template S - The type of state this Cubit manages
- * @template P - The type of parameters (optional, defaults to null)
  */
-export abstract class Cubit<S, P = null> extends BlocBase<S, P> {
-  /**
-   * @internal
-   * Protected method for useBloc to call
-   */
-  protected _updateProps(props: P): void {
-    const oldProps = this.props;
-    this.props = props;
-    this.onPropsChanged?.(oldProps as P | undefined, props);
-  }
-  
-  /**
-   * Optional override for props handling
-   */
-  protected onPropsChanged?(oldProps: P | undefined, newProps: P): void;
+export abstract class Cubit<S> extends BlocBase<S> {
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),

package/src/__tests__/Blac.config.test.ts

@@ -7,7 +7,6 @@ describe('Blac.config', () => {
   beforeEach(() => {
     // Reset to default config before each test
     Blac.setConfig({
-      exposeBlacInstance: false,
       proxyDependencyTracking: true,
     });
   });
@@ -20,26 +19,26 @@ describe('Blac.config', () => {
   describe('setConfig', () => {
     it('should have default configuration', () => {
       expect(Blac.config).toEqual({
-        exposeBlacInstance: false,
         proxyDependencyTracking: true,
       });
     });
 
     it('should update configuration with partial config', () => {
       Blac.setConfig({ proxyDependencyTracking: false });
-      
+
       expect(Blac.config).toEqual({
-        exposeBlacInstance: false,
         proxyDependencyTracking: false,
       });
     });
 
     it('should merge configuration properly', () => {
-      Blac.setConfig({ exposeBlacInstance: true });
+      // First set to false
       Blac.setConfig({ proxyDependencyTracking: false });
-      
+
+      // Then set empty config - should keep false
+      Blac.setConfig({});
+
       expect(Blac.config).toEqual({
-        exposeBlacInstance: true,
         proxyDependencyTracking: false,
       });
     });
@@ -50,16 +49,10 @@ describe('Blac.config', () => {
       }).toThrow('BlacConfig.proxyDependencyTracking must be a boolean');
     });
 
-    it('should throw error for invalid exposeBlacInstance type', () => {
-      expect(() => {
-        Blac.setConfig({ exposeBlacInstance: 1 as any });
-      }).toThrow('BlacConfig.exposeBlacInstance must be a boolean');
-    });
-
     it('should return a copy of config, not the original', () => {
       const config1 = Blac.config;
       const config2 = Blac.config;
-      
+
       expect(config1).not.toBe(config2);
       expect(config1).toEqual(config2);
     });
@@ -67,7 +60,7 @@ describe('Blac.config', () => {
     it('should not allow direct modification of config', () => {
       const config = Blac.config as any;
       config.proxyDependencyTracking = false;
-      
+
       // Original config should remain unchanged
       expect(Blac.config.proxyDependencyTracking).toBe(true);
     });
@@ -78,9 +71,9 @@ describe('Blac.config', () => {
       const testConfig: Partial<BlacConfig> = {
         proxyDependencyTracking: false,
       };
-      
+
       Blac.setConfig(testConfig);
       expect(Blac.config.proxyDependencyTracking).toBe(false);
     });
   });
-});
+});

package/src/__tests__/Bloc.event.test.ts

@@ -104,11 +104,11 @@ describe('Bloc Event Handling', () => {
 
     it('should handle events with proper type inference', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       await bloc.add(new IncrementEvent(5));
 
-      expect(observer).toHaveBeenCalledWith(5, 0, expect.any(IncrementEvent));
+      expect(observer).toHaveBeenCalledWith(5);
       expect(bloc.state).toBe(5);
     });
   });
@@ -116,7 +116,7 @@ describe('Bloc Event Handling', () => {
   describe('Event Queue and Sequential Processing', () => {
     it('should queue events and process them sequentially', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       // Add multiple events rapidly
       const promises = [
@@ -129,30 +129,15 @@ describe('Bloc Event Handling', () => {
 
       // Should be called 3 times with sequential state updates
       expect(observer).toHaveBeenCalledTimes(3);
-      expect(observer).toHaveBeenNthCalledWith(
-        1,
-        1,
-        0,
-        expect.any(IncrementEvent),
-      );
-      expect(observer).toHaveBeenNthCalledWith(
-        2,
-        3,
-        1,
-        expect.any(IncrementEvent),
-      );
-      expect(observer).toHaveBeenNthCalledWith(
-        3,
-        6,
-        3,
-        expect.any(IncrementEvent),
-      );
+      expect(observer).toHaveBeenNthCalledWith(1, 1);
+      expect(observer).toHaveBeenNthCalledWith(2, 3);
+      expect(observer).toHaveBeenNthCalledWith(3, 6);
       expect(bloc.state).toBe(6);
     });
 
     it('should process async events in order', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       // Add async events with different delays
       const promises = [
@@ -165,29 +150,14 @@ describe('Bloc Event Handling', () => {
 
       // Despite different delays, events should process in order
       expect(observer).toHaveBeenCalledTimes(3);
-      expect(observer).toHaveBeenNthCalledWith(
-        1,
-        1,
-        0,
-        expect.any(AsyncIncrementEvent),
-      );
-      expect(observer).toHaveBeenNthCalledWith(
-        2,
-        3,
-        1,
-        expect.any(AsyncIncrementEvent),
-      );
-      expect(observer).toHaveBeenNthCalledWith(
-        3,
-        6,
-        3,
-        expect.any(AsyncIncrementEvent),
-      );
+      expect(observer).toHaveBeenNthCalledWith(1, 1);
+      expect(observer).toHaveBeenNthCalledWith(2, 3);
+      expect(observer).toHaveBeenNthCalledWith(3, 6);
     });
 
     it('should handle mixed sync and async events', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       const promises = [
         bloc.add(new IncrementEvent(1)),
@@ -207,7 +177,7 @@ describe('Bloc Event Handling', () => {
     it('should handle errors in event handlers gracefully', async () => {
       const errorSpy = vi.spyOn(Blac, 'error').mockImplementation(() => {});
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       await bloc.add(new ErrorEvent('Test error'));
 
@@ -250,12 +220,12 @@ describe('Bloc Event Handling', () => {
   describe('Event Context and Metadata', () => {
     it('should pass event instance to state change notifications', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       const event = new IncrementEvent(10);
       await bloc.add(event);
 
-      expect(observer).toHaveBeenCalledWith(10, 0, event);
+      expect(observer).toHaveBeenCalledWith(10);
     });
 
     it('should maintain correct state context during handler execution', async () => {
@@ -293,7 +263,7 @@ describe('Bloc Event Handling', () => {
 
     it('should handle rapid event additions during processing', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
 
       // Custom bloc that adds more events during processing
       class ChainReactionBloc extends Bloc<number> {
@@ -313,7 +283,7 @@ describe('Bloc Event Handling', () => {
 
       const chainBloc = new ChainReactionBloc();
       const chainObserver = vi.fn();
-      chainBloc._observer.subscribe({ id: 'test', fn: chainObserver });
+      chainBloc.subscribe(chainObserver);
 
       await chainBloc.add(new IncrementEvent(1));
 
@@ -338,7 +308,7 @@ describe('Bloc Event Handling', () => {
 
       const multiBloc = new MultiEmitBloc();
       const observer = vi.fn();
-      multiBloc._observer.subscribe({ id: 'test', fn: observer });
+      multiBloc.subscribe(observer);
 
       await multiBloc.add(new IncrementEvent(3));
 
@@ -365,20 +335,25 @@ describe('Bloc Event Handling', () => {
       expect(simpleBloc.state).toBe('handled');
     });
 
-    it('should maintain event processing integrity during disposal', async () => {
+    it('should prevent state updates after disposal is initiated', async () => {
       const observer = vi.fn();
-      bloc._observer.subscribe({ id: 'test', fn: observer });
+      bloc.subscribe(observer);
+      const errorSpy = vi.spyOn(Blac, 'error').mockImplementation(() => {});
 
       // Start async event processing
       const promise = bloc.add(new AsyncIncrementEvent(5, 50));
 
       // Dispose bloc while event is processing
-      setTimeout(() => bloc._dispose(), 25);
+      setTimeout(() => bloc.dispose(), 25);
 
       await promise;
 
-      // Event should complete processing despite disposal attempt
-      expect(bloc.state).toBe(5);
+      // State should not be updated after disposal
+      expect(bloc.state).toBe(0);
+      // Error should be logged about attempted state update on disposed bloc
+      expect(errorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Attempted state update on'),
+      );
     });
   });
 

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

@@ -0,0 +1,349 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { BlocBase } from '../BlocBase';
+import { Blac } from '../Blac';
+
+// Test implementation of BlocBase
+class TestBloc extends BlocBase<{ count: number; message: string }> {
+  constructor(initialState = { count: 0, message: 'initial' }) {
+    super(initialState);
+  }
+
+  increment() {
+    this.emit({ ...this.state, count: this.state.count + 1 });
+  }
+
+  updateMessage(message: string) {
+    this.emit({ ...this.state, message });
+  }
+
+  updateBoth(count: number, message: string) {
+    this.emit({ count, message });
+  }
+}
+
+// Test bloc with static properties
+class KeepAliveBloc extends BlocBase<string> {
+  static keepAlive = true;
+
+  constructor() {
+    super('initial');
+  }
+
+  update(value: string) {
+    this.emit(value);
+  }
+}
+
+describe('BlocBase Subscription Model', () => {
+  let blac: Blac;
+
+  beforeEach(() => {
+    blac = new Blac({ __unsafe_ignore_singleton: true });
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  describe('Basic Subscriptions', () => {
+    it('should subscribe to all state changes', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+
+      const unsubscribe = bloc.subscribe(callback);
+
+      bloc.increment();
+      expect(callback).toHaveBeenCalledWith({ count: 1, message: 'initial' });
+
+      bloc.updateMessage('updated');
+      expect(callback).toHaveBeenCalledWith({ count: 1, message: 'updated' });
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      unsubscribe();
+      bloc.increment();
+      expect(callback).toHaveBeenCalledTimes(2); // No new calls
+    });
+
+    it('should track subscription count', () => {
+      const bloc = new TestBloc();
+
+      expect(bloc.subscriptionCount).toBe(0);
+
+      const unsub1 = bloc.subscribe(() => {});
+      expect(bloc.subscriptionCount).toBe(1);
+
+      const unsub2 = bloc.subscribe(() => {});
+      expect(bloc.subscriptionCount).toBe(2);
+
+      unsub1();
+      expect(bloc.subscriptionCount).toBe(1);
+
+      unsub2();
+      expect(bloc.subscriptionCount).toBe(0);
+    });
+  });
+
+  describe('Selector-based Subscriptions', () => {
+    it('should only notify when selected value changes', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+
+      const unsubscribe = bloc.subscribeWithSelector(
+        (state) => state.count,
+        callback,
+      );
+
+      // Should not be called on subscription
+      expect(callback).not.toHaveBeenCalled();
+
+      bloc.increment();
+      expect(callback).toHaveBeenCalledWith(1);
+
+      // Message update should not trigger callback
+      bloc.updateMessage('updated');
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      bloc.increment();
+      expect(callback).toHaveBeenCalledWith(2);
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      unsubscribe();
+    });
+
+    it('should support custom equality function', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+
+      // Only notify when count changes by more than 2
+      const unsubscribe = bloc.subscribeWithSelector(
+        (state) => state.count,
+        callback,
+        (a, b) => Math.abs(a - b) <= 2,
+      );
+
+      bloc.increment(); // 0 -> 1 (diff = 1, not notified)
+      expect(callback).not.toHaveBeenCalled();
+
+      bloc.increment(); // 1 -> 2 (diff = 1, not notified)
+      expect(callback).not.toHaveBeenCalled();
+
+      bloc.updateBoth(5, 'test'); // 2 -> 5 (diff = 3, notified)
+      expect(callback).toHaveBeenCalledWith(5);
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+    });
+
+    it('should handle complex selectors', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+
+      const unsubscribe = bloc.subscribeWithSelector(
+        (state) => ({
+          doubled: state.count * 2,
+          upper: state.message.toUpperCase(),
+        }),
+        callback,
+      );
+
+      bloc.increment();
+      expect(callback).toHaveBeenCalledWith({ doubled: 2, upper: 'INITIAL' });
+
+      bloc.updateMessage('hello');
+      expect(callback).toHaveBeenCalledWith({ doubled: 2, upper: 'HELLO' });
+
+      unsubscribe();
+    });
+  });
+
+  describe('Component Subscriptions', () => {
+    it('should support weak reference subscriptions', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+      let component: any = { id: 'test-component' };
+      const weakRef = new WeakRef(component);
+
+      const unsubscribe = bloc.subscribeComponent(weakRef, callback);
+
+      bloc.increment();
+      expect(callback).toHaveBeenCalled();
+
+      // Clear strong reference
+      component = null;
+
+      // Force garbage collection (platform-specific)
+      if ((global as any).gc) {
+        (global as any).gc();
+      }
+
+      unsubscribe();
+    });
+  });
+
+  describe('Lifecycle and Disposal', () => {
+    it('should dispose when no subscriptions remain', async () => {
+      const bloc = new TestBloc();
+      const disposeSpy = vi.spyOn(bloc, 'dispose');
+
+      const unsub1 = bloc.subscribe(() => {});
+      const unsub2 = bloc.subscribe(() => {});
+
+      unsub1();
+      expect(disposeSpy).not.toHaveBeenCalled();
+
+      unsub2();
+
+      // Disposal is scheduled with timeout
+      await vi.runAllTimersAsync();
+      expect(disposeSpy).toHaveBeenCalled();
+    });
+
+    it('should not dispose keep-alive blocs', async () => {
+      const bloc = new KeepAliveBloc();
+      const disposeSpy = vi.spyOn(bloc, 'dispose');
+
+      const unsubscribe = bloc.subscribe(() => {});
+      unsubscribe();
+
+      await vi.runAllTimersAsync();
+      expect(disposeSpy).not.toHaveBeenCalled();
+    });
+
+    it('should cancel disposal if new subscription added', async () => {
+      const bloc = new TestBloc();
+      const disposeSpy = vi.spyOn(bloc, 'dispose');
+
+      const unsub1 = bloc.subscribe(() => {});
+      unsub1();
+
+      // Disposal scheduled
+      expect(bloc.subscriptionCount).toBe(0);
+
+      // Add new subscription before disposal
+      const unsub2 = bloc.subscribe(() => {});
+
+      await vi.runAllTimersAsync();
+      expect(disposeSpy).not.toHaveBeenCalled();
+
+      unsub2();
+      await vi.runAllTimersAsync();
+      expect(disposeSpy).toHaveBeenCalled();
+    });
+
+    it('should not allow subscriptions to disposed bloc', async () => {
+      const bloc = new TestBloc();
+      await bloc.dispose();
+
+      const callback = vi.fn();
+      const unsubscribe = bloc.subscribe(callback);
+
+      bloc.increment();
+      expect(callback).not.toHaveBeenCalled();
+
+      unsubscribe();
+    });
+  });
+
+  describe('State Updates and Batching', () => {
+    it('should batch multiple state updates', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+
+      bloc.subscribe(callback);
+
+      bloc._batchUpdates(() => {
+        bloc.increment();
+        bloc.increment();
+        bloc.updateMessage('batched');
+      });
+
+      // Only one notification for the final state
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(callback).toHaveBeenCalledWith({ count: 2, message: 'batched' });
+    });
+
+    it('should not emit undefined states', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+
+      bloc.subscribe(callback);
+
+      // Try to emit undefined
+      (bloc as any).emit(undefined);
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Priority-based Notifications', () => {
+    it('should notify subscriptions in priority order', () => {
+      const bloc = new TestBloc();
+      const order: number[] = [];
+
+      // Direct access to subscription manager for priority testing
+      const manager = bloc._subscriptionManager;
+
+      manager.subscribe({
+        type: 'observer',
+        priority: 1,
+        notify: () => order.push(1),
+      });
+
+      manager.subscribe({
+        type: 'observer',
+        priority: 10,
+        notify: () => order.push(10),
+      });
+
+      manager.subscribe({
+        type: 'observer',
+        priority: 5,
+        notify: () => order.push(5),
+      });
+
+      bloc.increment();
+
+      expect(order).toEqual([10, 5, 1]); // Highest priority first
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle errors in subscription callbacks', () => {
+      const bloc = new TestBloc();
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const goodCallback = vi.fn();
+      const badCallback = vi.fn(() => {
+        throw new Error('Subscription error');
+      });
+
+      bloc.subscribe(badCallback);
+      bloc.subscribe(goodCallback);
+
+      bloc.increment();
+
+      expect(goodCallback).toHaveBeenCalled();
+      expect(badCallback).toHaveBeenCalled();
+
+      errorSpy.mockRestore();
+    });
+
+    it('should handle errors in selectors', () => {
+      const bloc = new TestBloc();
+      const callback = vi.fn();
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      bloc.subscribeWithSelector(() => {
+        throw new Error('Selector error');
+      }, callback);
+
+      bloc.increment();
+      expect(callback).not.toHaveBeenCalled();
+
+      errorSpy.mockRestore();
+    });
+  });
+});