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

package/src/Blac.ts

@@ -1,11 +1,4 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// TODO: The 'any' types in this file are necessary for proper type inference in complex generic scenarios.
-// Specifically:
-// 1. BlocConstructor<any> in Maps - allows any bloc type to be stored while maintaining type safety in usage
-// 2. Type assertions for _disposalState - private property access across inheritance hierarchy
-// 3. Constructor argument types - enables flexible bloc instantiation patterns
-// These 'any' usages are carefully controlled and don't compromise runtime type safety.
-import { BlocBase, BlocInstanceId } from './BlocBase';
+import { BlocBase, BlocInstanceId, BlocLifecycleState } from './BlocBase';
 import {
   BlocBaseAbstract,
   BlocConstructor,
@@ -20,6 +13,12 @@ import {
 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.
+   * Default: true
+   */
+  proxyDependencyTracking?: boolean;
 }
 
 export interface GetBlocOptions<B extends BlocBase<unknown>> {
@@ -29,6 +28,8 @@ export interface GetBlocOptions<B extends BlocBase<unknown>> {
   onMount?: (bloc: B) => void;
   instanceRef?: string;
   throwIfNotFound?: boolean;
+  /** Force creation of a new instance for isolated blocs, bypassing instance lookup */
+  forceNewInstance?: boolean;
 }
 
 /**
@@ -98,7 +99,6 @@ export function setBlacInstanceManager(manager: BlacInstanceManager): void {
  * - Providing logging and debugging capabilities
  */
 export class Blac {
-  /** @deprecated Use getInstance() instead */
   static get instance(): Blac {
     return instanceManager.getInstance();
   }
@@ -107,16 +107,55 @@ export class Blac {
   static get getAllBlocs() {
     return Blac.instance.getAllBlocs;
   }
+
+  /** Private static configuration */
+  private static _config: BlacConfig = {
+    exposeBlacInstance: false,
+    proxyDependencyTracking: true,
+  };
+
+  /** Get current configuration */
+  static get config(): Readonly<BlacConfig> {
+    return { ...this._config };
+  }
+
+  /**
+   * Set or update Blac configuration
+   * @param config - Partial configuration to merge with existing config
+   * @throws Error if configuration is invalid
+   */
+  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');
+    }
+
+    // Merge with existing config
+    this._config = {
+      ...this._config,
+      ...config,
+    };
+
+    // Log config update if logging is enabled
+    if (this.enableLog) {
+      this.instance.log('Blac config updated:', this._config);
+    }
+  }
   /** Map storing all registered bloc instances by their class name and ID */
   blocInstanceMap: Map<string, BlocBase<unknown>> = new Map();
   /** Map storing isolated bloc instances grouped by their constructor */
-  // TODO: BlocConstructor<any> is required here for type inference to work correctly.
   // Using BlocConstructor<BlocBase<unknown>> would break type inference when storing
   // different bloc types in the same map. The 'any' allows proper polymorphic storage
   // while maintaining type safety at usage sites through the BlocConstructor constraint.
   isolatedBlocMap: Map<BlocConstructor<any>, BlocBase<unknown>[]> = new Map();
   /** Map for O(1) lookup of isolated blocs by UID */
-  private isolatedBlocIndex: Map<string, BlocBase<unknown>> = new Map();
+  isolatedBlocIndex: Map<string, BlocBase<unknown>> = new Map();
   /** Map tracking UIDs to prevent memory leaks */
   uidRegistry: Map<string, BlocBase<unknown>> = new Map();
   /** Set of keep-alive blocs for controlled cleanup */
@@ -139,16 +178,22 @@ export class Blac {
   /** Flag to enable/disable logging */
   static enableLog = false;
   static logLevel: 'warn' | 'log' = 'warn';
+  static logSpy: ((...args: unknown[]) => void) | null = null;
 
   /**
    * Logs messages to console when logging is enabled
    * @param args - Arguments to log
    */
   log = (...args: unknown[]) => {
-    if (Blac.enableLog && Blac.logLevel === 'warn')
-      console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...args);
-    if (Blac.enableLog && Blac.logLevel === 'log')
-      console.log(`☢️ [Blac ${this.createdAt.toString()}]`, ...args);
+    if (Blac.logSpy) {
+      Blac.logSpy(args);
+    }
+    if (Blac.enableLog && Blac.logLevel === 'warn') {
+      // Logging disabled - console.warn removed
+    }
+    if (Blac.enableLog && Blac.logLevel === 'log') {
+      // Logging disabled - console.log removed
+    }
   };
   static get log() {
     return Blac.instance.log;
@@ -169,11 +214,7 @@ export class Blac {
    */
   warn = (message: string, ...args: unknown[]) => {
     if (Blac.enableLog) {
-      console.warn(
-        `🚨 [Blac ${String(Blac.instance.createdAt)}]`,
-        message,
-        ...args,
-      );
+      // Logging disabled - console.warn removed
     }
   };
   static get warn() {
@@ -186,11 +227,7 @@ export class Blac {
    */
   error = (message: string, ...args: unknown[]) => {
     if (Blac.enableLog) {
-      console.error(
-        `🚨 [Blac ${String(Blac.instance.createdAt)}]`,
-        message,
-        ...args,
-      );
+      // Logging disabled - console.error removed
     }
   };
   static get error() {
@@ -212,7 +249,10 @@ export class Blac {
     // Use disposeBloc method to ensure proper cleanup
     oldBlocInstanceMap.forEach((bloc) => {
       // TODO: Type assertion for private property access (see explanation above)
-      if (!bloc._keepAlive && (bloc as any)._disposalState === 'active') {
+      if (
+        !bloc._keepAlive &&
+        (bloc as any)._disposalState === BlocLifecycleState.ACTIVE
+      ) {
         this.disposeBloc(bloc);
       }
     });
@@ -220,7 +260,10 @@ export class Blac {
     oldIsolatedBlocMap.forEach((blocArray) => {
       blocArray.forEach((bloc) => {
         // TODO: Type assertion for private property access (see explanation above)
-        if (!bloc._keepAlive && (bloc as any)._disposalState === 'active') {
+        if (
+          !bloc._keepAlive &&
+          (bloc as any)._disposalState === BlocLifecycleState.ACTIVE
+        ) {
           this.disposeBloc(bloc);
         }
       });
@@ -248,9 +291,15 @@ export class Blac {
     // This is safe because we know BlocBase has this property, but TypeScript can't verify
     // private property access across class boundaries. Alternative would be to make
     // _disposalState protected, but that would expose internal implementation details.
-    if ((bloc as any)._disposalState !== 'active') {
+    const currentState = (bloc as any)._disposalState;
+    const validStatesForDisposal = [
+      BlocLifecycleState.ACTIVE,
+      BlocLifecycleState.DISPOSAL_REQUESTED,
+    ];
+
+    if (!validStatesForDisposal.includes(currentState)) {
       this.log(
-        `[${bloc._name}:${String(bloc._id)}] disposeBloc called on already disposed bloc`,
+        `[${bloc._name}:${String(bloc._id)}] disposeBloc called on bloc in invalid state: ${currentState}`,
       );
       return;
     }
@@ -467,7 +516,7 @@ export class Blac {
 
   activateBloc = (bloc: BlocBase<unknown>): void => {
     // Don't activate disposed blocs
-    if ((bloc as any)._disposalState !== 'active') {
+    if ((bloc as any)._disposalState !== BlocLifecycleState.ACTIVE) {
       this.log(
         `[${bloc._name}:${String(bloc._id)}] activateBloc called on disposed bloc. Ignoring.`,
       );
@@ -512,26 +561,39 @@ export class Blac {
     blocClass: B,
     options: GetBlocOptions<InstanceType<B>> = {},
   ): InstanceType<B> => {
-    const { id } = options;
+    const { id, forceNewInstance } = options;
     const base = blocClass as unknown as BlocBaseAbstract;
     const blocId = id ?? blocClass.name;
+    this.log(`[${blocClass.name}:${String(blocId)}] (getBloc) Called:`, {
+      options,
+      base,
+    });
 
-    if (base.isolated) {
-      const isolatedBloc = this.findIsolatedBlocInstance<B>(blocClass, blocId);
-      if (isolatedBloc) {
-        return isolatedBloc;
-      } else {
-        if (options.throwIfNotFound) {
-          throw new Error(`Isolated bloc ${blocClass.name} not found`);
+    // Skip instance lookup if forceNewInstance is true for isolated blocs
+    if (!forceNewInstance) {
+      if (base.isolated) {
+        const isolatedBloc = this.findIsolatedBlocInstance<B>(
+          blocClass,
+          options.instanceRef ?? blocId,
+        );
+        if (isolatedBloc) {
+          return isolatedBloc;
+        } else {
+          if (options.throwIfNotFound) {
+            throw new Error(`Isolated bloc ${blocClass.name} not found`);
+          }
         }
-      }
-    } else {
-      const registeredBloc = this.findRegisteredBlocInstance(blocClass, blocId);
-      if (registeredBloc) {
-        return registeredBloc;
       } else {
-        if (options.throwIfNotFound) {
-          throw new Error(`Registered bloc ${blocClass.name} not found`);
+        const registeredBloc = this.findRegisteredBlocInstance(
+          blocClass,
+          blocId,
+        );
+        if (registeredBloc) {
+          return registeredBloc;
+        } else {
+          if (options.throwIfNotFound) {
+            throw new Error(`Registered bloc ${blocClass.name} not found`);
+          }
         }
       }
     }
@@ -704,7 +766,7 @@ export class Blac {
       if (
         bloc._consumers.size === 0 &&
         !bloc._keepAlive &&
-        (bloc as any)._disposalState === 'active'
+        (bloc as any)._disposalState === BlocLifecycleState.ACTIVE
       ) {
         // Schedule disposal for blocs with no consumers
         setTimeout(() => {
@@ -713,7 +775,7 @@ export class Blac {
           if (
             bloc._consumers.size === 0 &&
             !bloc._keepAlive &&
-            (bloc as any)._disposalState === 'active'
+            (bloc as any)._disposalState === BlocLifecycleState.ACTIVE
           ) {
             this.disposeBloc(bloc);
           }

package/src/BlacObserver.ts

@@ -1,4 +1,5 @@
 import { Blac } from './Blac';
+import { BlocLifecycleState } from './BlocBase';
 import { BlocBase } from './BlocBase';
 import { BlocHookDependencyArrayFn } from './types';
 
@@ -14,7 +15,7 @@ export type BlacObserver<S> = {
   /** Dispose function for the observer */
   dispose?: () => void;
   /** Cached state values used for dependency comparison */
-  lastState?: unknown[][];
+  lastState?: unknown[];
   /** Unique identifier for the observer */
   id: string;
 };
@@ -59,13 +60,49 @@ export class BlacObservable<S = unknown> {
    * @returns A function that can be called to unsubscribe the observer
    */
   subscribe(observer: BlacObserver<S>): () => void {
-    Blac.log('BlacObservable.subscribe: Subscribing observer.', this.bloc, observer);
+    // 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);
+      Blac.log(
+        'BlacObservable.subscribe: Unsubscribing observer.',
+        this.bloc,
+        observer,
+      );
       this.unsubscribe(observer);
-    }
+    };
   }
 
   /**
@@ -79,8 +116,14 @@ export class BlacObservable<S = unknown> {
     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 === 'active') {
-        Blac.log(`[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`);
+      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();
       }
     }
@@ -98,35 +141,26 @@ export class BlacObservable<S = unknown> {
 
       if (observer.dependencyArray) {
         const lastDependencyCheck = observer.lastState;
-        const newDependencyCheck = observer.dependencyArray(newState, oldState);
+        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 two-array dependency structure: [stateArray, classArray]
+          // Compare dependency arrays
           if (lastDependencyCheck.length !== newDependencyCheck.length) {
             shouldUpdate = true;
           } else {
-            // Compare each array (state and class dependencies)
-            for (let arrayIndex = 0; arrayIndex < newDependencyCheck.length; arrayIndex++) {
-              const lastArray = lastDependencyCheck[arrayIndex] || [];
-              const newArray = newDependencyCheck[arrayIndex] || [];
-              
-              if (lastArray.length !== newArray.length) {
+            // 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;
               }
-              
-              // Compare each dependency value using Object.is (same as React)
-              for (let i = 0; i < newArray.length; i++) {
-                if (!Object.is(lastArray[i], newArray[i])) {
-                  shouldUpdate = true;
-                  break;
-                }
-              }
-              
-              if (shouldUpdate) break;
             }
           }
         }