@blac/core 2.0.0-rc-2 → 2.0.0-rc-4

package/src/BlocBase.ts

@@ -1,6 +1,4 @@
-import { Blac, BlacLifecycleEvent } from './Blac';
 import { BlacObservable } from './BlacObserver';
-import BlacAddon from './addons/BlacAddon';
 import { BlocConstructor } from './types';
 
 export type BlocInstanceId = string | number | undefined;
@@ -10,7 +8,6 @@ type DependencySelector<S> = (newState: S) => unknown[][];
 interface BlocStaticProperties {
   isolated: boolean;
   keepAlive: boolean;
-  addons?: BlacAddon[];
 }
 
 /**
@@ -25,6 +22,7 @@ export abstract class BlocBase<
   S,
   P = unknown
 > {
+  public uid = crypto.randomUUID();
   /**
    * When true, every consumer will receive its own unique instance of this Bloc.
    * Use this when state should not be shared between components.
@@ -50,12 +48,6 @@ export abstract class BlocBase<
    * When provided, observers will only be notified when selected dependencies change.
    */
   defaultDependencySelector: DependencySelector<S> | undefined;
-
-  /**
-   * @internal
-   * Optional array of addons to extend the functionality of this Bloc.
-   */
-  public _addons?: BlacAddon[];
   
   /**
    * @internal
@@ -69,12 +61,6 @@ export abstract class BlocBase<
    */
   public _observer: BlacObservable<S>;
   
-  /**
-   * @internal
-   * Reference to the global Blac manager instance.
-   */
-  public _blac = Blac.getInstance();
-  
   /**
    * The unique identifier for this Bloc instance.
    * Defaults to the class name, but can be customized.
@@ -126,17 +112,14 @@ export abstract class BlocBase<
   constructor(initialState: S) {
     this._state = initialState;
     this._observer = new BlacObservable(this);
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CREATED, this);
     this._id = this.constructor.name;
 
-    // Use a type assertion for the constructor to access static properties safely
-    const constructorWithStaticProps = this.constructor as BlocConstructor<this> & BlocStaticProperties;
-
-    this._keepAlive = constructorWithStaticProps.keepAlive;
-    this._isolated = constructorWithStaticProps.isolated;
-    this._addons = constructorWithStaticProps.addons;
-
-    this._connectAddons();
+    // Access static properties safely with proper type checking
+    const Constructor = this.constructor as typeof BlocBase & BlocStaticProperties;
+    
+    // Validate that the static properties exist and are boolean
+    this._keepAlive = typeof Constructor.keepAlive === 'boolean' ? Constructor.keepAlive : false;
+    this._isolated = typeof Constructor.isolated === 'boolean' ? Constructor.isolated : false;
   }
 
   /**
@@ -174,9 +157,17 @@ export abstract class BlocBase<
    * Notifies the Blac manager and clears all observers.
    */
   _dispose() {
-    this._observer.dispose();
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_DISPOSED, this);
+    // Clear all consumers
+    this._consumers.clear();
+    
+    // Clear observer subscriptions
+    this._observer.clear();
+    
+    // Call user-defined disposal hook
     this.onDispose?.();
+    
+    // The Blac manager will handle removal from registry
+    // This method is called by Blac.disposeBloc, so we don't need to call it again
   }
 
   /**
@@ -191,16 +182,29 @@ export abstract class BlocBase<
    */
   _consumers = new Set<string>();
 
+  /**
+   * @internal
+   * WeakSet to track consumer references for cleanup validation
+   */
+  private _consumerRefs = new WeakSet<object>();
+
   /**
    * @internal
    * Registers a new consumer to this Bloc instance.
    * Notifies the Blac manager that a consumer has been added.
    * 
    * @param consumerId The unique ID of the consumer being added
+   * @param consumerRef Optional reference to the consumer object for cleanup validation
    */
