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

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;
+  }
+}

package/src/adapter/ProxyFactory.ts

@@ -0,0 +1,308 @@
+import { BlocBase } from '../BlocBase';
+import { BlocState } from '../types';
+
+interface ConsumerTracker {
+  trackAccess: (
+    consumerRef: object,
+    type: 'state' | 'class',
+    path: string,
+    value?: any,
+  ) => void;
+}
+
+// Cache for proxies to ensure consistent object identity
+const proxyCache = new WeakMap<object, WeakMap<object, any>>();
+
+// Statistics tracking
+let proxyStats = {
+  stateProxiesCreated: 0,
+  classProxiesCreated: 0,
+  cacheHits: 0,
+  cacheMisses: 0,
+  propertyAccesses: 0,
+  nestedProxiesCreated: 0,
+  totalProxiesCreated: 0,
+  createdAt: Date.now(),
+};
+
+export class ProxyFactory {
+  static createStateProxy<T extends object>(options: {
+    target: T;
+    consumerRef: object;
+    consumerTracker: ConsumerTracker;
+    path?: string;
+  }): T {
+    const { target, consumerRef, consumerTracker, path = '' } = options;
+
+    if (!consumerRef || !consumerTracker) {
+      return target;
+    }
+
+    if (typeof target !== 'object' || target === null) {
+      return target;
+    }
+
+    // Check cache to ensure consistent proxy identity
+    let refCache = proxyCache.get(target);
+    if (!refCache) {
+      refCache = new WeakMap();
+      proxyCache.set(target, refCache);
+    }
+
+    const existingProxy = refCache.get(consumerRef);
+    if (existingProxy) {
+      proxyStats.cacheHits++;
+      return existingProxy;
+    }
+
+    proxyStats.cacheMisses++;
+
+    const handler: ProxyHandler<T> = {
+      get(obj: T, prop: string | symbol): any {
+        // Handle symbols and special properties
+        if (typeof prop === 'symbol' || prop === 'constructor') {
+          return Reflect.get(obj, prop);
+        }
+
+        const fullPath = path ? `${path}.${prop}` : prop;
+        proxyStats.propertyAccesses++;
+
+        const value = Reflect.get(obj, prop);
+        const valueType = typeof value;
+        const isObject = value && valueType === 'object' && value !== null;
+
+        // Track the access with value (only for primitives at root level)
+        const trackValue = !isObject ? value : undefined;
+        consumerTracker.trackAccess(consumerRef, 'state', fullPath, trackValue);
+
+        // Recursively proxy nested objects and arrays
+        if (value && typeof value === 'object' && value !== null) {
+          // Support arrays, plain objects, and other object types
+          const isPlainObject =
+            Object.getPrototypeOf(value) === Object.prototype;
+          const isArray = Array.isArray(value);
+
+          if (isPlainObject || isArray) {
+            proxyStats.nestedProxiesCreated++;
+            return ProxyFactory.createStateProxy({
+              target: value,
+              consumerRef,
+              consumerTracker,
+              path: fullPath,
+            });
+          }
+        }
+
+        return value;
+      },
+
+      has(obj: T, prop: string | symbol): boolean {
+        return prop in obj;
+      },
+
+      ownKeys(obj: T): (string | symbol)[] {
+        return Reflect.ownKeys(obj);
+      },
+
+      getOwnPropertyDescriptor(
+        obj: T,
+        prop: string | symbol,
+      ): PropertyDescriptor | undefined {
+        return Reflect.getOwnPropertyDescriptor(obj, prop);
+      },
+
+      set(): boolean {
+        // State should not be mutated directly. Use emit() or patch() methods.
+        return false;
+      },
+
+      deleteProperty(): boolean {
+        // State properties should not be deleted directly.
+        return false;
+      },
+    };
+
+    const proxy = new Proxy(target, handler);
+    refCache.set(consumerRef, proxy);
+
+    proxyStats.stateProxiesCreated++;
+    proxyStats.totalProxiesCreated++;
+
+    return proxy;
+  }
+
+  static createClassProxy<T extends object>(options: {
+    target: T;
+    consumerRef: object;
+    consumerTracker: ConsumerTracker;
+  }): T {
+    const { target, consumerRef, consumerTracker } = options;
+
+    if (!consumerRef || !consumerTracker) {
+      return target;
+    }
+
+    // Check cache for class proxies
+    let refCache = proxyCache.get(target);
+    if (!refCache) {
+      refCache = new WeakMap();
+      proxyCache.set(target, refCache);
+    }
+
+    const existingProxy = refCache.get(consumerRef);
+    if (existingProxy) {
+      proxyStats.cacheHits++;
+      return existingProxy;
+    }
+
+    proxyStats.cacheMisses++;
+
+    const handler: ProxyHandler<T> = {
+      get(obj: T, prop: string | symbol): any {
+        const value = Reflect.get(obj, prop);
+        // Check for getter on the prototype chain with safety limits
+        let isGetter = false;
+        let currentObj: any = obj;
+        const visitedPrototypes = new WeakSet();
+        const MAX_PROTOTYPE_DEPTH = 10; // Reasonable depth limit
+        let depth = 0;
+
+        while (currentObj && !isGetter && depth < MAX_PROTOTYPE_DEPTH) {
+          // Check for circular references
+          if (visitedPrototypes.has(currentObj)) {
+            break;
+          }
+          visitedPrototypes.add(currentObj);
+
+          try {
+            const descriptor = Object.getOwnPropertyDescriptor(
+              currentObj,
+              prop,
+            );
+            if (descriptor && descriptor.get) {
+              isGetter = true;
+              break;
+            }
+            currentObj = Object.getPrototypeOf(currentObj);
+            depth++;
+          } catch (error) {
+            break;
+          }
+        }
+
+        if (!isGetter) {
+          // bind methods to the object if they are functions
+          /*
+          if (typeof value === 'function') {
+            proxyStats.propertyAccesses++;
+            console.log(
+              `🏭 [ProxyFactory] 🔧 Method accessed: ${String(prop)}`,
+            );
+            console.log(`🏭 [ProxyFactory] Binding method to object instance`);
+            return value.bind(obj);
+          }
+          */
+
+          // Return the value directly if it's not a getter or method
+          return value;
+        }
+
+        // For getters, track access and value
+        proxyStats.propertyAccesses++;
+
+        // Track the getter value if it's a primitive
+        const getterValue = value;
+        const isGetterValuePrimitive =
+          getterValue !== null && typeof getterValue !== 'object';
+        const trackValue = isGetterValuePrimitive ? getterValue : undefined;
+
+        // Track access with value for primitives
+        consumerTracker.trackAccess(
+          consumerRef,
+          'class',
+          String(prop),
+          trackValue,
+        );
+        return value;
+      },
+
+      has(obj: T, prop: string | symbol): boolean {
+        return prop in obj;
+      },
+
+      ownKeys(obj: T): (string | symbol)[] {
+        return Reflect.ownKeys(obj);
+      },
+
+      getOwnPropertyDescriptor(
+        obj: T,
+        prop: string | symbol,
+      ): PropertyDescriptor | undefined {
+        return Reflect.getOwnPropertyDescriptor(obj, prop);
+      },
+    };
+
+    const proxy = new Proxy(target, handler);
+    refCache.set(consumerRef, proxy);
+
+    proxyStats.classProxiesCreated++;
+    proxyStats.totalProxiesCreated++;
+
+    return proxy;
+  }
+
+  static getProxyState<B extends BlocBase<any>>(options: {
+    state: BlocState<B>;
+    consumerRef: object;
+    consumerTracker: ConsumerTracker;
+  }): BlocState<B> {
+    return ProxyFactory.createStateProxy({
+      target: options.state,
+      consumerRef: options.consumerRef,
+      consumerTracker: options.consumerTracker,
+    });
+  }
+
+  static getProxyBlocInstance<B extends BlocBase<any>>(options: {
+    blocInstance: B;
+    consumerRef: object;
+    consumerTracker: ConsumerTracker;
+  }): B {
+    return ProxyFactory.createClassProxy({
+      target: options.blocInstance,
+      consumerRef: options.consumerRef,
+      consumerTracker: options.consumerTracker,
+    });
+  }
+
+  static getStats() {
+    const lifetime = Date.now() - proxyStats.createdAt;
+    return {
+      ...proxyStats,
+      totalProxies:
+        proxyStats.stateProxiesCreated + proxyStats.classProxiesCreated,
+      cacheEfficiency:
+        proxyStats.cacheHits + proxyStats.cacheMisses > 0
+          ? `${((proxyStats.cacheHits / (proxyStats.cacheHits + proxyStats.cacheMisses)) * 100).toFixed(1)}%`
+          : 'N/A',
+      lifetime: `${lifetime}ms`,
+      proxiesPerSecond:
+        lifetime > 0
+          ? (proxyStats.totalProxiesCreated / (lifetime / 1000)).toFixed(2)
+          : 'N/A',
+    };
+  }
+
+  static resetStats() {
+    proxyStats = {
+      stateProxiesCreated: 0,
+      classProxiesCreated: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      propertyAccesses: 0,
+      nestedProxiesCreated: 0,
+      totalProxiesCreated: 0,
+      createdAt: Date.now(),
+    };
+  }
+}