@blac/core 2.0.0-rn-12 → 2.0.1

package/src/adapter/ConsumerTracker.ts

@@ -1,241 +0,0 @@
-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

@@ -1,308 +0,0 @@
-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(),
-    };
-  }
-}