@blac/core 2.0.0-rc-10 → 2.0.0-rn-12

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export declare 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;
 }
@@ -23,6 +23,16 @@ export declare class Blac {
     static get getAllBlocs(): <B extends BlocConstructor<any>>(blocClass: B, options?: {
         searchIsolated?: boolean;
     }) => InstanceType<B>[];
+    /** Private static configuration */
+    private static _config;
+    /** Get current configuration */
+    static get config(): Readonly<BlacConfig>;
+    /**
+     * Set or update Blac configuration
+     * @param config - Partial configuration to merge with existing config
+     * @throws Error if configuration is invalid
+     */
+    static setConfig(config: Partial<BlacConfig>): void;
     /** Map storing all registered bloc instances by their class name and ID */
     blocInstanceMap: Map<string, BlocBase<unknown>>;
     /** Map storing isolated bloc instances grouped by their constructor */
@@ -225,6 +235,8 @@ export declare class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     };
     blocInstance: InstanceType<B>;
     private consumerTracker;
+    private static propsOwners;
+    private lastProps?;
     unmountTime: number;
     mountTime: number;
     private dependencyValues?;
@@ -258,6 +270,7 @@ export declare class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
     getProxyState: (state: BlocState<InstanceType<B>>) => BlocState<InstanceType<B>>;
     getProxyBlocInstance: () => InstanceType<B>;
     get calledOnMount(): boolean;
+    updateProps(props: any): void;
     private hasDependencyValuesChanged;
 }
 
@@ -267,6 +280,12 @@ export declare class BlacAdapter<B extends BlocConstructor<BlocBase<any>>> {
 export declare interface BlacConfig {
     /** Whether to expose the Blac instance globally */
     exposeBlacInstance?: boolean;
+    /**
+     * Whether to enable proxy dependency tracking for automatic re-render optimization.
+     * When false, state changes always cause re-renders unless dependencies are manually specified.
+     * Default: true
+     */
+    proxyDependencyTracking?: boolean;
 }
 
 /**
@@ -498,19 +517,10 @@ export declare interface BlocErrorBoundary<S, A extends BlocEventConstraint> {
     shouldRethrow?: (error: Error, event: A) => boolean;
 }
 
-/**
- * Base interface for all Bloc events
- * Events must be objects with a constructor to enable proper type matching
- */
-export declare interface BlocEvent {
-    readonly type?: string;
-    readonly timestamp?: number;
-}
-
 /**
  * Enhanced constraint for Bloc events - must be objects with proper constructor
  */
-export declare type BlocEventConstraint = BlocEvent & object;
+export declare type BlocEventConstraint = object;
 
 /**
  * Function type for determining dependencies that trigger re-renders
@@ -620,6 +630,11 @@ declare interface ConsumerTracker_2 {
  * @template P - The type of parameters (optional, defaults to null)
  */
 export declare abstract class Cubit<S, P = null> extends BlocBase<S, P> {
+    /* Excluded from this release type: _updateProps */
+    /**
+     * Optional override for props handling
+     */
+    protected onPropsChanged?(oldProps: P | undefined, newProps: P): void;
     /**
      * Updates the current state and notifies all observers of the change.
      * If the new state is identical to the current state (using Object.is),
@@ -728,6 +743,11 @@ export declare class MockCubit<S> extends Cubit<S> {
     clearStateHistory(): void;
 }
 
+export declare class PropsUpdated<P = any> {
+    readonly props: P;
+    constructor(props: P);
+}
+
 export declare class ProxyFactory {
     static createStateProxy<T extends object>(options: {
         target: T;
@@ -772,6 +792,15 @@ export declare class ProxyFactory {
  */
 export declare function setBlacInstanceManager(manager: BlacInstanceManager): void;
 
+/**
+ * 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 declare function shallowEqual(a: any, b: any): boolean;
+
 /**
  * Result of an atomic state transition operation
  */