@blac/core 2.0.0-rc-14 → 2.0.0-rc.0

package/src/adapter/BlacAdapter.ts

@@ -1,467 +0,0 @@
-import { Blac } from '../Blac';
-import { BlocBase } from '../BlocBase';
-import { BlocConstructor, BlocState } from '../types';
-import { generateUUID } from '../utils/uuid';
-import { generateInstanceIdFromProps } from '../utils/generateInstanceId';
-import { ProxyFactory } from './ProxyFactory';
-
-export interface AdapterOptions<B extends BlocBase<any>> {
-  instanceId?: string;
-  dependencies?: (bloc: B) => unknown[];
-  staticProps?: any;
-  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 = `adapter-${generateUUID()}`;
-  public readonly blocConstructor: B;
-  public readonly componentRef: { current: object } = { current: {} };
-  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(
-    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 bloc instance
-    this.updateBlocInstance();
-
-    // Initialize dependency values if using dependencies
-    if (this.isUsingDependencies && options?.dependencies) {
-      this.dependencyValues = options.dependencies(this.blocInstance);
-    }
-
-    // Notify plugins
-    const metadata = this.getAdapterMetadata();
-    Blac.getInstance().plugins.notifyAdapterCreated(this, metadata);
-  }
-
-  trackAccess(
-    consumerRef: object,
-    type: 'state' | 'class',
-    path: string,
-    value?: any,
-  ): void {
-    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}`);
-      }
-    }
-  }
-
-  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;
-  }
-
-  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;
-      }
-    }
-
-    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;
-    }
-
-    // Return cached proxy if state hasn't changed
-    const currentState = this.blocInstance.state;
-    if (this.cachedStateProxy && this.lastProxiedState === currentState) {
-      return this.cachedStateProxy;
-    }
-
-    // Create new proxy for new state
-    this.lastProxiedState = currentState;
-    this.cachedStateProxy = this.createStateProxy({ target: currentState });
-    return this.cachedStateProxy!;
-  };
-
-  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({
-      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,
-    });
-  };
-
-  // Lifecycle methods
-  mount = () => {
-    this.hasMounted = true;
-    this.mountCount++;
-    this.mountTime = Date.now();
-
-    // Call onMount hook
-    if (this.options?.onMount) {
-      this.options.onMount(this.blocInstance);
-    }
-
-    // Refresh dependencies if using manual tracking
-    if (this.isUsingDependencies && this.options?.dependencies) {
-      this.dependencyValues = this.options.dependencies(this.blocInstance);
-    }
-
-    // Notify plugins
-    const metadata = this.getAdapterMetadata();
-    Blac.getInstance().plugins.notifyAdapterMount(this, metadata);
-  };
-
-  unmount = () => {
-    this.unmountTime = Date.now();
-
-    // Cancel subscription
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = undefined;
-      this.subscriptionId = undefined;
-    }
-
-    // Call onUnmount hook
-    if (this.options?.onUnmount) {
-      try {
-        this.options.onUnmount(this.blocInstance);
-      } catch (error) {
-        console.error('Error in onUnmount hook:', error);
-      }
-    }
-
-    // Notify plugins
-    const metadata = this.getAdapterMetadata();
-    Blac.getInstance().plugins.notifyAdapterUnmount(this, metadata);
-  };
-
-  // 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();
-      }
-    }
-  }
-
-  // Set component name for rerender logging
-  setComponentName(name: string): void {
-    this.componentName = name;
-  }
-
-  // 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);
-    }
-
-    const metadata = this.getAdapterMetadata();
-    Blac.getInstance().plugins.notifyAdapterRender(this, metadata);
-  }
-
-  // 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,
-    };
-  }
-
-  // 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];
-    }
-
-    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)');
-      }
-    }
-
-    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;
-    }
-
-    // Handle primitives
-    if (typeof oldObj !== 'object' || typeof newObj !== 'object') {
-      if (oldObj !== newObj) {
-        changes.push(basePath || '(root)');
-      }
-      return changes;
-    }
-
-    // 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;
-    }
-
-    // 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 changes;
-  }
-
-  // Get last rerender reason
-  getLastRerenderReason(): any {
-    // This method is deprecated - render reason is now handled by the RenderLoggingPlugin
-    return undefined;
-  }
-}

package/src/adapter/ProxyFactory.ts

@@ -1,249 +0,0 @@
-import { BlocBase } from '../BlocBase';
-
-interface ConsumerTracker {
-  trackAccess: (
-    consumerRef: object,
-    type: 'state' | 'class',
-    path: string,
-    value?: any,
-  ) => void;
-}
-
-// Minimal cache for backward compatibility
-const proxyCache = new WeakMap<object, WeakMap<object, any>>();
-
-// Minimal stats for backward compatibility
-const stats = {
-  stateProxiesCreated: 0,
-  classProxiesCreated: 0,
-  cacheHits: 0,
-  cacheMisses: 0,
-  totalProxiesCreated: 0,
-};
-
-/**
- * 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 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 cached = refCache.get(consumerRef);
-    if (cached) {
-      stats.cacheHits++;
-      return cached;
-    }
-    stats.cacheMisses++;
-  }
-
-  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);
-    stats.stateProxiesCreated++;
-    stats.totalProxiesCreated++;
-  }
-
-  return proxy;
-};
-
-/**
- * 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;
-  }
-
-  // Check cache
-  let refCache = proxyCache.get(target);
-  if (!refCache) {
-    refCache = new WeakMap();
-    proxyCache.set(target, refCache);
-  }
-
-  const cached = refCache.get(consumerRef);
-  if (cached) {
-    stats.cacheHits++;
-    return cached;
-  }
-  stats.cacheMisses++;
-
-  const proxy = new Proxy(target, {
-    get(obj: T, prop: string | symbol): any {
-      const value = Reflect.get(obj, prop);
-
-      // 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),
-          isPrimitive ? value : undefined,
-        );
-      }
-
-      return value;
-    },
-  });
-
-  // Cache proxy
-  refCache.set(consumerRef, proxy);
-  stats.classProxiesCreated++;
-  stats.totalProxiesCreated++;
-
-  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++;
-  }
-
-  return undefined;
-};
-
-// Export compatibility functions for easier migration
-export const ProxyFactory = {
-  createStateProxy: (options: {
-    target: any;
-    consumerRef: object;
-    consumerTracker: ConsumerTracker;
-    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;
-  }) =>
-    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;
-  },
-};