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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blac/core",
-  "version": "2.0.0-rc-11",
+  "version": "2.0.0-rc-14",
   "license": "MIT",
   "author": "Brendan Mullins <jsnanigans@gmail.com>",
   "main": "dist/index.cjs.js",
@@ -27,16 +27,15 @@
     "@testing-library/jest-dom": "^6.6.4",
     "@testing-library/user-event": "^14.6.1",
     "@vitest/browser": "^3.2.4",
-    "jsdom": "^24.1.1",
+    "jsdom": "^26.1.0",
     "prettier": "^3.6.2",
-    "typescript": "^5.8.3",
-    "vite": "^5.3.1",
+    "typescript": "^5.9.2",
+    "vite": "^7.0.6",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "^1.6.0"
+    "vitest": "^3.2.4"
   },
   "scripts": {
-    "prettier": "prettier --write ./src",
-    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx}\"",
+    "format": "prettier --write \".\"",
     "test": "vitest run",
     "test:watch": "vitest --watch",
     "coverage": "vitest run --coverage",

package/src/Blac.ts

@@ -1,18 +1,19 @@
-import { BlocBase, BlocInstanceId, BlocLifecycleState } from './BlocBase';
+import { BlocBase, BlocInstanceId } from './BlocBase';
+import { BlocLifecycleState } from './lifecycle/BlocLifecycle';
 import {
   BlocBaseAbstract,
   BlocConstructor,
   BlocHookDependencyArrayFn,
   BlocState,
-  InferPropsFromGeneric,
 } from './types';