-  _addConsumer = (consumerId: string) => {
+  _addConsumer = (consumerId: string, consumerRef?: object) => {
+    if (this._consumers.has(consumerId)) return;
     this._consumers.add(consumerId);
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_ADDED, this, { consumerId });
+    
+    if (consumerRef) {
+      this._consumerRefs.add(consumerRef);
+    }
+    
+    // this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_ADDED, this, { consumerId });
   };
 
   /**
@@ -211,27 +215,61 @@ export abstract class BlocBase<
    * @param consumerId The unique ID of the consumer being removed
    */
   _removeConsumer = (consumerId: string) => {
-    this._blac.log(`[${this._name}:${String(this._id ?? 'default_id')}] Removing consumer: ${consumerId}`);
+    if (!this._consumers.has(consumerId)) return;
     this._consumers.delete(consumerId);
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_REMOVED, this, { consumerId });
+    // this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_REMOVED, this, { consumerId });
+    
+    // If no consumers remain and not keep-alive, schedule disposal
+    if (this._consumers.size === 0 && !this._keepAlive) {
+      this._scheduleDisposal();
+    }
   };
 
   /**
    * @internal
-   * Initializes all registered addons for this Bloc instance.
-   * Calls the onInit lifecycle method on each addon if defined.
+   * Handler function for disposal (can be set by Blac manager)
    */
-  _connectAddons = () => {
-    const { _addons: addons } = this;
-    if (addons) {
-      addons.forEach(addon => {
-        addon.onInit?.(this);
-      });
-    }
-  };
+  private _disposalHandler?: (bloc: BlocBase<unknown>) => void;
+
+  /**
+   * @internal
+   * Sets the disposal handler for this bloc
+   */
+  _setDisposalHandler(handler: (bloc: BlocBase<unknown>) => void) {
+    this._disposalHandler = handler;
+  }
+
+  /**
+   * @internal
+   * Schedules disposal of this bloc instance if it has no consumers
+   */
+  private _scheduleDisposal() {
+    // Use setTimeout to avoid disposal during render cycles
+    setTimeout(() => {
+      if (this._consumers.size === 0 && !this._keepAlive) {
+        if (this._disposalHandler) {
+          this._disposalHandler(this as any);
+        } else {
+          this._dispose();
+        }
+      }
+    }, 0);
+  }
 
   lastUpdate = Date.now();
 
+  /**
+   * @internal
+   * Flag to indicate if batching is enabled for this bloc
+   */
+  private _batchingEnabled = false;
+
+  /**
+   * @internal
+   * Pending state updates when batching is enabled
+   */
+  private _pendingUpdates: Array<{newState: S, oldState: S, action?: unknown}> = [];
+
   /**
    * @internal
    * Updates the state and notifies all observers of the change.
@@ -241,8 +279,59 @@ export abstract class BlocBase<
    * @param action Optional metadata about what caused the state change
    */
   _pushState = (newState: S, oldState: S, action?: unknown): void => {
+    // Runtime validation for state changes
+    if (newState === undefined) {
+      console.warn('BlocBase._pushState: newState is undefined', this);
+      return;
+    }
+    
+    // Validate action type if provided
+    if (action !== undefined && action !== null) {
+      const actionType = typeof action;
+      if (!(['string', 'object', 'number'].includes(actionType))) {
+        console.warn('BlocBase._pushState: Invalid action type', this, action);
+      }
+    }
+
+    // If batching is enabled, queue the update
+    if (this._batchingEnabled) {
+      this._pendingUpdates.push({ newState, oldState, action });
+      return;
+    }
+    
+    this._oldState = oldState;
     this._state = newState;
     this._observer.notify(newState, oldState, action);
     this.lastUpdate = Date.now();
   };
+
+  /**
+   * Enables batching for multiple state updates
+   * @param batchFn Function to execute with batching enabled
+   */
+  batch = <T>(batchFn: () => T): T => {
+    const wasBatching = this._batchingEnabled;
+    this._batchingEnabled = true;
+    
+    try {
+      const result = batchFn();
+      
+      // Process all pending updates
+      if (this._pendingUpdates.length > 0) {
+        const lastUpdate = this._pendingUpdates[this._pendingUpdates.length - 1];
+        this._oldState = this._pendingUpdates[0].oldState;
+        this._state = lastUpdate.newState;
+        
+        // Notify with the final state
+        this._observer.notify(lastUpdate.newState, this._oldState, lastUpdate.action);
+        this.lastUpdate = Date.now();
+        
+        this._pendingUpdates = [];
+      }
+      
+      return result;
+    } finally {
+      this._batchingEnabled = wasBatching;
+    }
+  };
 }

package/src/index.ts

@@ -1,8 +1,7 @@
 export * from './Blac';
 export * from './BlacObserver';
+export * from './Bloc';
 export * from './BlocBase';
 export * from './Cubit';
-export * from './Bloc';
 export * from './types';
-export * from './BlacPlugin';
-export * from './addons';
+

package/src/BlacObservable.ts

