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

package/src/adapter/BlacAdapter.ts

@@ -0,0 +1,262 @@
+import { Blac } from '../Blac';
+import { BlocBase } from '../BlocBase';
+import { BlocConstructor, BlocState, InferPropsFromGeneric } from '../types';
+import { generateUUID } from '../utils/uuid';
+import { ConsumerTracker, DependencyArray } from './ConsumerTracker';
+import { ProxyFactory } from './ProxyFactory';
+
+export interface AdapterOptions<B extends BlocBase<any>> {
+  id?: string;
+  dependencies?: (bloc: B) => unknown[];
+  props?: InferPropsFromGeneric<B>;
+  onMount?: (bloc: B) => void;
+  onUnmount?: (bloc: B) => void;
+}
+
+/**
+ * BlacAdapter orchestrates the connection between Bloc instances and React components.
+ * It manages dependency tracking, lifecycle hooks, and proxy creation.
+ */
+export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
+  public readonly id = `consumer-${generateUUID()}`;
+  public readonly blocConstructor: B;
+  public readonly componentRef: { current: object } = { current: {} };
+  public blocInstance: InstanceType<B>;
+
+  // Core components
+  private consumerTracker: ConsumerTracker;
+
+  unmountTime: number = 0;
+  mountTime: number = 0;
+
+  // Dependency tracking
+  private dependencyValues?: unknown[];
+  private isUsingDependencies: boolean = false;
+
+  // Lifecycle state
+  private hasMounted = false;
+  private mountCount = 0;
+
+  options?: AdapterOptions<InstanceType<B>>;
+
+  constructor(
+    instanceProps: { componentRef: { current: object }; blocConstructor: B },
+    options?: typeof this.options,
+  ) {
+    this.options = options;
+    this.blocConstructor = instanceProps.blocConstructor;
+    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 dependency values if using dependencies
+    if (this.isUsingDependencies && options?.dependencies) {
+      this.dependencyValues = options.dependencies(this.blocInstance);
+    }
+  }
+
+  trackAccess(
+    consumerRef: object,
+    type: 'state' | 'class',
+    path: string,
+    value?: any,
+  ): void {
+    this.consumerTracker.trackAccess(consumerRef, type, path, value);
+  }
+
+  getConsumerDependencies(consumerRef: object): DependencyArray | null {
+    return this.consumerTracker.getDependencies(consumerRef);
+  }
+
+  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
+    }
+
+    // First render - always notify to establish baseline
+    if (!consumerInfo.hasRendered) {
+      return true;
+    }
+
+    // Use built-in method from ConsumerTracker
+    return this.consumerTracker.shouldNotifyConsumer(consumerRef, changedPaths);
+  }
+
+  updateLastNotified(consumerRef: object): void {
+    this.consumerTracker.updateLastNotified(consumerRef);
+    this.consumerTracker.setHasRendered(consumerRef, true);
+  }
+
+  resetConsumerTracking(): void {
+    this.consumerTracker.resetTracking(this.componentRef.current);
+  }
+
+  createStateProxy = <T extends object>(props: { target: T }): T => {
+    return ProxyFactory.createStateProxy({
+      target: props.target,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this as any,
+    });
+  };
+
+  createClassProxy = <T extends object>(props: { target: T }): T => {
+    return ProxyFactory.createClassProxy({
+      target: props.target,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this as 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>>,
+      ) => {
+        // Handle dependency-based change detection
+        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;
+        } 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();
+      },
+    });
+
+    return unsubscribe;
+  };
+
+  mount = (): void => {
+    // Re-run dependencies on mount to ensure fresh values
+    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;
+        }
+      }
+    }
+  };
+
+  unmount = (): void => {
+    this.unmountTime = Date.now();
+    this.consumerTracker.unregister(this.componentRef.current);
+    this.blocInstance._removeConsumer(this.id);
+
+    // Call onUnmount callback
+    if (this.options?.onUnmount) {
+      try {
+        this.options.onUnmount(this.blocInstance);
+      } catch (error) {
+        // Don't re-throw on unmount to allow cleanup to continue
+      }
+    }
+  };
+
+  getProxyState = (
+    state: BlocState<InstanceType<B>>,
+  ): BlocState<InstanceType<B>> => {
+    if (this.isUsingDependencies) {
+      return state; // Return raw state when using dependencies
+    }
+
+    return ProxyFactory.getProxyState({
+      state,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this as any,
+    });
+  };
+
+  getProxyBlocInstance = (): InstanceType<B> => {
+    if (this.isUsingDependencies) {
+      return this.blocInstance; // Return raw instance when using dependencies
+    }
+
+    return ProxyFactory.getProxyBlocInstance({
+      blocInstance: this.blocInstance,
+      consumerRef: this.componentRef.current,
+      consumerTracker: this as any,
+    });
+  };
+
+  // Expose calledOnMount for backward compatibility
+  get calledOnMount(): boolean {
+    return this.hasMounted;
+  }
+
+  private hasDependencyValuesChanged(
+    prev: unknown[] | undefined,
+    next: unknown[],
+  ): boolean {
+    if (!prev) return true; // First run, always trigger
+    if (prev.length !== next.length) return true;
+
+    // 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;
+      }
+    }
+
+    return false;
+  }
+}

