@blac/core 2.0.0-rn-12 → 2.0.1

package/src/BlacObserver.ts

@@ -1,186 +0,0 @@
-import { Blac } from './Blac';
-import { BlocLifecycleState } from './BlocBase';
-import { BlocBase } from './BlocBase';
-import { BlocHookDependencyArrayFn } from './types';
-
-/**
- * Represents an observer that can subscribe to state changes in a Bloc
- * @template S - The type of state being observed
- */
-export type BlacObserver<S> = {
-  /** Function to be called when state changes */
-  fn: (newState: S, oldState: S, action?: unknown) => void | Promise<void>;
-  /** Optional function to determine if the observer should be notified of state changes */
-  dependencyArray?: BlocHookDependencyArrayFn<S>;
-  /** Dispose function for the observer */
-  dispose?: () => void;
-  /** Cached state values used for dependency comparison */
-  lastState?: unknown[];
-  /** Unique identifier for the observer */
-  id: string;
-};
-
-/**
- * A class that manages observers for a Bloc's state changes
- * @template S - The type of state being observed
- */
-export class BlacObservable<S = unknown> {
-  /** The Bloc instance this observable is associated with */
-  bloc: BlocBase<S>;
-
-  /**
-   * Creates a new BlacObservable instance
-   * @param bloc - The Bloc instance to observe
-   */
-  constructor(bloc: BlocBase<S>) {
-    this.bloc = bloc;
-  }
-
-  private _observers = new Set<BlacObserver<S>>();
-
-  /**
-   * Gets the number of active observers
-   * @returns The number of observers currently subscribed
-   */
-  get size(): number {
-    return this._observers.size;
-  }
-
-  /**
-   * Gets the set of all observers
-   * @returns The Set of all BlacObserver instances
-   */
-  get observers() {
-    return this._observers;
-  }
-
-  /**
-   * Subscribes an observer to state changes
-   * @param observer - The observer to subscribe
-   * @returns A function that can be called to unsubscribe the observer
-   */
-  subscribe(observer: BlacObserver<S>): () => void {
-    // Check if bloc is disposed or in disposal process
-    const disposalState = (this.bloc as any)._disposalState;
-    if (
-      disposalState === BlocLifecycleState.DISPOSED ||
-      disposalState === BlocLifecycleState.DISPOSING
-    ) {
-      Blac.log(
-        'BlacObservable.subscribe: Cannot subscribe to disposed/disposing bloc.',
-        this.bloc,
-        observer,
-      );
-      return () => {}; // Return no-op unsubscribe
-    }
-
-    Blac.log(
-      'BlacObservable.subscribe: Subscribing observer.',
-      this.bloc,
-      observer,
-    );
-    this._observers.add(observer);
-
-    // If we're in DISPOSAL_REQUESTED state, cancel the disposal since we have a new observer
-    if (disposalState === BlocLifecycleState.DISPOSAL_REQUESTED) {
-      Blac.log(
-        'BlacObservable.subscribe: Cancelling disposal due to new subscription.',
-        this.bloc,
-      );
-      // Transition back to active state
-      (this.bloc as any)._atomicStateTransition(
-        BlocLifecycleState.DISPOSAL_REQUESTED,
-        BlocLifecycleState.ACTIVE,
-      );
-    }
-
-    // Don't initialize lastState here - let it remain undefined for first-time detection
-    return () => {
-      Blac.log(
-        'BlacObservable.subscribe: Unsubscribing observer.',
-        this.bloc,
-        observer,
-      );
-      this.unsubscribe(observer);
-    };
-  }
-
-  /**
-   * Unsubscribes an observer from state changes
-   * @param observer - The observer to unsubscribe
-   */
-  unsubscribe(observer: BlacObserver<S>) {
-    this._observers.delete(observer);
-    // Blac.instance.dispatchEvent(BlacLifecycleEvent.LISTENER_REMOVED, this.bloc, { listenerId: observer.id });
-
-    if (this.size === 0) {
-      Blac.log('BlacObservable.unsubscribe: No observers left.', this.bloc);
-      // Check if bloc should be disposed when both observers and consumers are gone
-      if (
-        this.bloc._consumers.size === 0 &&
-        !this.bloc._keepAlive &&
-        (this.bloc as any)._disposalState === BlocLifecycleState.ACTIVE
-      ) {
-        Blac.log(
-          `[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`,
-        );
-        (this.bloc as any)._scheduleDisposal();
-      }
-    }
-  }
-
-  /**
-   * Notifies all observers of a state change
-   * @param newState - The new state value
-   * @param oldState - The previous state value
-   * @param action - Optional action that triggered the state change
-   */
-  notify(newState: S, oldState: S, action?: unknown) {
-    this._observers.forEach((observer) => {
-      let shouldUpdate = false;
-
-      if (observer.dependencyArray) {
-        const lastDependencyCheck = observer.lastState;
-        const newDependencyCheck = observer.dependencyArray(
-          newState,
-          oldState,
-          this.bloc,
-        );
-
-        // If this is the first time (no lastState), trigger initial render
-        if (!lastDependencyCheck) {
-          shouldUpdate = true;
-        } else {
-          // Compare dependency arrays
-          if (lastDependencyCheck.length !== newDependencyCheck.length) {
-            shouldUpdate = true;
-          } else {
-            // Compare each dependency value using Object.is (same as React)
-            for (let i = 0; i < newDependencyCheck.length; i++) {
-              if (!Object.is(lastDependencyCheck[i], newDependencyCheck[i])) {
-                shouldUpdate = true;
-                break;
-              }
-            }
-          }
-        }
-
-        observer.lastState = newDependencyCheck;
-      } else {
-        shouldUpdate = true;
-      }
-
-      if (shouldUpdate) {
-        void observer.fn(newState, oldState, action);
-      }
-    });
-  }
-
-  /**
-   * Clears the observer set
-   */
-  clear() {
-    // Just clear the observers without calling unsubscribe to avoid circular disposal
-    this._observers.clear();
-  }
-}