@@ -1,85 +0,0 @@
-import { Blac, BlacLifecycleEvent } from './Blac';
-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>;
-  /** 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 {
-    this._observers.add(observer);
-    Blac.instance.dispatchEvent(BlacLifecycleEvent.LISTENER_ADDED, this.bloc, { listenerId: observer.id });
-    
-    // Immediately notify the new observer with the current state
-    // Pass current state as both newState and oldState for initial notification context
-    void observer.fn(this.bloc.state, this.bloc.state, { initialSubscription: true });
-
-    if (!observer.lastState) {
-      observer.lastState = observer.dependencyArray
-        ? observer.dependencyArray(this.bloc.state)
-        : [];
-    }
-    return () => {
-      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 });
-  }
-}

package/src/BlacPlugin.ts

@@ -1,13 +0,0 @@
-import { BlacLifecycleEvent } from './Blac';
-import { BlocBase } from './BlocBase';
-
-export interface BlacPlugin {
-  name: string;
-
-  onEvent(
-    event: BlacLifecycleEvent,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    bloc: BlocBase<any>,
-    params?: unknown,
-  ): void;
-}

package/src/addons/BlacAddon.ts

@@ -1,17 +0,0 @@
-import { BlocBase } from '../BlocBase';
-
-export type BlacAddonInit = (bloc: BlocBase<any>) => void;
-
-export type BlacAddonEmit = (params: {
-  oldState: unknown;
-  newState: unknown;
-  cubit: BlocBase<any>;
-}) => void;
-
-type BlacAddon = {
-  name: string;
-  onInit?: BlacAddonInit;
-  onEmit?: BlacAddonEmit;
-};
-
-export default BlacAddon;

package/src/addons/Persist.ts

@@ -1,105 +0,0 @@
-import { BlocBase, BlocInstanceId } from '../BlocBase';
-import BlacAddon, { BlacAddonEmit, BlacAddonInit } from './BlacAddon';
-
-type StorageType = 'localStorage' | 'sessionStorage';
-
-function getStorage(type: StorageType): Storage {
-  switch (type) {
-    case 'localStorage':
-      return localStorage;
-    case 'sessionStorage':
-      return sessionStorage;
-    default:
-      return localStorage;
-  }
-}
-
-/**
- * Persist addon
- *
- * @param options
- * @returns BlacAddon
- */
-export function Persist(
-  options: {
-    /**
-     * @default 'blac'
-     */
-    keyPrefix?: string;
-    /**
-     * @default the bloc's id
-     */
-    keyName?: string;
-    /**
-     * Used when the value is not found in storage
-     */
-    defaultValue?: unknown;
-
-    /**
-     * @default 'localStorage'
-     * @see StorageType
-     */
-    storageType?: StorageType;
-
-    /**
-     * @default false
-     */
-    onError?: (e: unknown) => void;
-  } = {},
-): BlacAddon {
-  const {
-    keyPrefix = 'blac',
-    keyName,
-    defaultValue,
-    storageType = 'localStorage',
-  } = options;
-
-  const fullKey = (id: string | BlocInstanceId) => `${keyPrefix}:${String(id)}`;
-
-  const getFromLocalStorage = (id: string | BlocInstanceId): unknown => {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-      const value = getStorage(storageType).getItem(fullKey(id));
-      if (typeof value !== 'string') {
-        return defaultValue;
-      }
-
-      const p = JSON.parse(value) as { v: unknown };
-      if (typeof p.v !== 'undefined') {
-        return p.v;
-      } else {
-        return defaultValue;
-      }
-    } catch (e) {
-      options.onError?.(e);
-      return defaultValue;
-    }
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const onInit: BlacAddonInit = (e: BlocBase<any>) => {
-    const id = keyName ?? e._id;
-
-    const value = getFromLocalStorage(id);
-    e._pushState(value, null);
-  };
-
-  let currentCachedValue = '';
-  const onEmit: BlacAddonEmit = ({ newState, cubit }) => {
-    const id = keyName ?? cubit._id;
-
-    const newValue = JSON.stringify({ v: newState });
-
-    if (newValue !== currentCachedValue) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-      getStorage(storageType).setItem(fullKey(id), newValue);
-      currentCachedValue = newValue;
-    }
-  };
-
-  return {
-    name: 'Persist',
-    onInit,
-    onEmit,
-  };
-}

package/src/addons/index.ts

@@ -1 +0,0 @@
-export * from './Persist';