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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blac/core",
-  "version": "2.0.0-rc-11",
+  "version": "2.0.0-rc-13",
   "license": "MIT",
   "author": "Brendan Mullins <jsnanigans@gmail.com>",
   "main": "dist/index.cjs.js",

package/src/Blac.ts

@@ -6,6 +6,7 @@ import {
   BlocState,
   InferPropsFromGeneric,
 } from './types';
+import { SystemPluginRegistry } from './plugins/SystemPluginRegistry';
 
 /**
  * Configuration options for the Blac instance
@@ -162,6 +163,8 @@ export class Blac {
   keepAliveBlocs: Set<BlocBase<unknown>> = new Set();
   /** Flag to control whether changes should be posted to document */
   postChangesToDocument = false;
+  /** System plugin registry */
+  readonly plugins = new SystemPluginRegistry();
 
   /**
    * Creates a new Blac instance.
@@ -173,6 +176,9 @@ export class Blac {
       return Blac.instance;
     }
     instanceManager.setInstance(this);
+
+    // Bootstrap plugins on creation
+    this.plugins.bootstrap();
   }
 
   /** Flag to enable/disable logging */
@@ -313,6 +319,9 @@ export class Blac {
     // First dispose the bloc to prevent further operations
     bloc._dispose();
 
+    // Notify plugins of bloc disposal
+    this.plugins.notifyBlocDisposed(bloc);
+
     // Then clean up from registries
     if (base.isolated) {
       this.unregisterIsolatedBlocInstance(bloc);
@@ -507,10 +516,16 @@ export class Blac {
 
     if (newBloc.isIsolated) {
       this.registerIsolatedBlocInstance(newBloc);
-      return newBloc;
+    } else {
+      this.registerBlocInstance(newBloc);
     }
 
-    this.registerBlocInstance(newBloc);
+    // Activate bloc plugins
+    newBloc._activatePlugins();
+
+    // Notify system plugins of bloc creation
+    this.plugins.notifyBlocCreated(newBloc);
+
     return newBloc;
   }
 
@@ -786,4 +801,35 @@ export class Blac {
   static get validateConsumers() {
     return Blac.instance.validateConsumers;
   }
+
+  /**
+   * Bootstrap the Blac instance and all plugins
+   */
+  bootstrap(): void {
+    this.plugins.bootstrap();
+  }
+
+  /**
+   * Shutdown the Blac instance and all plugins
+   */
+  shutdown(): void {
+    this.plugins.shutdown();
+
+    // Dispose all non-keepAlive blocs
+    for (const bloc of this.blocInstanceMap.values()) {
+      if (!bloc._keepAlive) {
+        this.disposeBloc(bloc);
+      }
+    }
+
+    for (const blocs of this.isolatedBlocMap.values()) {
+      for (const bloc of blocs) {
+        if (!bloc._keepAlive) {
+          this.disposeBloc(bloc);
+        }
+      }
+    }
+  }
+
+
 }

package/src/BlacObserver.ts

@@ -174,6 +174,9 @@ export class BlacObservable<S = unknown> {
         void observer.fn(newState, oldState, action);
       }
     });
