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

package/src/adapter/BlacAdapter.ts

@@ -1,16 +1,14 @@
 import { Blac } from '../Blac';
-import { BlocBase, BlocLifecycleState } from '../BlocBase';
-import { BlocConstructor, BlocState, InferPropsFromGeneric } from '../types';
-import { PropsUpdated } from '../events';
+import { BlocBase } from '../BlocBase';
+import { BlocConstructor, BlocState } from '../types';
 import { generateUUID } from '../utils/uuid';
-import { shallowEqual } from '../utils/shallowEqual';
-import { ConsumerTracker, DependencyArray } from './ConsumerTracker';
+import { generateInstanceIdFromProps } from '../utils/generateInstanceId';
 import { ProxyFactory } from './ProxyFactory';
 
 export interface AdapterOptions<B extends BlocBase<any>> {
-  id?: string;
+  instanceId?: string;
   dependencies?: (bloc: B) => unknown[];
-  props?: any;
+  staticProps?: any;
   onMount?: (bloc: B) => void;
   onUnmount?: (bloc: B) => void;
 }
@@ -20,29 +18,40 @@ export interface AdapterOptions<B extends BlocBase<any>> {
  * It manages dependency tracking, lifecycle hooks, and proxy creation.
  */
 export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
-  public readonly id = `consumer-${generateUUID()}`;
+  public readonly id = `adapter-${generateUUID()}`;
   public readonly blocConstructor: B;
   public readonly componentRef: { current: object } = { current: {} };
-  public blocInstance: InstanceType<B>;
-
-  // Core components
-  private consumerTracker: ConsumerTracker;
-
-  // Props ownership tracking
-  private static propsOwners = new WeakMap<BlocBase<any>, string>();
-  private lastProps?: any;
+  public blocInstance!: InstanceType<B>;
 
   unmountTime: number = 0;
   mountTime: number = 0;
 
+  // Subscription management
+  private subscriptionId?: string;
+  private unsubscribe?: () => void;
+
   // Dependency tracking
   private dependencyValues?: unknown[];
   private isUsingDependencies: boolean = false;
+  private trackedPaths = new Set<string>();
+  private pendingTrackedPaths = new Set<string>(); // Paths tracked before subscription exists
+
+  // Proxy caching
+  private cachedStateProxy?: BlocState<InstanceType<B>>;
+  private cachedBlocProxy?: InstanceType<B>;
+  private lastProxiedState?: BlocState<InstanceType<B>>;
 
   // Lifecycle state
   private hasMounted = false;
   private mountCount = 0;
 
+  // Rerender tracking
+  private lastState?: BlocState<InstanceType<B>>;
+  private lastDependencyValues?: unknown[];
+  private componentName?: string;
+  private renderCount = 0;
+  private lastDependenciesFn?: (bloc: InstanceType<B>) => unknown[];
+
   options?: AdapterOptions<InstanceType<B>>;
 
   constructor(
@@ -54,22 +63,17 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     this.componentRef = instanceProps.componentRef;
     this.isUsingDependencies = !!options?.dependencies;
 
-    // Initialize consumer tracker
-    this.consumerTracker = new ConsumerTracker();
-
-    // Initialize bloc instance and register consumer
-    this.blocInstance = this.updateBlocInstance();
-    this.consumerTracker.register(instanceProps.componentRef.current, this.id);
+    // Initialize bloc instance
+    this.updateBlocInstance();
 
     // Initialize dependency values if using dependencies
     if (this.isUsingDependencies && options?.dependencies) {
       this.dependencyValues = options.dependencies(this.blocInstance);
     }
 
-    // Handle initial props if provided
-    if (options?.props !== undefined) {
-      this.updateProps(options.props);
-    }
+    // Notify plugins
+    const metadata = this.getAdapterMetadata();
+    Blac.getInstance().plugins.notifyAdapterCreated(this, metadata);
   }
 
   trackAccess(
@@ -78,39 +82,139 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     path: string,
     value?: any,
   ): void {
-    this.consumerTracker.trackAccess(consumerRef, type, path, value);
+    const fullPath = type === 'class' ? `_class.${path}` : path;
+    this.trackedPaths.add(fullPath);
+
+    if (this.subscriptionId) {
+      this.blocInstance.trackAccess(this.subscriptionId, fullPath, value);
+    } else {
+      // No subscription ID yet - store for later
+      this.pendingTrackedPaths.add(fullPath);
+      if ((Blac.config as any).logLevel === 'debug') {
+        Blac.log(`[BlacAdapter] trackAccess storing pending path: ${path}`);
+      }
+    }
   }
 
-  getConsumerDependencies(consumerRef: object): DependencyArray | null {
-    return this.consumerTracker.getDependencies(consumerRef);
+  updateBlocInstance(): InstanceType<B> {
+    // Determine the instance ID
+    let instanceId = this.options?.instanceId;
+
+    // If no explicit instanceId provided but staticProps exist, generate from them
+    if (!instanceId && this.options?.staticProps) {
+      const generatedId = generateInstanceIdFromProps(this.options.staticProps);
+      if (generatedId) {
+        instanceId = generatedId;
+      }
+    }
+
+    this.blocInstance = Blac.instance.getBloc<B>(this.blocConstructor, {
+      constructorParams: this.options?.staticProps,
+      id: instanceId,
+      instanceRef: this.id,
+    });
+    return this.blocInstance;
   }
 
-  shouldNotifyConsumer(
-    consumerRef: object,
-    changedPaths: Set<string>,
-  ): boolean {
-    const consumerInfo = this.consumerTracker.getConsumerInfo(consumerRef);
-    if (!consumerInfo) {
-      return true; // If consumer not registered yet, notify by default
+  createSubscription = (options: { onChange: () => void }) => {
+    // If using manual dependencies, create a selector-based subscription
+    if (this.isUsingDependencies && this.options?.dependencies) {
+      this.unsubscribe = this.blocInstance.subscribeWithSelector(
+        (_state) => this.options!.dependencies!(this.blocInstance),
+        (newValues) => {
+          const hasChanged = this.hasDependencyValuesChanged(
+            this.dependencyValues,
+            newValues as unknown[],
+          );
+
+          if (hasChanged) {
+            this.dependencyValues = newValues as unknown[];
+            options.onChange();
+          }
+        },
+      );
+    } else {
+      // Create a component subscription with weak reference
+      const weakRef = new WeakRef(this.componentRef.current);
+      this.unsubscribe = this.blocInstance.subscribeComponent(
+        weakRef,
+        options.onChange,
+      );
+
+      // Get the subscription ID for tracking
+      const subscriptions = (this.blocInstance._subscriptionManager as any)
+        .subscriptions as Map<string, any>;
+      this.subscriptionId = Array.from(subscriptions.keys()).pop();
+
+      // Apply any pending tracked paths
+      if (this.subscriptionId && this.pendingTrackedPaths.size > 0) {
+        for (const path of this.pendingTrackedPaths) {
+          this.blocInstance.trackAccess(this.subscriptionId, path);
+        }
+        this.pendingTrackedPaths.clear();
+      }
+    }
+
+    // Don't call onChange initially - let React handle the initial render
+
+    return () => {
+      if (this.unsubscribe) {
+        this.unsubscribe();
+        this.unsubscribe = undefined;
+        this.subscriptionId = undefined;
+      }
+    };
+  };
+
+  hasDependencyValuesChanged = (
+    oldValues: unknown[] | undefined,
+    newValues: unknown[],
+  ): boolean => {
+    if (!oldValues) return true;
+    if (oldValues.length !== newValues.length) return true;
+
+    for (let i = 0; i < oldValues.length; i++) {
+      if (!Object.is(oldValues[i], newValues[i])) {
+        return true;
+      }
     }
 
-    // First render - always notify to establish baseline
-    if (!consumerInfo.hasRendered) {
-      return true;
+    return false;
+  };
+
+  getStateProxy = (): BlocState<InstanceType<B>> => {
+    // If using manual dependencies or proxy tracking is disabled, return raw state
+    if (this.isUsingDependencies || !Blac.config.proxyDependencyTracking) {
+      return this.blocInstance.state;
     }
 
-    // Use built-in method from ConsumerTracker
-    return this.consumerTracker.shouldNotifyConsumer(consumerRef, changedPaths);
-  }
+    // Return cached proxy if state hasn't changed
+    const currentState = this.blocInstance.state;
+    if (this.cachedStateProxy && this.lastProxiedState === currentState) {
+      return this.cachedStateProxy;
+    }
 
-  updateLastNotified(consumerRef: object): void {
-    this.consumerTracker.updateLastNotified(consumerRef);
-    this.consumerTracker.setHasRendered(consumerRef, true);
-  }
+    // Create new proxy for new state
+    this.lastProxiedState = currentState;
+    this.cachedStateProxy = this.createStateProxy({ target: currentState });
+    return this.cachedStateProxy!;
+  };
 
-  resetConsumerTracking(): void {
-    this.consumerTracker.resetTracking(this.componentRef.current);
-  }
+  getBlocProxy = (): InstanceType<B> => {
+    // If using manual dependencies or proxy tracking is disabled, return raw bloc
+    if (this.isUsingDependencies || !Blac.config.proxyDependencyTracking) {
+      return this.blocInstance;
+    }
+
+    // Return cached proxy if bloc instance hasn't changed
+    if (this.cachedBlocProxy) {
+      return this.cachedBlocProxy;
+    }
+
+    // Create and cache proxy
+    this.cachedBlocProxy = this.createClassProxy({ target: this.blocInstance });
+    return this.cachedBlocProxy;
+  };
 
   createStateProxy = <T extends object>(props: { target: T }): T => {
     return ProxyFactory.createStateProxy({
@@ -128,200 +232,236 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     });
   };
 
-  updateBlocInstance(): InstanceType<B> {
-    this.blocInstance = Blac.instance.getBloc<B>(this.blocConstructor, {
-      props: this.options?.props,
-      id: this.options?.id,
-      instanceRef: this.id,
-    });
-    return this.blocInstance;
-  }
-
-  createSubscription = (options: { onChange: () => void }) => {
-    const unsubscribe = this.blocInstance._observer.subscribe({
-      id: this.id,
-      fn: (
-        newState: BlocState<InstanceType<B>>,
-        oldState: BlocState<InstanceType<B>>,
-      ) => {
-        // Case 1: Manual dependencies provided
-        if (this.isUsingDependencies && this.options?.dependencies) {
-          const newValues = this.options.dependencies(this.blocInstance);
-          const hasChanged = this.hasDependencyValuesChanged(
-            this.dependencyValues,
-            newValues,
-          );
-
-          if (!hasChanged) {
-            return; // Don't trigger re-render
-          }
-
-          this.dependencyValues = newValues;
-        } 
-        // Case 2: Proxy tracking disabled globally (and no manual dependencies)
-        else if (!Blac.config.proxyDependencyTracking) {
-          // Always trigger re-render when proxy tracking is disabled
-          options.onChange();
-          return;
-        } 
-        // Case 3: Proxy tracking enabled (default behavior)
-        else {
-          // Check if any tracked values have changed (proxy-based tracking)
-          const consumerInfo = this.consumerTracker.getConsumerInfo(
-            this.componentRef.current,
-          );
-          if (consumerInfo && consumerInfo.hasRendered) {
-            // Only check dependencies if component has rendered at least once
-            const hasChanged = this.consumerTracker.hasValuesChanged(
-              this.componentRef.current,
-              newState,
-              this.blocInstance,
-            );
-
-            if (!hasChanged) {
-              return; // Don't trigger re-render
-            }
-          }
-        }
-
-        options.onChange();
-      },
-    });
+  // Lifecycle methods
+  mount = () => {
+    this.hasMounted = true;
+    this.mountCount++;
+    this.mountTime = Date.now();
 
-    return unsubscribe;
-  };
+    // Call onMount hook
+    if (this.options?.onMount) {
+      this.options.onMount(this.blocInstance);
+    }
 
-  mount = (): void => {
-    // Re-run dependencies on mount to ensure fresh values
+    // Refresh dependencies if using manual tracking
     if (this.isUsingDependencies && this.options?.dependencies) {
       this.dependencyValues = this.options.dependencies(this.blocInstance);
     }
 
-    // Lifecycle management
-    this.mountCount++;
-    this.blocInstance._addConsumer(this.id, this.componentRef.current);
-
-    // Call onMount callback if provided and not already called
-    if (!this.hasMounted) {
-      this.hasMounted = true;
-      this.mountTime = Date.now();
-
-      if (this.options?.onMount) {
-        try {
-          this.options.onMount(this.blocInstance);
-        } catch (error) {
-          throw error;
-        }
-      }
-    }
+    // Notify plugins
+    const metadata = this.getAdapterMetadata();
+    Blac.getInstance().plugins.notifyAdapterMount(this, metadata);
   };
 
-  unmount = (): void => {
+  unmount = () => {
     this.unmountTime = Date.now();
-    this.consumerTracker.unregister(this.componentRef.current);
-    this.blocInstance._removeConsumer(this.id);
 
-    // Clear ownership if we own this bloc
-    if (BlacAdapter.propsOwners.get(this.blocInstance) === this.id) {
-      BlacAdapter.propsOwners.delete(this.blocInstance);
+    // Cancel subscription
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = undefined;
+      this.subscriptionId = undefined;
     }
 
-    // Call onUnmount callback
+    // Call onUnmount hook
     if (this.options?.onUnmount) {
       try {
         this.options.onUnmount(this.blocInstance);
       } catch (error) {
-        // Don't re-throw on unmount to allow cleanup to continue
+        console.error('Error in onUnmount hook:', error);
       }
     }
+
+    // Notify plugins
+    const metadata = this.getAdapterMetadata();
+    Blac.getInstance().plugins.notifyAdapterUnmount(this, metadata);
   };
 
-  getProxyState = (
-    state: BlocState<InstanceType<B>>,
-  ): BlocState<InstanceType<B>> => {
-    // Return raw state if proxy tracking is disabled globally or using manual dependencies
-    if (this.isUsingDependencies || !Blac.config.proxyDependencyTracking) {
-      return state;
+  // Reset tracking for next render
+  resetTracking(): void {
+    // Clear tracked paths from previous render
+    this.trackedPaths.clear();
+    this.pendingTrackedPaths.clear();
+
+    // Clear subscription dependencies to track only current render
+    if (this.subscriptionId) {
+      const subscription = (
+        this.blocInstance._subscriptionManager as any
+      ).subscriptions.get(this.subscriptionId);
+      if (subscription && subscription.dependencies) {
+        // Clear old dependencies - we'll track new ones in this render
+        subscription.dependencies.clear();
+      }
     }
+  }
 
-    return ProxyFactory.getProxyState({
-      state,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this as any,
-    });
-  };
+  // Set component name for rerender logging
+  setComponentName(name: string): void {
+    this.componentName = name;
+  }
 
-  getProxyBlocInstance = (): InstanceType<B> => {
-    // Return raw instance if proxy tracking is disabled globally or using manual dependencies
-    if (this.isUsingDependencies || !Blac.config.proxyDependencyTracking) {
-      return this.blocInstance;
+  // Notify plugins about render
+  notifyRender(): void {
+    this.renderCount++;
+
+    // Update dependency values if using manual tracking
+    if (this.isUsingDependencies && this.options?.dependencies) {
+      this.lastDependencyValues = this.dependencyValues;
+      this.dependencyValues = this.options.dependencies(this.blocInstance);
     }
 
-    return ProxyFactory.getProxyBlocInstance({
-      blocInstance: this.blocInstance,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this as any,
-    });
-  };
+    const metadata = this.getAdapterMetadata();
+    Blac.getInstance().plugins.notifyAdapterRender(this, metadata);
+  }
 
-  // Expose calledOnMount for backward compatibility
-  get calledOnMount(): boolean {
-    return this.hasMounted;
+  // Get adapter metadata for plugins
+  private getAdapterMetadata(): any {
+    return {
+      componentName: this.componentName,
+      blocInstance: this.blocInstance,
+      renderCount: this.renderCount,
+      trackedPaths: Array.from(this.trackedPaths),
+      isUsingDependencies: this.isUsingDependencies,
+      lastState: this.lastState,
+      lastDependencyValues: this.lastDependencyValues,
+      currentDependencyValues: this.dependencyValues,
+    };
   }
 
-  updateProps(props: any): void {
-    const bloc = this.blocInstance;
-    
-    // Check ownership
-    if (!BlacAdapter.propsOwners.has(bloc)) {
-      // First adapter with props becomes the owner
-      BlacAdapter.propsOwners.set(bloc, this.id);
-    }
-    
-    if (BlacAdapter.propsOwners.get(bloc) !== this.id) {
-      Blac.warn(
-        `[BlacAdapter] Attempted to set props on ${bloc.constructor.name} from non-owner adapter`
-      );
-      return;
+  // Get value at a dot-notated path
+  private getValueAtPath(obj: any, path: string): any {
+    const parts = path.split('.');
+    let current = obj;
+
+    for (const part of parts) {
+      if (current == null) return undefined;
+      current = current[part];
     }
-    
-    // Disposal safety
-    if ((bloc as any)._disposalState === BlocLifecycleState.DISPOSED ||
-        (bloc as any)._disposalState === BlocLifecycleState.DISPOSING) {
-      return;
+
+    return current;
+  }
+
+  // Get paths that changed between states
+  private getStateChangedPaths(oldState: any, newState: any): string[] {
+    const changedPaths: string[] = [];
+
+    // Only check tracked paths if we have any
+    if (this.trackedPaths.size > 0) {
+      for (const path of this.trackedPaths) {
+        // Skip class property paths
+        if (path.startsWith('_class.')) continue;
+
+        const oldValue = this.getValueAtPath(oldState, path);
+        const newValue = this.getValueAtPath(newState, path);
+
+        if (!Object.is(oldValue, newValue)) {
+          changedPaths.push(path);
+        }
+      }
+    } else {
+      // No tracked paths - do deep comparison to find what changed
+      if (oldState !== newState) {
+        const deepChanges = this.getDeepChangedPaths(oldState, newState);
+        if (deepChanges.length > 0) {
+          return deepChanges;
+        }
+        changedPaths.push('(entire state)');
+      }
     }
-    
-    // Check if props have changed
-    if (shallowEqual(this.lastProps, props)) {
-      return;
+
+    return changedPaths;
+  }
+
+  // Deep comparison to find all changed paths
+  private getDeepChangedPaths(
+    oldObj: any,
+    newObj: any,
+    basePath: string = '',
+  ): string[] {
+    const changes: string[] = [];
+
+    // Handle null/undefined
+    if (oldObj === newObj) return changes;
+    if (oldObj == null || newObj == null) {
+      changes.push(basePath || '(root)');
+      return changes;
     }
-    
-    // Update props based on bloc type
-    if ('add' in bloc && typeof bloc.add === 'function') {
-      // Bloc: dispatch PropsUpdated event
-      (bloc as any).add(new PropsUpdated(props));
-    } else if ('_updateProps' in bloc && typeof (bloc as any)._updateProps === 'function') {
-      // Cubit: direct props update
-      (bloc as any)._updateProps(props);
+
+    // Handle primitives
+    if (typeof oldObj !== 'object' || typeof newObj !== 'object') {
+      if (oldObj !== newObj) {
+        changes.push(basePath || '(root)');
+      }
+      return changes;
     }
-    
-    this.lastProps = props;
-  }
 
-  private hasDependencyValuesChanged(
-    prev: unknown[] | undefined,
-    next: unknown[],
-  ): boolean {
-    if (!prev) return true; // First run, always trigger
-    if (prev.length !== next.length) return true;
+    // Handle arrays
+    if (Array.isArray(oldObj) || Array.isArray(newObj)) {
+      if (
+        !Array.isArray(oldObj) ||
+        !Array.isArray(newObj) ||
+        oldObj.length !== newObj.length
+      ) {
+        changes.push(basePath || '(root)');
+        return changes;
+      }
+      // Compare array elements
+      for (let i = 0; i < oldObj.length; i++) {
+        const elementPath = basePath ? `${basePath}[${i}]` : `[${i}]`;
+        changes.push(
+          ...this.getDeepChangedPaths(oldObj[i], newObj[i], elementPath),
+        );
+      }
+      return changes;
+    }
 
-    // Use Object.is for comparison (handles NaN, +0/-0 correctly)
-    for (let i = 0; i < prev.length; i++) {
-      if (!Object.is(prev[i], next[i])) {
-        return true;
+    // Handle objects
+    const allKeys = new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+    for (const key of allKeys) {
+      const keyPath = basePath ? `${basePath}.${key}` : key;
+
+      if (!(key in oldObj)) {
+        changes.push(`${keyPath} (added)`);
+      } else if (!(key in newObj)) {
+        changes.push(`${keyPath} (removed)`);
+      } else {
+        const oldVal = oldObj[key];
+        const newVal = newObj[key];
+
+        // Use Object.is for comparison
+        if (!Object.is(oldVal, newVal)) {
+          // For primitives and different object references, record the change
+          if (
+            typeof oldVal !== 'object' ||
+            typeof newVal !== 'object' ||
+            oldVal === null ||
+            newVal === null
+          ) {
+            changes.push(keyPath);
+          } else {
+            // For objects/arrays, recurse deeper
+            const deeperChanges = this.getDeepChangedPaths(
+              oldVal,
+              newVal,
+              keyPath,
+            );
+            if (deeperChanges.length > 0) {
+              changes.push(...deeperChanges);
+            } else {
+              // Objects are different references but have same content
+              changes.push(keyPath);
+            }
+          }
+        }
       }
     }
 
-    return false;
+    return changes;
+  }
+
+  // Get last rerender reason
+  getLastRerenderReason(): any {
+    // This method is deprecated - render reason is now handled by the RenderLoggingPlugin
+    return undefined;
   }
 }