+import { SystemPluginRegistry } from './plugins/SystemPluginRegistry';
+import { BlacError, ErrorCategory, ErrorSeverity } from './errors/BlacError';
+import { ErrorManager } from './errors/ErrorManager';
 
 /**
  * Configuration options for the Blac instance
  */
 export interface BlacConfig {
-  /** Whether to expose the Blac instance globally */
-  exposeBlacInstance?: boolean;
   /**
    * Whether to enable proxy dependency tracking for automatic re-render optimization.
    * When false, state changes always cause re-renders unless dependencies are manually specified.
@@ -24,7 +25,7 @@ export interface BlacConfig {
 export interface GetBlocOptions<B extends BlocBase<unknown>> {
   id?: string;
   selector?: BlocHookDependencyArrayFn<BlocState<B>>;
-  props?: InferPropsFromGeneric<B>;
+  constructorParams?: ConstructorParameters<BlocConstructor<B>>[];
   onMount?: (bloc: B) => void;
   instanceRef?: string;
   throwIfNotFound?: boolean;
@@ -104,13 +105,13 @@ export class Blac {
   }
   /** Timestamp when the instance was created */
   createdAt = Date.now();
+  private errorManager = ErrorManager.getInstance();
   static get getAllBlocs() {
     return Blac.instance.getAllBlocs;
   }
 
   /** Private static configuration */
   private static _config: BlacConfig = {
-    exposeBlacInstance: false,
     proxyDependencyTracking: true,
   };
 
@@ -126,14 +127,16 @@ export class Blac {
    */
   static setConfig(config: Partial<BlacConfig>): void {
     // Validate config
-    if (config.proxyDependencyTracking !== undefined &&
-        typeof config.proxyDependencyTracking !== 'boolean') {
-      throw new Error('BlacConfig.proxyDependencyTracking must be a boolean');
-    }
-
-    if (config.exposeBlacInstance !== undefined &&
-        typeof config.exposeBlacInstance !== 'boolean') {
-      throw new Error('BlacConfig.exposeBlacInstance must be a boolean');
+    if (
+      config.proxyDependencyTracking !== undefined &&
+      typeof config.proxyDependencyTracking !== 'boolean'
+    ) {
+      const error = new BlacError(
+        'BlacConfig.proxyDependencyTracking must be a boolean',
+        ErrorCategory.VALIDATION,
+        ErrorSeverity.FATAL,
+      );
+      this.instance.errorManager.handle(error);
     }
 
     // Merge with existing config
@@ -162,6 +165,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 +178,9 @@ export class Blac {
       return Blac.instance;
     }
     instanceManager.setInstance(this);
+
+    // Bootstrap plugins on creation
+    this.plugins.bootstrap();
   }
 
   /** Flag to enable/disable logging */
@@ -213,9 +221,7 @@ export class Blac {
    * @param args - Additional arguments
    */
   warn = (message: string, ...args: unknown[]) => {
-    if (Blac.enableLog) {
-      // Logging disabled - console.warn removed
-    }
+    console.warn(message, ...args);
   };
   static get warn() {
     return Blac.instance.warn;
@@ -227,7 +233,7 @@ export class Blac {
    */
   error = (message: string, ...args: unknown[]) => {
     if (Blac.enableLog) {
-      // Logging disabled - console.error removed
+      console.error(message, ...args);
     }
   };
   static get error() {
@@ -311,7 +317,10 @@ export class Blac {
     );
 
     // First dispose the bloc to prevent further operations
-    bloc._dispose();
+    bloc.dispose();
+
+    // Notify plugins of bloc disposal
+    this.plugins.notifyBlocDisposed(bloc);
 
     // Then clean up from registries
     if (base.isolated) {
@@ -384,6 +393,12 @@ export class Blac {
 
     const key = this.createBlocInstanceMapKey(blocClass.name, id);
     const found = this.blocInstanceMap.get(key) as InstanceType<B> | undefined;
+
+    // Don't return disposed blocs
+    if (found && (found as any).isDisposed) {
+      return undefined;
+    }
+
     return found;
   }
 
@@ -468,7 +483,7 @@ export class Blac {
       return undefined;
     }
     // Find the specific bloc by ID within the isolated array
-    const found = blocs.find((b) => b._id === id) as
+    const found = blocs.find((b) => b._id === id && !(b as any).isDisposed) as
       | InstanceType<B>
       | undefined;
     return found;
@@ -496,21 +511,26 @@ export class Blac {
     id: BlocInstanceId,
     options: GetBlocOptions<InstanceType<B>> = {},
   ): InstanceType<B> {
-    const { props, instanceRef } = options;
-    const newBloc = new blocClass(props as never) as InstanceType<B>;
+    const { constructorParams, instanceRef } = options;
+    const newBloc = new blocClass(constructorParams) as InstanceType<B>;
+    newBloc.blacInstance = this;
     newBloc._instanceRef = instanceRef;
-    newBloc.props = props || null;
-    newBloc._updateId(id);
+    newBloc._id = id;
 
     // Set up disposal handler to break circular dependency
-    newBloc._setDisposalHandler((bloc) => this.disposeBloc(bloc));
+    newBloc.setDisposalHandler((bloc) => this.disposeBloc(bloc));
 
     if (newBloc.isIsolated) {
       this.registerIsolatedBlocInstance(newBloc);
-      return newBloc;
+    } else {
+      this.registerBlocInstance(newBloc);
     }
 
-    this.registerBlocInstance(newBloc);
+    // Plugins are activated in constructor
+
+    // Notify system plugins of bloc creation
+    this.plugins.notifyBlocCreated(newBloc);
+
     return newBloc;
   }
 
@@ -617,38 +637,6 @@ export class Blac {
     return Blac.instance.getBloc;
   }
 
-  /**
-   * Gets a bloc instance or throws an error if it doesn't exist
-   * @param blocClass - The bloc class to get
-   * @param options - Options including:
-   *   - id: The instance ID (defaults to class name if not provided)
-   *   - props: Properties to pass to the bloc constructor
-   *   - instanceRef: Optional reference string for the instance
-   */
-  getBlocOrThrow = <B extends BlocConstructor<any>>(
-    blocClass: B,
-    options: {
-      id?: BlocInstanceId;
-      props?: InferPropsFromGeneric<B>;
-      instanceRef?: string;
-    } = {},
-  ): InstanceType<B> => {
-    const isIsolated = (blocClass as unknown as BlocBaseAbstract).isolated;
-    const id = options.id || blocClass.name;
-
-    const registered = isIsolated
-      ? this.findIsolatedBlocInstance(blocClass, id)
-      : this.findRegisteredBlocInstance(blocClass, id);
-
-    if (registered) {
-      return registered;
-    }
-    throw new Error(`Bloc ${blocClass.name} not found`);
-  };
-  static get getBlocOrThrow() {
-    return Blac.instance.getBlocOrThrow;
-  }
-
   /**
    * Gets all instances of a specific bloc class
    * @param blocClass - The bloc class to search for
@@ -663,7 +651,6 @@ export class Blac {
     } = {},
   ): InstanceType<B>[] => {
     const results: InstanceType<B>[] = [];
-    // const blocClassName = (blocClass as any).name; // Temporarily removed for debugging
 
     // Search non-isolated blocs
     this.blocInstanceMap.forEach((blocInstance) => {
@@ -699,7 +686,7 @@ export class Blac {
       }
     }
 
-    toDispose.forEach((bloc) => bloc._dispose());
+    toDispose.forEach((bloc) => bloc.dispose());
   };
   static get disposeKeepAliveBlocs() {
     return Blac.instance.disposeKeepAliveBlocs;
@@ -728,7 +715,7 @@ export class Blac {
       }
     }
 
-    toDispose.forEach((bloc) => bloc._dispose());
+    toDispose.forEach((bloc) => bloc.dispose());
   };
   static get disposeBlocs() {
     return Blac.instance.disposeBlocs;
@@ -754,26 +741,23 @@ export class Blac {
   }
 
   /**
-   * Validates consumer references and cleans up orphaned consumers
+   * Validates subscription references and cleans up orphaned blocs
    */
   validateConsumers = (): void => {
     for (const bloc of this.uidRegistry.values()) {
-      // Validate consumers using the bloc's own validation method
-      bloc._validateConsumers();
-
       // Check if bloc should be disposed after validation
       // TODO: Type assertion for private property access (see explanation above)
       if (
-        bloc._consumers.size === 0 &&
+        bloc.subscriptionCount === 0 &&
         !bloc._keepAlive &&
         (bloc as any)._disposalState === BlocLifecycleState.ACTIVE
       ) {
-        // Schedule disposal for blocs with no consumers
+        // Schedule disposal for blocs with no subscriptions
         setTimeout(() => {
           // Double-check conditions before disposal
           // TODO: Type assertion for private property access (see explanation above)
           if (
-            bloc._consumers.size === 0 &&
+            bloc.subscriptionCount === 0 &&
             !bloc._keepAlive &&
             (bloc as any)._disposalState === BlocLifecycleState.ACTIVE
           ) {
@@ -786,4 +770,33 @@ 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/Bloc.ts

@@ -5,8 +5,7 @@ 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> {
+> extends BlocBase<S> {
   readonly eventHandlers: Map<
     new (...args: any[]) => A,
     (event: A, emit: (newState: S) => void) => void | Promise<void>
@@ -55,7 +54,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 +142,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;
         }