package/src/Bloc.ts

@@ -1,138 +0,0 @@
-import { Blac } from './Blac';
-import { BlocBase } from './BlocBase';
-import { BlocEventConstraint } from './types';
-
-export abstract class Bloc<
-  S, // State type
-  A extends BlocEventConstraint = BlocEventConstraint, // Base Action/Event type with proper constraints
-  P = unknown, // Props type
-> extends BlocBase<S, P> {
-  readonly eventHandlers: Map<
-    new (...args: any[]) => A,
-    (event: A, emit: (newState: S) => void) => void | Promise<void>
-  > = new Map();
-
-  /**
-   * @internal
-   * Event queue to ensure sequential processing of async events
-   */
-  private _eventQueue: A[] = [];
-
-  /**
-   * @internal
-   * Flag indicating if an event is currently being processed
-   */
-  private _isProcessingEvent = false;
-
-  /**
-   * Registers an event handler for a specific event type.
-   * This method is typically called in the constructor of a derived Bloc class.
-   * @param eventConstructor The constructor of the event to handle (e.g., LoadDataEvent).
-   * @param handler A function that processes the event and can emit new states.
-   *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
-   */
-  protected on<E extends A>(
-    eventConstructor: new (...args: any[]) => E,
-    handler: (event: E, emit: (newState: S) => void) => void | Promise<void>,
-  ): void {
-    if (this.eventHandlers.has(eventConstructor)) {
-      Blac.warn(
-        `[Bloc ${this._name}:${String(this._id)}] Handler for event '${eventConstructor.name}' already registered. It will be overwritten.`,
-      );
-    }
-    this.eventHandlers.set(
-      eventConstructor,
-      handler as (
-        event: A,
-        emit: (newState: S) => void,
-      ) => void | Promise<void>,
-    );
-  }
-
-  /**
-   * Dispatches an action/event to the Bloc.
-   * Events are queued and processed sequentially to prevent race conditions.
-   * @param action The action/event instance to be processed.
-   */
-  public add = async (action: A): Promise<void> => {
-    this._eventQueue.push(action);
-
-    if (!this._isProcessingEvent) {
-      await this._processEventQueue();
-    }
-  };
-
-  /**
-   * @internal
-   * Processes events from the queue sequentially
-   */
-  private async _processEventQueue(): Promise<void> {
-    if (this._isProcessingEvent) {
-      return;
-    }
-
-    this._isProcessingEvent = true;
-
-    try {
-      while (this._eventQueue.length > 0) {
-        const action = this._eventQueue.shift()!;
-        await this._processEvent(action);
-      }
-    } finally {
-      this._isProcessingEvent = false;
-    }
-  }
-
-  /**
-   * @internal
-   * Processes a single event
-   */
-  private async _processEvent(action: A): Promise<void> {
-    const eventConstructor = action.constructor as new (...args: any[]) => A;
-    const handler = this.eventHandlers.get(eventConstructor);
-
-    if (handler) {
-      const emit = (newState: S): void => {
-        const previousState = this.state; // State just before this specific emission
-        this._pushState(newState, previousState, action);
-      };
-
-      try {
-        await handler(action, emit);
-      } catch (error) {
-        const constructorName =
-          (action.constructor as { name?: string }).name ||
-          'UnnamedConstructor';
-        const errorContext = {
-          blocName: this._name,
-          blocId: String(this._id),
-          eventType: constructorName,
-          currentState: this.state,
-          action: action,
-          timestamp: new Date().toISOString(),
-        };
-
-        Blac.error(
-          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${constructorName}':`,
-          error,
-          'Context:',
-          errorContext,
-        );
-
-        if (error instanceof Error && error.name === 'CriticalError') {
-          throw error;
-        }
-      }
-    } else {
-      const constructorName =
-        (action.constructor as { name?: string }).name || 'UnnamedConstructor';
-      Blac.warn(
-        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${constructorName}'.`,
-        'Registered handlers:',
-        Array.from(this.eventHandlers.keys()).map((k) => k.name),
-        'Action was:',
-        action,
-      );
-    }
-  }
-}