@blac/core 2.0.0-rc-8 → 2.0.0-rc-11

package/src/testing.ts

@@ -9,7 +9,7 @@ import { BlocEventConstraint } from './types';
  */
 export class BlocTest {
   private static originalInstance: Blac;
-  
+
   /**
    * Sets up a clean test environment
    */
@@ -18,7 +18,7 @@ export class BlocTest {
     Blac.resetInstance();
     Blac.enableLog = false; // Disable logging in tests by default
   }
-  
+
   /**
    * Tears down the test environment and restores original state
    */
@@ -27,7 +27,7 @@ export class BlocTest {
     // 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
    */
@@ -39,31 +39,35 @@ export class BlocTest {
     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
+    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`));
+        reject(
+          new Error(
+            `Timeout waiting for state matching predicate after ${timeout}ms`,
+          ),
+        );
       }, timeout);
-      
+
       const unsubscribe = bloc._observer.subscribe({
-        id: `test-waiter-${crypto.randomUUID()}`,
+        id: `test-waiter-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
         fn: (newState: S) => {
           if (predicate(newState)) {
             clearTimeout(timeoutId);
             unsubscribe();
             resolve(newState);
           }
-        }
+        },
       });
-      
+
       // Check current state immediately
       if (predicate(bloc.state)) {
         clearTimeout(timeoutId);
@@ -72,53 +76,57 @@ export class BlocTest {
       }
     });
   }
-  
+
   /**
    * Expects a bloc to emit specific states in order
    */
   static async expectStates<T extends BlocBase<S>, S>(
     bloc: T,
     expectedStates: S[],
-    timeout = 5000
+    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)}`
-        ));
+        reject(
+          new Error(
+            `Timeout waiting for states. Expected: ${JSON.stringify(expectedStates)}, ` +
+              `Received: ${JSON.stringify(receivedStates)}`,
+          ),
+        );
       }, timeout);
-      
+
       const unsubscribe = bloc._observer.subscribe({
         id: `test-expecter-${crypto.randomUUID()}`,
         fn: (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)}`
-                ));
+                reject(
+                  new Error(
+                    `State mismatch at index ${i}. Expected: ${JSON.stringify(expected)}, ` +
+                      `Received: ${JSON.stringify(received)}`,
+                  ),
+                );
                 return;
               }
             }
-            
+
             resolve();
           }
-        }
+        },
       });
     });
   }