+
+    // Notify system plugins of state change
+    Blac.instance.plugins.notifyStateChanged(this.bloc, oldState, newState);
   }
 
   /**

package/src/Bloc.ts

@@ -55,7 +55,31 @@ export abstract class Bloc<
    * @param action The action/event instance to be processed.
    */
   public add = async (action: A): Promise<void> => {
-    this._eventQueue.push(action);
+    // Transform event through plugins
+    let transformedAction: A | null = action;
+    try {
+      transformedAction = (this._plugins as any).transformEvent(action);
+    } catch (error) {
+      console.error('Error transforming event:', error);
+      // Continue with original event if transformation fails
+    }
+    
+    // If event was cancelled by plugin, don't process it
+    if (transformedAction === null) {
+      return;
+    }
+    
+    // Notify bloc plugins of event
+    try {
+      (this._plugins as any).notifyEvent(transformedAction);
+    } catch (error) {
+      console.error('Error notifying plugins of event:', error);
+    }
+    
+    // Notify system plugins of event
+    Blac.instance.plugins.notifyEventAdded(this as any, transformedAction);
+    
+    this._eventQueue.push(transformedAction);
 
     if (!this._isProcessingEvent) {
       await this._processEventQueue();
@@ -119,6 +143,25 @@ export abstract class Bloc<
           errorContext,
         );
 
+        // Notify plugins of the error
+        if (error instanceof Error) {
+          try {
+            this._plugins.notifyError(error, {
+              phase: 'event-processing',
+              operation: 'handler',
+              metadata: { event: action }
+            });
+            
+            Blac.instance.plugins.notifyError(error, this as any, {
+              phase: 'event-processing',
+              operation: 'handler',
+              metadata: { event: action }
+            });
+          } catch (pluginError) {
+            console.error('Error notifying plugins:', pluginError);
+          }
+        }
+
         if (error instanceof Error && error.name === 'CriticalError') {
           throw error;
         }

package/src/BlocBase.ts

@@ -1,5 +1,7 @@
 import { BlacObservable } from './BlacObserver';
 import { generateUUID } from './utils/uuid';
+import { BlocPlugin, ErrorContext } from './plugins/types';
+import { BlocPluginRegistry } from './plugins/BlocPluginRegistry';
 
 export type BlocInstanceId = string | number | undefined;
 type DependencySelector<S> = (
@@ -32,6 +34,7 @@ export interface StateTransitionResult {
 interface BlocStaticProperties {
   isolated: boolean;
   keepAlive: boolean;
+  plugins?: BlocPlugin<any, any>[];
 }
 
 /**
@@ -158,6 +161,11 @@ export abstract class BlocBase<S, P = unknown> {
    */
   private _consumerRefs = new Map<string, WeakRef<object>>();
 
+  /**
+   * Plugin registry for this bloc instance
+   */
+  protected _plugins: BlocPluginRegistry<S, any>;
+
   /**
    * @internal
    * Validates that all consumer references are still alive
@@ -210,6 +218,16 @@ export abstract class BlocBase<S, P = unknown> {
         : false;
     this._isolated =
       typeof Constructor.isolated === 'boolean' ? Constructor.isolated : false;
+
+    // Initialize plugin registry
+    this._plugins = new BlocPluginRegistry<S, any>();
+
+    // Register static plugins
+    if (Constructor.plugins && Array.isArray(Constructor.plugins)) {
+      for (const plugin of Constructor.plugins) {
+        this.addPlugin(plugin);
+      }
+    }
   }
 
   /**
@@ -529,25 +547,55 @@ export abstract class BlocBase<S, P = unknown> {
       return;
     }
 
+    // Transform state through plugins
+    let transformedState: S = newState;
+    try {
+      const result = this._plugins.transformState(oldState, newState);
+      transformedState = result;
+    } catch (error) {
+      this._plugins.notifyError(error as Error, {
+        phase: 'state-change',
+        operation: 'transformState'
+      });
+      // Continue with original state if transformation fails
+    }
+
     if (this._batchingEnabled) {
       // When batching, just accumulate the updates
-      this._pendingUpdates.push({ newState, oldState, action });
+      this._pendingUpdates.push({ newState: transformedState, oldState, action });
 
       // Update internal state for consistency
       this._oldState = oldState;
-      this._state = newState;
+      this._state = transformedState;
       return;
     }
 
     // Normal state update flow
     this._oldState = oldState;
-    this._state = newState;
+    this._state = transformedState;
+
+    // Notify bloc plugins first
+    try {
+      this._plugins.notifyStateChange(oldState, transformedState);
+    } catch (error) {
+      console.error('Error notifying bloc plugins of state change:', error);
+    }
 
     // Notify observers of the state change
-    this._observer.notify(newState, oldState, action);
+    this._observer.notify(transformedState, oldState, action);
     this.lastUpdate = Date.now();
   };
 
+  /**
+   * Notify observers of a state change
+   * @internal Used by plugins for state hydration
+   * @param newState The new state
+   * @param oldState The old state
+   */
+  _notifyObservers(newState: S, oldState: S): void {
+    this._observer.notify(newState, oldState);
+  }
+
   /**
    * Enables batching for multiple state updates
    * @param batchFn Function to execute with batching enabled
@@ -586,4 +634,59 @@ export abstract class BlocBase<S, P = unknown> {
       this._pendingUpdates = [];
     }
   };
+
+  /**
+   * Add a plugin to this bloc instance
+   */
+  addPlugin(plugin: BlocPlugin<S, any>): void {
+    this._plugins.add(plugin);
+
+    // Attach if already active
+    if (this._disposalState === BlocLifecycleState.ACTIVE) {
+      try {
+        if (plugin.onAttach) {
+          plugin.onAttach(this);
+        }
+      } catch (error) {
+        console.error(`Failed to attach plugin '${plugin.name}':`, error);
+        this._plugins.remove(plugin.name);
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Remove a plugin from this bloc instance
+   */
+  removePlugin(pluginName: string): boolean {
+    return this._plugins.remove(pluginName);
+  }
+
+  /**
+   * Get a plugin by name
+   */
+  getPlugin(pluginName: string): BlocPlugin<S, any> | undefined {
+    return this._plugins.get(pluginName);
+  }
+
+  /**
+   * Get all plugins
+   */
+  getPlugins(): ReadonlyArray<BlocPlugin<S, any>> {
+    return this._plugins.getAll();
+  }
+
+  /**
+   * @internal
+   * Activate plugins when bloc becomes active
+   */
+  _activatePlugins(): void {
+    if (this._disposalState === BlocLifecycleState.ACTIVE) {
+      try {
+        this._plugins.attach(this);
+      } catch (error) {
+        console.error(`Failed to activate plugins for ${this._name}:`, error);
+      }
+    }
+  }
 }