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

package/src/adapter/ProxyFactory.ts

@@ -1,5 +1,4 @@
 import { BlocBase } from '../BlocBase';
-import { BlocState } from '../types';
 
 interface ConsumerTracker {
   trackAccess: (
@@ -10,299 +9,241 @@ interface ConsumerTracker {
   ) => void;
 }
 
-// Cache for proxies to ensure consistent object identity
+// Minimal cache for backward compatibility
 const proxyCache = new WeakMap<object, WeakMap<object, any>>();
 
-// Statistics tracking
-let proxyStats = {
+// Minimal stats for backward compatibility
+const stats = {
   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;
-    }
+/**
+ * Creates a proxy for state objects that tracks property access
+ */
+export const createStateProxy = <T extends object>(
+  target: T,
+  consumerRef: object,
+  consumerTracker: ConsumerTracker,
+  path = '',
+): T => {
+  if (
+    !consumerRef ||
+    !consumerTracker ||
+    typeof target !== 'object' ||
+    target === null
+  ) {
+    return target;
+  }
 
-    // Check cache to ensure consistent proxy identity
+  // Check cache for backward compatibility with tests
+  if (!path) {
+    // Only cache root objects
     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;
+    const cached = refCache.get(consumerRef);
+    if (cached) {
+      stats.cacheHits++;
+      return cached;
     }
+    stats.cacheMisses++;
+  }
 
-    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);
+  const proxy = new Proxy(target, {
+    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;
+      const value = Reflect.get(obj, prop);
+      const isObject = value && typeof value === 'object';
+
+      // Track access with value for primitives
+      consumerTracker.trackAccess(
+        consumerRef,
+        'state',
+        fullPath,
+        isObject ? undefined : value,
+      );
+
+      // Recursively proxy nested objects and arrays
+      if (
+        isObject &&
+        (Array.isArray(value) ||
+          Object.getPrototypeOf(value) === Object.prototype)
+      ) {
+        return createStateProxy(value, consumerRef, consumerTracker, fullPath);
+      }
+
+      return value;
+    },
+
+    set: () => false, // State should be immutable
+    deleteProperty: () => false, // State properties should not be deleted
+  });
+
+  // Cache root proxies
+  if (!path) {
+    const refCache = proxyCache.get(target)!;
     refCache.set(consumerRef, proxy);
-
-    proxyStats.stateProxiesCreated++;
-    proxyStats.totalProxiesCreated++;
-
-    return proxy;
+    stats.stateProxiesCreated++;
+    stats.totalProxiesCreated++;
   }
 
-  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;
-          }
-        }
+  return proxy;
+};
 
-        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);
-          }
-          */
+/**
+ * Creates a proxy for bloc instances that tracks getter access
+ */
+export const createBlocProxy = <T extends object>(
+  target: T,
+  consumerRef: object,
+  consumerTracker: ConsumerTracker,
+): T => {
+  if (!consumerRef || !consumerTracker) {
+    return target;
+  }
 
-          // Return the value directly if it's not a getter or method
-          return value;
-        }
+  // Check cache
+  let refCache = proxyCache.get(target);
+  if (!refCache) {
+    refCache = new WeakMap();
+    proxyCache.set(target, refCache);
+  }
 
-        // For getters, track access and value
-        proxyStats.propertyAccesses++;
+  const cached = refCache.get(consumerRef);
+  if (cached) {
+    stats.cacheHits++;
+    return cached;
+  }
+  stats.cacheMisses++;
 
-        // Track the getter value if it's a primitive
-        const getterValue = value;
-        const isGetterValuePrimitive =
-          getterValue !== null && typeof getterValue !== 'object';
-        const trackValue = isGetterValuePrimitive ? getterValue : undefined;
+  const proxy = new Proxy(target, {
+    get(obj: T, prop: string | symbol): any {
+      const value = Reflect.get(obj, prop);
 
-        // Track access with value for primitives
+      // Only track getters, not methods or regular properties
+      const descriptor = findPropertyDescriptor(obj, prop);
+      if (descriptor?.get) {
+        // Track getter access with value for primitives
+        const isPrimitive = value !== null && typeof value !== 'object';
         consumerTracker.trackAccess(
           consumerRef,
           'class',
           String(prop),
-          trackValue,
+          isPrimitive ? value : undefined,
         );
-        return value;
-      },
+      }
 
-      has(obj: T, prop: string | symbol): boolean {
-        return prop in obj;
-      },
+      return value;
+    },
+  });
 
-      ownKeys(obj: T): (string | symbol)[] {
-        return Reflect.ownKeys(obj);
-      },
+  // Cache proxy
+  refCache.set(consumerRef, proxy);
+  stats.classProxiesCreated++;
+  stats.totalProxiesCreated++;
 
-      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;
+};
 
-    return proxy;
+/**
+ * Helper to find property descriptor in prototype chain
+ */
+const findPropertyDescriptor = (
+  obj: any,
+  prop: string | symbol,
+  maxDepth = 10,
+): PropertyDescriptor | undefined => {
+  let current = obj;
+  let depth = 0;
+
+  while (current && depth < maxDepth) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, prop);
+    if (descriptor) return descriptor;
+
+    current = Object.getPrototypeOf(current);
+    depth++;
   }
 
-  static getProxyState<B extends BlocBase<any>>(options: {
-    state: BlocState<B>;
+  return undefined;
+};
+
+// Export compatibility functions for easier migration
+export const ProxyFactory = {
+  createStateProxy: (options: {
+    target: any;
     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: {
+    path?: string;
+  }) =>
+    createStateProxy(
+      options.target,
+      options.consumerRef,
+      options.consumerTracker,
+      options.path,
+    ),
+
+  createClassProxy: (options: {
+    target: any;
+    consumerRef: object;
+    consumerTracker: ConsumerTracker;
+  }) =>
+    createBlocProxy(
+      options.target,
+      options.consumerRef,
+      options.consumerTracker,
+    ),
+
+  getProxyState: <B extends BlocBase<any>>(options: {
+    state: any;
+    consumerRef: object;
+    consumerTracker: ConsumerTracker;
+  }) =>
+    createStateProxy(
+      options.state,
+      options.consumerRef,
+      options.consumerTracker,
+    ),
+
+  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(),
-    };
-  }
-}
+  }) =>
+    createBlocProxy(
+      options.blocInstance,
+      options.consumerRef,
+      options.consumerTracker,
+    ),
+
+  // Compatibility functions that return expected structure
+  getStats: () => ({
+    ...stats,
+    propertyAccesses: 0,
+    nestedProxiesCreated: 0,
+    cacheEfficiency:
+      stats.cacheHits + stats.cacheMisses > 0
+        ? `${((stats.cacheHits / (stats.cacheHits + stats.cacheMisses)) * 100).toFixed(1)}%`
+        : 'N/A',
+    lifetime: '0ms',
+    proxiesPerSecond: 'N/A',
+  }),
+  resetStats: () => {
+    stats.stateProxiesCreated = 0;
+    stats.classProxiesCreated = 0;
+    stats.cacheHits = 0;
+    stats.cacheMisses = 0;
+    stats.totalProxiesCreated = 0;
+  },
+};