@@ -127,31 +135,37 @@ export class BlocTest {
 /**
  * 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>>();
-  
+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>
+    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
    */
@@ -165,12 +179,12 @@ export class MockBloc<S, A extends BlocEventConstraint = BlocEventConstraint> ex
  */
 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
    */
@@ -178,14 +192,14 @@ export class MockCubit<S> extends Cubit<S> {
     this.stateHistory.push(newState);
     super.emit(newState);
   }
-  
+
   /**
    * Get the history of all states
    */
   getStateHistory(): S[] {
     return [...this.stateHistory];
   }
-  
+
   /**
    * Clear state history
    */
@@ -199,11 +213,11 @@ export class MockCubit<S> extends Cubit<S> {
  */
 export class MemoryLeakDetector {
   private initialStats: ReturnType<typeof Blac.getMemoryStats>;
-  
+
   constructor() {
     this.initialStats = Blac.getMemoryStats();
   }
-  
+
   /**
    * Check for memory leaks and return a report
    */
@@ -213,12 +227,11 @@ export class MemoryLeakDetector {
     stats: ReturnType<typeof Blac.getMemoryStats>;
   } {
     const currentStats = Blac.getMemoryStats();
-    const hasLeaks = (
+    const hasLeaks =
       currentStats.registeredBlocs > this.initialStats.registeredBlocs ||
       currentStats.isolatedBlocs > this.initialStats.isolatedBlocs ||
-      currentStats.keepAliveBlocs > this.initialStats.keepAliveBlocs
-    );
-    
+      currentStats.keepAliveBlocs > this.initialStats.keepAliveBlocs;
+
     const report = `
 Memory Leak Detection Report:
 - Initial registered blocs: ${this.initialStats.registeredBlocs}
@@ -229,11 +242,11 @@ Memory Leak Detection Report:
 - Current keep-alive blocs: ${currentStats.keepAliveBlocs}
 - Potential leaks detected: ${hasLeaks ? 'YES' : 'NO'}
     `.trim();
-    
+
     return {
       hasLeaks,
       report,
-      stats: currentStats
+      stats: currentStats,
     };
   }
-} 
+}

package/src/types.ts

@@ -20,7 +20,10 @@ export type BlocBaseAbstract =
  * Represents a constructor type for a Bloc that can take any parameters
  * @template B - The type of the Bloc instance
  */
-export type BlocConstructor<B> = new (...args: any) => B;
+export type BlocConstructor<B> = (new (...args: any) => B) & {
+  isolated?: boolean;
+  keepAlive?: boolean;
+};
 
 /**
  * Extracts the state type from a BlocBase instance
@@ -53,25 +56,21 @@ export type InferPropsFromGeneric<T> =
 export type BlocConstructorParameters<B extends BlocBase<any>> =
   BlocConstructor<B> extends new (...args: infer P) => B ? P : never;
 
-/**
- * Base interface for all Bloc events
- * Events must be objects with a constructor to enable proper type matching
- */
-export interface BlocEvent {
-  readonly type?: string;
-  readonly timestamp?: number;
-}
-
 /**
  * Enhanced constraint for Bloc events - must be objects with proper constructor
  */
-export type BlocEventConstraint = BlocEvent & object;
+export type BlocEventConstraint = object;
 
 /**
  * Error boundary interface for Bloc error handling
  */
 export interface BlocErrorBoundary<S, A extends BlocEventConstraint> {
-  onError: (error: Error, event: A, currentState: S, bloc: { name: string; id: string }) => void | Promise<void>;
+  onError: (
+    error: Error,
+    event: A,
+    currentState: S,
+    bloc: { name: string; id: string },
+  ) => void | Promise<void>;
   shouldRethrow?: (error: Error, event: A) => boolean;
 }
 
@@ -88,5 +87,5 @@ export interface BlocErrorBoundary<S, A extends BlocEventConstraint> {
 export type BlocHookDependencyArrayFn<S, I = any> = (
   currentState: S,
   previousState: S | undefined,
-  instance: I
+  instance: I,
 ) => unknown[];

package/src/utils/shallowEqual.ts

@@ -0,0 +1,40 @@
+/**
+ * Performs a shallow equality comparison between two values.
+ * For objects, it checks if all top-level properties are equal using Object.is.
+ * @param a First value to compare
+ * @param b Second value to compare
+ * @returns true if values are shallowly equal, false otherwise
+ */
+export function shallowEqual(a: any, b: any): boolean {
+  if (Object.is(a, b)) {
+    return true;
+  }
+
+  if (
+    typeof a !== 'object' ||
+    a === null ||
+    typeof b !== 'object' ||
+    b === null
+  ) {
+    return false;
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (
+      !Object.prototype.hasOwnProperty.call(b, key) ||
+      !Object.is(a[key], b[key])
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/utils/uuid.ts

@@ -14,9 +14,9 @@ export function generateUUID(): string {
   }
 
   // Fallback implementation for React Native/Hermes and older environments
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-    const r = Math.random() * 16 | 0;
-    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
     return v.toString(16);
   });
-}
+}

package/src/BlacEvent.ts

@@ -1,5 +0,0 @@
-export default class BlacEvent<T = any> extends CustomEvent<T> {
-  constructor(type: string, eventInitDict?: CustomEventInit<T> | undefined) {
-    super(type, eventInitDict);
-  }
-}