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

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@blac/core",
-  "version": "2.0.0-rc-13",
+  "version": "2.0.0-rc-16",
   "license": "MIT",
   "author": "Brendan Mullins <jsnanigans@gmail.com>",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.es.js",
-  "typings": "dist/index.d.ts",
-  "types": "dist/index.d.ts",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "typings": "src/index.ts",
+  "types": "src/index.ts",
   "files": [
-    "dist",
     "src",
     "README.md",
     "LICENSE"
@@ -27,21 +26,17 @@
     "@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",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^1.6.0"
+    "typescript": "^5.9.2",
+    "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",
     "typecheck": "tsc --noEmit",
-    "build": "vite build",
-    "deploy": "pnpm run build && pnpm publish --access public"
+    "deploy": "pnpm publish --access public"
   }
 }

package/src/Blac.ts

@@ -1,19 +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.
@@ -25,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;
@@ -105,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,
   };
 
@@ -127,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
@@ -219,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;
@@ -233,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() {
@@ -317,7 +317,7 @@ export class Blac {
     );
 
     // First dispose the bloc to prevent further operations
-    bloc._dispose();
+    bloc.dispose();
 
     // Notify plugins of bloc disposal
     this.plugins.notifyBlocDisposed(bloc);
@@ -393,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;
   }
 
@@ -477,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;
@@ -505,14 +511,14 @@ 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);
@@ -520,8 +526,7 @@ export class Blac {
       this.registerBlocInstance(newBloc);
     }
 
-    // Activate bloc plugins
-    newBloc._activatePlugins();
+    // Plugins are activated in constructor
 
     // Notify system plugins of bloc creation
     this.plugins.notifyBlocCreated(newBloc);
@@ -632,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
@@ -678,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) => {
@@ -714,7 +686,7 @@ export class Blac {
       }
     }
 
-    toDispose.forEach((bloc) => bloc._dispose());
+    toDispose.forEach((bloc) => bloc.dispose());
   };
   static get disposeKeepAliveBlocs() {
     return Blac.instance.disposeKeepAliveBlocs;
@@ -743,7 +715,7 @@ export class Blac {
       }
     }
 
-    toDispose.forEach((bloc) => bloc._dispose());
+    toDispose.forEach((bloc) => bloc.dispose());
   };
   static get disposeBlocs() {
     return Blac.instance.disposeBlocs;
@@ -769,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
           ) {
@@ -830,6 +799,4 @@ export class Blac {
       }
     }
   }
-
-
 }

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>
@@ -63,22 +62,22 @@ export abstract class Bloc<
       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) {
@@ -149,13 +148,13 @@ export abstract class Bloc<
             this._plugins.notifyError(error, {
               phase: 'event-processing',
               operation: 'handler',
-              metadata: { event: action }
+              metadata: { event: action },
             });
-            
+
             Blac.instance.plugins.notifyError(error, this as any, {
               phase: 'event-processing',
               operation: 'handler',
-              metadata: { event: action }
+              metadata: { event: action },
             });
           } catch (pluginError) {
             console.error('Error notifying plugins:', pluginError);