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

package/src/adapter/BlacAdapter.ts

@@ -1,14 +1,16 @@
 import { Blac } from '../Blac';
-import { BlocBase } from '../BlocBase';
+import { BlocBase, BlocLifecycleState } from '../BlocBase';
 import { BlocConstructor, BlocState, InferPropsFromGeneric } from '../types';
+import { PropsUpdated } from '../events';
 import { generateUUID } from '../utils/uuid';
+import { shallowEqual } from '../utils/shallowEqual';
 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>;
+  props?: any;
   onMount?: (bloc: B) => void;
   onUnmount?: (bloc: B) => void;
 }
@@ -26,6 +28,10 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
   // Core components
   private consumerTracker: ConsumerTracker;
 
+  // Props ownership tracking
+  private static propsOwners = new WeakMap<BlocBase<any>, string>();
+  private lastProps?: any;
+
   unmountTime: number = 0;
   mountTime: number = 0;
 
@@ -59,6 +65,11 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     if (this.isUsingDependencies && options?.dependencies) {
       this.dependencyValues = options.dependencies(this.blocInstance);
     }
+
+    // Handle initial props if provided
+    if (options?.props !== undefined) {
+      this.updateProps(options.props);
+    }
   }
 
   trackAccess(
@@ -133,7 +144,7 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
         newState: BlocState<InstanceType<B>>,
         oldState: BlocState<InstanceType<B>>,
       ) => {
-        // Handle dependency-based change detection
+        // Case 1: Manual dependencies provided
         if (this.isUsingDependencies && this.options?.dependencies) {
           const newValues = this.options.dependencies(this.blocInstance);
           const hasChanged = this.hasDependencyValuesChanged(
@@ -146,7 +157,15 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
           }
 
           this.dependencyValues = newValues;
-        } else {
+        } 
+        // Case 2: Proxy tracking disabled globally (and no manual dependencies)
+        else if (!Blac.config.proxyDependencyTracking) {
+          // Always trigger re-render when proxy tracking is disabled
+          options.onChange();
+          return;
+        } 
+        // Case 3: Proxy tracking enabled (default behavior)
+        else {
           // Check if any tracked values have changed (proxy-based tracking)
           const consumerInfo = this.consumerTracker.getConsumerInfo(
             this.componentRef.current,
@@ -202,6 +221,11 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     this.consumerTracker.unregister(this.componentRef.current);
     this.blocInstance._removeConsumer(this.id);
 
+    // Clear ownership if we own this bloc
+    if (BlacAdapter.propsOwners.get(this.blocInstance) === this.id) {
+      BlacAdapter.propsOwners.delete(this.blocInstance);
+    }
+
     // Call onUnmount callback
     if (this.options?.onUnmount) {
       try {
@@ -215,8 +239,9 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
   getProxyState = (
     state: BlocState<InstanceType<B>>,
   ): BlocState<InstanceType<B>> => {
-    if (this.isUsingDependencies) {
-      return state; // Return raw state when using dependencies
+    // Return raw state if proxy tracking is disabled globally or using manual dependencies
+    if (this.isUsingDependencies || !Blac.config.proxyDependencyTracking) {
+      return state;
     }
 
     return ProxyFactory.getProxyState({
@@ -227,8 +252,9 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
   };
 
   getProxyBlocInstance = (): InstanceType<B> => {
-    if (this.isUsingDependencies) {
-      return this.blocInstance; // Return raw instance when using dependencies
+    // Return raw instance if proxy tracking is disabled globally or using manual dependencies
+    if (this.isUsingDependencies || !Blac.config.proxyDependencyTracking) {
+      return this.blocInstance;
     }
 
     return ProxyFactory.getProxyBlocInstance({
@@ -243,6 +269,45 @@ export class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     return this.hasMounted;
   }
 
+  updateProps(props: any): void {
+    const bloc = this.blocInstance;
+    
+    // Check ownership
+    if (!BlacAdapter.propsOwners.has(bloc)) {
+      // First adapter with props becomes the owner
+      BlacAdapter.propsOwners.set(bloc, this.id);
+    }
+    
+    if (BlacAdapter.propsOwners.get(bloc) !== this.id) {
+      Blac.warn(
+        `[BlacAdapter] Attempted to set props on ${bloc.constructor.name} from non-owner adapter`
+      );
+      return;
+    }
+    
+    // Disposal safety
+    if ((bloc as any)._disposalState === BlocLifecycleState.DISPOSED ||
+        (bloc as any)._disposalState === BlocLifecycleState.DISPOSING) {
+      return;
+    }
+    
+    // Check if props have changed
+    if (shallowEqual(this.lastProps, props)) {
+      return;
+    }
+    
+    // Update props based on bloc type
+    if ('add' in bloc && typeof bloc.add === 'function') {
+      // Bloc: dispatch PropsUpdated event
+      (bloc as any).add(new PropsUpdated(props));
+    } else if ('_updateProps' in bloc && typeof (bloc as any)._updateProps === 'function') {
+      // Cubit: direct props update
+      (bloc as any)._updateProps(props);
+    }
+    
+    this.lastProps = props;
+  }
+
   private hasDependencyValuesChanged(
     prev: unknown[] | undefined,
     next: unknown[],

package/src/events.ts

@@ -0,0 +1,3 @@
+export class PropsUpdated<P = any> {
+  constructor(public readonly props: P) {}
+}

package/src/index.ts

@@ -4,9 +4,11 @@ export * from './Bloc';
 export * from './BlocBase';
 export * from './Cubit';
 export * from './types';
+export * from './events';
 
 // Utilities
 export * from './utils/uuid';
+export * from './utils/shallowEqual';
 
 // Test utilities
 export * from './testing';

package/src/types.ts

@@ -56,19 +56,10 @@ export type InferPropsFromGeneric<T> =
 export type BlocConstructorParameters<B extends BlocBase<any>> =
   BlocConstructor<B> extends new (...args: infer P) => B ? P : never;
 
-/**
- * Base interface for all Bloc events
- * Events must be objects with a constructor to enable proper type matching
- */
-export interface BlocEvent {
-  readonly type?: string;
-  readonly timestamp?: number;
-}
-
 /**
  * Enhanced constraint for Bloc events - must be objects with proper constructor
  */
-export type BlocEventConstraint = BlocEvent & object;
+export type BlocEventConstraint = object;
 
 /**
  * Error boundary interface for Bloc error handling

package/src/utils/shallowEqual.ts

@@ -0,0 +1,40 @@
+/**
+ * Performs a shallow equality comparison between two values.
+ * For objects, it checks if all top-level properties are equal using Object.is.
+ * @param a First value to compare
+ * @param b Second value to compare
+ * @returns true if values are shallowly equal, false otherwise
+ */
+export function shallowEqual(a: any, b: any): boolean {
+  if (Object.is(a, b)) {
+    return true;
+  }
+
+  if (
+    typeof a !== 'object' ||
+    a === null ||
+    typeof b !== 'object' ||
+    b === null
+  ) {
+    return false;
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (
+      !Object.prototype.hasOwnProperty.call(b, key) ||
+      !Object.is(a[key], b[key])
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}