package/src/adapter/ConsumerTracker.ts

@@ -0,0 +1,241 @@
+export interface DependencyArray {
+  statePaths: string[];
+  classPaths: string[];
+}
+
+export interface TrackedValue {
+  value: any;
+  lastAccessTime: number;
+}
+
+export interface ConsumerInfo {
+  id: string;
+  lastNotified: number;
+  hasRendered: boolean;
+  // Dependency tracking
+  stateAccesses: Set<string>;
+  classAccesses: Set<string>;
+  stateValues: Map<string, TrackedValue>;
+  classValues: Map<string, TrackedValue>;
+  accessCount: number;
+  lastAccessTime: number;
+  firstAccessTime: number;
+}
+
+/**
+ * ConsumerTracker manages both consumer registration and dependency tracking.
+ * It uses a WeakMap for automatic garbage collection when consumers are no longer referenced.
+ */
+export class ConsumerTracker {
+  private consumers = new WeakMap<object, ConsumerInfo>();
+  private registrationCount = 0;
+  private activeConsumers = 0;
+
+  register(consumerRef: object, consumerId: string): void {
+    this.registrationCount++;
+
+    const existingConsumer = this.consumers.get(consumerRef);
+    if (!existingConsumer) {
+      this.activeConsumers++;
+    }
+
+    this.consumers.set(consumerRef, {
+      id: consumerId,
+      lastNotified: Date.now(),
+      hasRendered: false,
+      stateAccesses: new Set(),
+      classAccesses: new Set(),
+      stateValues: new Map(),
+      classValues: new Map(),
+      accessCount: 0,
+      lastAccessTime: 0,
+      firstAccessTime: 0,
+    });
+  }
+
+  unregister(consumerRef: object): void {
+    if (consumerRef) {
+      const consumerInfo = this.consumers.get(consumerRef);
+      if (consumerInfo) {
+        this.consumers.delete(consumerRef);
+        this.activeConsumers = Math.max(0, this.activeConsumers - 1);
+      }
+    }
+  }
+
+  trackAccess(
+    consumerRef: object,
+    type: 'state' | 'class',
+    path: string,
+    value?: any,
+  ): void {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (!consumerInfo) return;
+
+    const now = Date.now();
+
+    if (!consumerInfo.firstAccessTime) {
+      consumerInfo.firstAccessTime = now;
+    }
+
+    consumerInfo.accessCount++;
+    consumerInfo.lastAccessTime = now;
+
+    if (type === 'state') {
+      consumerInfo.stateAccesses.add(path);
+      if (value !== undefined) {
+        consumerInfo.stateValues.set(path, { value, lastAccessTime: now });
+      }
+    } else {
+      consumerInfo.classAccesses.add(path);
+      if (value !== undefined) {
+        consumerInfo.classValues.set(path, { value, lastAccessTime: now });
+      }
+    }
+  }
+
+  resetTracking(consumerRef: object): void {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (!consumerInfo) return;
+
+    consumerInfo.stateAccesses.clear();
+    consumerInfo.classAccesses.clear();
+    consumerInfo.stateValues.clear();
+    consumerInfo.classValues.clear();
+    consumerInfo.accessCount = 0;
+    consumerInfo.firstAccessTime = 0;
+  }
+
+  getDependencies(consumerRef: object): DependencyArray | null {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (!consumerInfo) return null;
+
+    return {
+      statePaths: Array.from(consumerInfo.stateAccesses),
+      classPaths: Array.from(consumerInfo.classAccesses),
+    };
+  }
+
+  hasValuesChanged(
+    consumerRef: object,
+    newState: any,
+    newBlocInstance: any,
+  ): boolean {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (!consumerInfo) return true;
+
+    let hasChanged = false;
+    const now = Date.now();
+
+    // If we haven't tracked any values yet, consider it changed to establish baseline
+    if (
+      consumerInfo.stateValues.size === 0 &&
+      consumerInfo.classValues.size === 0 &&
+      (consumerInfo.stateAccesses.size > 0 ||
+        consumerInfo.classAccesses.size > 0)
+    ) {
+      return true;
+    }
+
+    // Check state values
+    for (const [path, trackedValue] of consumerInfo.stateValues) {
+      try {
+        const currentValue = this.getValueAtPath(newState, path);
+        if (currentValue !== trackedValue.value) {
+          consumerInfo.stateValues.set(path, {
+            value: currentValue,
+            lastAccessTime: now,
+          });
+          hasChanged = true;
+        }
+      } catch (error) {
+        hasChanged = true;
+      }
+    }
+
+    // Check class getter values
+    for (const [path, trackedValue] of consumerInfo.classValues) {
+      try {
+        const currentValue = this.getValueAtPath(newBlocInstance, path);
+        if (currentValue !== trackedValue.value) {
+          consumerInfo.classValues.set(path, {
+            value: currentValue,
+            lastAccessTime: now,
+          });
+          hasChanged = true;
+        }
+      } catch (error) {
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged;
+  }
+
+  shouldNotifyConsumer(
+    consumerRef: object,
+    changedPaths: Set<string>,
+  ): boolean {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (!consumerInfo) return false;
+
+    // Check if any changed paths match tracked dependencies
+    for (const changedPath of changedPaths) {
+      if (consumerInfo.stateAccesses.has(changedPath)) return true;
+      if (consumerInfo.classAccesses.has(changedPath)) return true;
+
+      // Check for nested path changes
+      for (const trackedPath of consumerInfo.stateAccesses) {
+        if (
+          changedPath.startsWith(trackedPath + '.') ||
+          trackedPath.startsWith(changedPath + '.')
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  updateLastNotified(consumerRef: object): void {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (consumerInfo) {
+      consumerInfo.lastNotified = Date.now();
+    }
+  }
+
+  getConsumerInfo(consumerRef: object): ConsumerInfo | undefined {
+    return this.consumers.get(consumerRef);
+  }
+
+  setHasRendered(consumerRef: object, hasRendered: boolean): void {
+    const consumerInfo = this.consumers.get(consumerRef);
+    if (consumerInfo) {
+      consumerInfo.hasRendered = hasRendered;
+    }
+  }
+
+  hasConsumer(consumerRef: object): boolean {
+    return this.consumers.has(consumerRef);
+  }
+
+  getStats() {
+    return {
+      totalRegistrations: this.registrationCount,
+      activeConsumers: this.activeConsumers,
+    };
+  }
+
+  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];
+    }
+
+    return current;
+  }
+}