@blac/core 2.0.0-rn-12 → 2.0.1

package/src/testing.ts

@@ -1,252 +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._observer.subscribe({
-        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);
-        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._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)}`,
-                  ),
-                );
-                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,
-    };
-  }
-}

package/src/types.ts

@@ -1,91 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Bloc } from './Bloc';
-import { BlocBase } from './BlocBase';
-import { Cubit } from './Cubit';
-
-/**
- * Represents a constructor type for a Bloc that takes no parameters
- * @template B - The type of the Bloc instance
- */
-export type BlocClassNoParams<B> = new (args: never[]) => B;
-
-/**
- * Represents the abstract base types for Bloc and Cubit
- */
-export type BlocBaseAbstract =
-  | typeof Bloc<any, any, any>
-  | typeof Cubit<any, any>;
-
-/**
- * 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) & {
-  isolated?: boolean;
-  keepAlive?: boolean;
-};
-
-/**
- * Extracts the state type from a BlocBase instance
- * @template B - The BlocBase type to extract the state from
- */
-export type ValueType<B extends BlocBase<any>> =
-  B extends BlocBase<infer U> ? U : never;
-
-/**
- * Extracts the state type from either a Bloc or Cubit
- * @template T - The Bloc or Cubit type to extract the state from
- */
-export type BlocState<T> = T extends BlocBase<infer S> ? S : never;
-
-/**
- * Extracts the props type from either a Bloc or Cubit
- * @template T - The Bloc or Cubit type to extract the props from
- */
-export type InferPropsFromGeneric<T> =
-  T extends Bloc<any, any, infer P>
-    ? P
-    : T extends Cubit<any, infer P>
-      ? P
-      : never;
-
-/**
- * Extracts the constructor parameters type from a BlocBase
- * @template B - The BlocBase type to extract the constructor parameters from
- */
-export type BlocConstructorParameters<B extends BlocBase<any>> =
-  BlocConstructor<B> extends new (...args: infer P) => B ? P : never;
-
-/**
- * Enhanced constraint for Bloc events - must be objects with proper constructor
- */
-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>;
-  shouldRethrow?: (error: Error, event: A) => boolean;
-}
-
-/**
- * Function type for determining dependencies that trigger re-renders
- * Similar to React's useEffect dependency array - if any dependency changes, a re-render is triggered
- * @template S The state type
- * @template I The bloc instance type
- * @param currentState The current state
- * @param previousState The previous state (undefined on first call)
- * @param instance The bloc instance
- * @returns Array of dependencies - if any dependency changes, a re-render is triggered
- */
-export type BlocHookDependencyArrayFn<S, I = any> = (
-  currentState: S,
-  previousState: S | undefined,
-  instance: I,
-) => unknown[];

package/src/utils/shallowEqual.ts

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1,22 +0,0 @@
-/**
- * Cross-platform UUID v4 generator that works in all environments including React Native/Hermes
- * Falls back to crypto.randomUUID() when available, otherwise uses Math.random()
- */
-
-/**
- * Generates a UUID v4 string compatible with all JavaScript environments
- * @returns A UUID v4 string in the format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
- */
-export function generateUUID(): string {
-  // Try to use crypto.randomUUID() if available (Node.js 16+, modern browsers)
-  if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-
-  // 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 v.toString(16);
-  });
-}