@blac/core 2.0.0-rc-3 → 2.0.0-rc-5

package/dist/index.es.js

@@ -1,69 +1,92 @@
-var B = Object.defineProperty;
-var I = (d, e, t) => e in d ? B(d, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : d[e] = t;
-var s = (d, e, t) => I(d, typeof e != "symbol" ? e + "" : e, t);
-const o = class o {
+var v = Object.defineProperty;
+var w = (l, e, t) => e in l ? v(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
+var n = (l, e, t) => w(l, typeof e != "symbol" ? e + "" : e, t);
+const d = class d {
+  getInstance() {
+    return d._instance || (d._instance = new h({ __unsafe_ignore_singleton: !0 })), d._instance;
+  }
+  setInstance(e) {
+    d._instance = e;
+  }
+  resetInstance() {
+    const e = d._instance;
+    if (d._instance = new h({ __unsafe_ignore_singleton: !0 }), e)
+      for (const t of e.keepAliveBlocs)
+        d._instance.keepAliveBlocs.add(t), d._instance.uidRegistry.set(t.uid, t);
+  }
+};
+n(d, "_instance");
+let _ = d, u = new _();
+function b(l) {
+  u = l;
+}
+const r = class r {
   /**
    * Creates a new Blac instance.
    * @param options - Configuration options including singleton control
    */
   constructor(e = {}) {
     /** Timestamp when the instance was created */
-    s(this, "createdAt", Date.now());
+    n(this, "createdAt", Date.now());
     /** Map storing all registered bloc instances by their class name and ID */
-    s(this, "blocInstanceMap", /* @__PURE__ */ new Map());
+    n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
     /** Map storing isolated bloc instances grouped by their constructor */
-    s(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
+    n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
+    /** Map for O(1) lookup of isolated blocs by UID */
+    n(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
+    /** Map tracking UIDs to prevent memory leaks */
+    n(this, "uidRegistry", /* @__PURE__ */ new Map());
+    /** Set of keep-alive blocs for controlled cleanup */
+    n(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
     /** Flag to control whether changes should be posted to document */
-    s(this, "postChangesToDocument", !1);
+    n(this, "postChangesToDocument", !1);
     /**
      * Logs messages to console when logging is enabled
      * @param args - Arguments to log
      */
-    s(this, "log", (...e) => {
-      o.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...e);
+    n(this, "log", (...e) => {
+      r.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...e);
     });
     /**
      * Logs a warning message
      * @param message - Warning message
      * @param args - Additional arguments
      */
-    s(this, "warn", (e, ...t) => {
-      o.enableLog && console.warn(`🚨 [Blac ${String(o.instance.createdAt)}]`, e, ...t);
+    n(this, "warn", (e, ...t) => {
+      r.enableLog && console.warn(`🚨 [Blac ${String(r.instance.createdAt)}]`, e, ...t);
     });
     /**
      * Logs an error message
      * @param message - Error message
      * @param args - Additional arguments
      */
-    s(this, "error", (e, ...t) => {
-      o.enableLog && console.error(`🚨 [Blac ${String(o.instance.createdAt)}]`, e, ...t);
+    n(this, "error", (e, ...t) => {
+      r.enableLog && console.error(`🚨 [Blac ${String(r.instance.createdAt)}]`, e, ...t);
     });
     /**
      * Resets the Blac instance to a new one, disposing non-keepAlive blocs
      * from the old instance.
      */
-    s(this, "resetInstance", () => {
+    n(this, "resetInstance", () => {
       this.log("Reset Blac instance");
       const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
-      e.forEach((n) => {
-        n._dispose();
-      }), t.forEach((n) => {
-        n.forEach((i) => {
-          i._dispose();
+      e.forEach((s) => {
+        s._keepAlive || s._dispose();
+      }), t.forEach((s) => {
+        s.forEach((i) => {
+          i._keepAlive || i._dispose();
         });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), o.instance = new o({
-        __unsafe_ignore_singleton: !0
-      });
+      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), u.resetInstance();
     });
     /**
      * Disposes of a bloc instance by removing it from the appropriate registry
      * @param bloc - The bloc instance to dispose
      */
-    s(this, "disposeBloc", (e) => {
-      const t = e.constructor, n = this.createBlocInstanceMapKey(e._name, e._id);
-      this.log(`[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(t.isolated)}`), t.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(n)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
+    n(this, "disposeBloc", (e) => {
+      const t = e.constructor, s = this.createBlocInstanceMapKey(e._name, e._id);
+      this.log(`[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(t.isolated)}`), t.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
     });
-    s(this, "activateBloc", (e) => {
+    n(this, "activateBloc", (e) => {
       const t = e.constructor;
       (e.isIsolated ? this.findIsolatedBlocInstance(t, e._id) : this.findRegisteredBlocInstance(t, e._id)) || (this.log(`[${e._name}:${String(e._id)}] activateBloc called. Isolated: ${String(e.isIsolated)}`), e.isIsolated ? this.registerIsolatedBlocInstance(e) : this.registerBlocInstance(e));
     });
@@ -78,27 +101,27 @@ const o = class o {
      *   - instanceRef: Optional reference string for the instance
      * @returns The bloc instance
      */
-    s(this, "getBloc", (e, t = {}) => {
-      const { id: n } = t, i = e, a = n ?? e.name;
+    n(this, "getBloc", (e, t = {}) => {
+      const { id: s } = t, i = e, a = s ?? e.name;
       if (i.isolated) {
-        const l = this.findIsolatedBlocInstance(e, a);
-        if (l)
-          return this.log(`[${e.name}:${String(a)}] (getBloc) Found existing isolated instance.`, t), l;
+        const c = this.findIsolatedBlocInstance(e, a);
+        if (c)
+          return this.log(`[${e.name}:${String(a)}] (getBloc) Found existing isolated instance.`, t), c;
         if (t.throwIfNotFound)
           throw new Error(`Isolated bloc ${e.name} not found`);
       } else {
-        const l = this.findRegisteredBlocInstance(e, a);
-        if (l)
-          return this.log(`[${e.name}:${String(a)}] (getBloc) Found existing registered instance.`, t), l;
+        const c = this.findRegisteredBlocInstance(e, a);
+        if (c)
+          return this.log(`[${e.name}:${String(a)}] (getBloc) Found existing registered instance.`, t), c;
         if (t.throwIfNotFound)
           throw new Error(`Registered bloc ${e.name} not found`);
       }
-      const r = this.createNewBlocInstance(
+      const o = this.createNewBlocInstance(
         e,
         a,
         t
       );
-      return this.log(`[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`, t, r), r;
+      return this.log(`[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`, t, o), o;
     });
     /**
      * Gets a bloc instance or throws an error if it doesn't exist
@@ -108,8 +131,8 @@ const o = class o {
      *   - props: Properties to pass to the bloc constructor
      *   - instanceRef: Optional reference string for the instance
      */
-    s(this, "getBlocOrThrow", (e, t = {}) => {
-      const n = e.isolated, i = t.id || e.name, a = n ? this.findIsolatedBlocInstance(e, i) : this.findRegisteredBlocInstance(e, i);
+    n(this, "getBlocOrThrow", (e, t = {}) => {
+      const s = e.isolated, i = t.id || e.name, a = s ? this.findIsolatedBlocInstance(e, i) : this.findRegisteredBlocInstance(e, i);
       if (a)
         return a;
       throw new Error(`Bloc ${e.name} not found`);
@@ -121,27 +144,85 @@ const o = class o {
      *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
      * @returns Array of matching bloc instances
      */
-    s(this, "getAllBlocs", (e, t = {}) => {
-      const n = [];
+    n(this, "getAllBlocs", (e, t = {}) => {
+      const s = [];
       if (this.blocInstanceMap.forEach((i) => {
-        i.constructor === e && n.push(i);
+        i.constructor === e && s.push(i);
       }), t.searchIsolated !== !1) {
         const i = this.isolatedBlocMap.get(e);
-        i && n.push(...i.map((a) => a));
+        i && s.push(...i.map((a) => a));
       }
-      return n;
+      return s;
+    });
+    /**
+     * Disposes all keep-alive blocs of a specific type
+     * @param blocClass - The bloc class to dispose
+     */
+    n(this, "disposeKeepAliveBlocs", (e) => {
+      const t = [];
+      for (const s of this.keepAliveBlocs)
+        (!e || s.constructor === e) && t.push(s);
+      t.forEach((s) => s._dispose());
+    });
+    /**
+     * Disposes all blocs matching a pattern
+     * @param predicate - Function to test each bloc for disposal
+     */
+    n(this, "disposeBlocs", (e) => {
+      const t = [];
+      for (const s of this.blocInstanceMap.values())
+        e(s) && t.push(s);
+      for (const s of this.isolatedBlocMap.values())
+        for (const i of s)
+          e(i) && t.push(i);
+      t.forEach((s) => s._dispose());
+    });
+    /**
+     * Gets memory usage statistics for debugging
+     */
+    n(this, "getMemoryStats", () => ({
+      totalBlocs: this.uidRegistry.size,
+      registeredBlocs: this.blocInstanceMap.size,
+      isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce((e, t) => e + t.length, 0),
+      keepAliveBlocs: this.keepAliveBlocs.size,
+      isolatedBlocTypes: this.isolatedBlocMap.size
+    }));
+    /**
+     * Validates consumer references and cleans up orphaned consumers
+     */
+    n(this, "validateConsumers", () => {
+      for (const e of this.uidRegistry.values())
+        e._consumers.size === 0 && !e._keepAlive && setTimeout(() => {
+          e._consumers.size === 0 && !e._keepAlive && e._dispose();
+        }, 1e3);
     });
     const { __unsafe_ignore_singleton: t = !1 } = e;
     if (!t)
-      return o.instance;
-    o.instance = this;
+      return r.instance;
+    u.setInstance(this);
+  }
+  /** @deprecated Use getInstance() instead */
+  static get instance() {
+    return u.getInstance();
+  }
+  static get getAllBlocs() {
+    return r.instance.getAllBlocs;
+  }
+  static get log() {
+    return r.instance.log;
   }
   /**
-   * Gets the singleton instance of Blac
+   * Gets the current Blac instance
    * @returns The Blac instance
    */
   static getInstance() {
-    return o.instance;
+    return u.getInstance();
+  }
+  static get warn() {
+    return r.instance.warn;
+  }
+  static get error() {
+    return r.instance.error;
   }
   /**
    * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
@@ -158,7 +239,7 @@ const o = class o {
    */
   unregisterBlocInstance(e) {
     const t = this.createBlocInstanceMapKey(e._name, e._id);
-    this.blocInstanceMap.delete(t);
+    this.blocInstanceMap.delete(t), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
   }
   /**
    * Registers a bloc instance in the main registry
@@ -166,7 +247,7 @@ const o = class o {
    */
   registerBlocInstance(e) {
     const t = this.createBlocInstanceMapKey(e._name, e._id);
-    this.blocInstanceMap.set(t, e);
+    this.blocInstanceMap.set(t, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
   }
   /**
    * Finds a registered bloc instance by its class and ID
@@ -184,27 +265,34 @@ const o = class o {
    * @param bloc - The isolated bloc instance to register
    */
   registerIsolatedBlocInstance(e) {
-    const t = e.constructor, n = this.isolatedBlocMap.get(t);
-    n ? n.push(e) : this.isolatedBlocMap.set(t, [e]);
+    const t = e.constructor, s = this.isolatedBlocMap.get(t);
+    s ? s.push(e) : this.isolatedBlocMap.set(t, [e]), this.isolatedBlocIndex.set(e.uid, e), this.uidRegistry.set(e.uid, e), e._keepAlive && this.keepAliveBlocs.add(e);
   }
   /**
    * Unregister an isolated bloc instance from the isolated registry
    * @param bloc - The isolated bloc instance to unregister
    */
   unregisterIsolatedBlocInstance(e) {
-    const t = e.constructor, n = this.isolatedBlocMap.get(t);
-    if (n) {
-      const i = n.findIndex((a) => a._id === e._id);
-      i !== -1 && n.splice(i, 1), n.length === 0 && this.isolatedBlocMap.delete(t);
+    const t = e.constructor, s = this.isolatedBlocMap.get(t);
+    if (s) {
+      const i = s.findIndex((a) => a.uid === e.uid);
+      i !== -1 && s.splice(i, 1), s.length === 0 && this.isolatedBlocMap.delete(t);
     }
+    this.isolatedBlocIndex.delete(e.uid), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
   }
   /**
-   * Finds an isolated bloc instance by its class and ID
+   * Finds an isolated bloc instance by its class and ID (O(n) lookup)
    */
   findIsolatedBlocInstance(e, t) {
     if (!e.isolated) return;
     const i = this.isolatedBlocMap.get(e);
-    return i ? i.find((r) => r._id === t) : void 0;
+    return i ? i.find((o) => o._id === t) : void 0;
+  }
+  /**
+   * Finds an isolated bloc instance by UID (O(1) lookup)
+   */
+  findIsolatedBlocInstanceByUid(e) {
+    return this.isolatedBlocIndex.get(e);
   }
   /**
    * Creates a new bloc instance and registers it in the appropriate registry
@@ -214,24 +302,46 @@ const o = class o {
    * @param instanceRef - Optional reference string for the instance
    * @returns The newly created bloc instance
    */
-  createNewBlocInstance(e, t, n = {}) {
-    const { props: i, instanceRef: a } = n, r = new e(i);
-    return r._instanceRef = a, r.props = i || null, r._updateId(t), r.isIsolated ? (this.registerIsolatedBlocInstance(r), r) : (this.registerBlocInstance(r), r);
+  createNewBlocInstance(e, t, s = {}) {
+    const { props: i, instanceRef: a } = s, o = new e(i);
+    return o._instanceRef = a, o.props = i || null, o._updateId(t), o._setDisposalHandler((c) => this.disposeBloc(c)), o.isIsolated ? (this.registerIsolatedBlocInstance(o), o) : (this.registerBlocInstance(o), o);
+  }
+  static get activateBloc() {
+    return r.instance.activateBloc;
+  }
+  static get getBloc() {
+    return r.instance.getBloc;
+  }
+  static get getBlocOrThrow() {
+    return r.instance.getBlocOrThrow;
+  }
+  static get disposeKeepAliveBlocs() {
+    return r.instance.disposeKeepAliveBlocs;
+  }
+  static get disposeBlocs() {
+    return r.instance.disposeBlocs;
+  }
+  static get getMemoryStats() {
+    return r.instance.getMemoryStats;
+  }
+  static get validateConsumers() {
+    return r.instance.validateConsumers;
   }
 };
-/** The singleton instance of Blac */
-s(o, "instance", new o()), s(o, "getAllBlocs", o.instance.getAllBlocs), /** Flag to enable/disable logging */
-s(o, "enableLog", !1), s(o, "log", o.instance.log), s(o, "warn", o.instance.warn), s(o, "error", o.instance.error), s(o, "resetInstance", o.instance.resetInstance), s(o, "activateBloc", o.instance.activateBloc), s(o, "getBloc", o.instance.getBloc), s(o, "getBlocOrThrow", o.instance.getBlocOrThrow);
-let c = o;
-class _ {
+/** Flag to enable/disable logging */
+n(r, "enableLog", !1), n(r, "resetInstance", () => {
+  u.resetInstance();
+});
+let h = r;
+class m {
   /**
    * Creates a new BlacObservable instance
    * @param bloc - The Bloc instance to observe
    */
   constructor(e) {
     /** The Bloc instance this observable is associated with */
-    s(this, "bloc");
-    s(this, "_observers", /* @__PURE__ */ new Set());
+    n(this, "bloc");
+    n(this, "_observers", /* @__PURE__ */ new Set());
     this.bloc = e;
   }
   /**
@@ -254,8 +364,8 @@ class _ {
    * @returns A function that can be called to unsubscribe the observer
    */
   subscribe(e) {
-    return c.log("BlacObservable.subscribe: Subscribing observer.", this.bloc, e), this._observers.add(e), e.lastState || (e.lastState = e.dependencyArray ? e.dependencyArray(this.bloc.state) : []), () => {
-      c.log("BlacObservable.subscribe: Unsubscribing observer.", this.bloc, e), this.unsubscribe(e);
+    return h.log("BlacObservable.subscribe: Subscribing observer.", this.bloc, e), this._observers.add(e), e.lastState || (e.lastState = e.dependencyArray ? e.dependencyArray(this.bloc.state) : []), () => {
+      h.log("BlacObservable.subscribe: Unsubscribing observer.", this.bloc, e), this.unsubscribe(e);
     };
   }
   /**
@@ -263,7 +373,7 @@ class _ {
    * @param observer - The observer to unsubscribe
    */
   unsubscribe(e) {
-    this._observers.delete(e), this.size === 0 && (c.log("BlacObservable.unsubscribe: No observers left. Disposing bloc.", this.bloc), this.bloc._dispose());
+    this._observers.delete(e), this.size === 0 && (h.log("BlacObservable.unsubscribe: No observers left. Disposing bloc.", this.bloc), this.bloc._dispose());
   }
   /**
    * Notifies all observers of a state change
@@ -271,23 +381,23 @@ class _ {
    * @param oldState - The previous state value
    * @param action - Optional action that triggered the state change
    */
-  notify(e, t, n) {
+  notify(e, t, s) {
     this._observers.forEach((i) => {
       let a = !1;
       if (i.dependencyArray) {
-        const r = i.lastState || [], l = i.dependencyArray(e);
-        for (let h = 0; h < l.length; h++) {
-          const f = l[h], p = r[h] || [];
-          for (let u = 0; u < f.length; u++)
-            if (!Object.is(f[u], p[u])) {
+        const o = i.lastState || [], c = i.dependencyArray(e);
+        for (let p = 0; p < c.length; p++) {
+          const B = c[p], I = o[p] || [];
+          for (let f = 0; f < B.length; f++)
+            if (!Object.is(B[f], I[f])) {
               a = !0;
               break;
             }
         }
-        i.lastState = l;
+        i.lastState = c;
       } else
         a = !0;
-      a && i.fn(e, t, n);
+      a && i.fn(e, t, s);
     });
   }
   /**
@@ -307,62 +417,57 @@ class g {
    * @param initialState The initial state value for this Bloc
    */
   constructor(e) {
-    s(this, "uid", crypto.randomUUID());
+    n(this, "uid", crypto.randomUUID());
     /**
      * Defines how dependencies are selected from the state for efficient updates.
      * When provided, observers will only be notified when selected dependencies change.
      */
-    s(this, "defaultDependencySelector");
+    n(this, "defaultDependencySelector");
     /**
      * @internal
      * Indicates if this specific Bloc instance is isolated from others of the same type.
      */
-    s(this, "_isolated", !1);
+    n(this, "_isolated", !1);
     /**
      * @internal
      * Observable responsible for managing state listeners and notifying consumers.
      */
-    s(this, "_observer");
-    /**
-     * @internal
-     * Reference to the global Blac manager instance.
-     */
-    s(this, "_blac", c.getInstance());
+    n(this, "_observer");
     /**
      * The unique identifier for this Bloc instance.
      * Defaults to the class name, but can be customized.
      */
-    s(this, "_id");
+    n(this, "_id");
     /**
      * @internal
      * Reference string used internally for tracking and debugging.
      */
-    s(this, "_instanceRef");
+    n(this, "_instanceRef");
     /**
      * @internal
      * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
      */
-    s(this, "_keepAlive", !1);
+    n(this, "_keepAlive", !1);
     /**
      * @readonly
      * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
      */
-    s(this, "_createdAt", Date.now());
+    n(this, "_createdAt", Date.now());
     /**
      * @internal
      * The current state of the Bloc.
      */
-    s(this, "_state");
+    n(this, "_state");
     /**
      * @internal
      * The previous state of the Bloc, maintained for comparison and history.
      */
-    s(this, "_oldState");
+    n(this, "_oldState");
     /**
      * Props passed during Bloc instance creation.
      * Can be used to configure or parameterize the Bloc's behavior.
      */
-    s(this, "props", null);
+    n(this, "props", null);
     /**
      * @internal
      * Updates the Bloc instance's ID to a new value.
@@ -370,7 +475,7 @@ class g {
      * 
      * @param id The new ID to assign to this Bloc instance
      */
-    s(this, "_updateId", (e) => {
+    n(this, "_updateId", (e) => {
       const t = this._id;
       !e || e === t || (this._id = e);
     });
@@ -378,21 +483,27 @@ class g {
      * @internal
      * Optional function to be called when the Bloc is disposed.
      */
-    s(this, "onDispose");
+    n(this, "onDispose");
     /**
      * @internal
      * Set of consumer IDs currently listening to this Bloc's state changes.
      */
-    s(this, "_consumers", /* @__PURE__ */ new Set());
+    n(this, "_consumers", /* @__PURE__ */ new Set());
+    /**
+     * @internal
+     * WeakSet to track consumer references for cleanup validation
+     */
+    n(this, "_consumerRefs", /* @__PURE__ */ new WeakSet());
     /**
      * @internal
      * Registers a new consumer to this Bloc instance.
      * Notifies the Blac manager that a consumer has been added.
      * 
      * @param consumerId The unique ID of the consumer being added
+     * @param consumerRef Optional reference to the consumer object for cleanup validation
      */
-    s(this, "_addConsumer", (e) => {
-      this._consumers.has(e) || (this._consumers.add(e), c.log("BlocBase._addConsumer", this, e));
+    n(this, "_addConsumer", (e, t) => {
+      this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.add(t));
     });
     /**
      * @internal
@@ -401,10 +512,25 @@ class g {
      * 
      * @param consumerId The unique ID of the consumer being removed
      */
-    s(this, "_removeConsumer", (e) => {
-      this._consumers.has(e) && (this._consumers.delete(e), c.log("BlocBase._removeConsumer", this, e));
+    n(this, "_removeConsumer", (e) => {
+      this._consumers.has(e) && (this._consumers.delete(e), this._consumers.size === 0 && !this._keepAlive && this._scheduleDisposal());
     });
-    s(this, "lastUpdate", Date.now());
+    /**
+     * @internal
+     * Handler function for disposal (can be set by Blac manager)
+     */
+    n(this, "_disposalHandler");
+    n(this, "lastUpdate", Date.now());
+    /**
+     * @internal
+     * Flag to indicate if batching is enabled for this bloc
+     */
+    n(this, "_batchingEnabled", !1);
+    /**
+     * @internal
+     * Pending state updates when batching is enabled
+     */
+    n(this, "_pendingUpdates", []);
     /**
      * @internal
      * Updates the state and notifies all observers of the change.
@@ -413,12 +539,42 @@ class g {
      * @param oldState The previous state for comparison
      * @param action Optional metadata about what caused the state change
      */
-    s(this, "_pushState", (e, t, n) => {
-      this._state = e, this._observer.notify(e, t, n), this.lastUpdate = Date.now();
+    n(this, "_pushState", (e, t, s) => {
+      if (e === void 0) {
+        console.warn("BlocBase._pushState: newState is undefined", this);
+        return;
+      }
+      if (s != null) {
+        const i = typeof s;
+        ["string", "object", "number"].includes(i) || console.warn("BlocBase._pushState: Invalid action type", this, s);
+      }
+      if (this._batchingEnabled) {
+        this._pendingUpdates.push({ newState: e, oldState: t, action: s });
+        return;
+      }
+      this._oldState = t, this._state = e, this._observer.notify(e, t, s), this.lastUpdate = Date.now();
+    });
+    /**
+     * Enables batching for multiple state updates
+     * @param batchFn Function to execute with batching enabled
+     */
+    n(this, "batch", (e) => {
+      const t = this._batchingEnabled;
+      this._batchingEnabled = !0;
+      try {
+        const s = e();
+        if (this._pendingUpdates.length > 0) {
+          const i = this._pendingUpdates[this._pendingUpdates.length - 1];
+          this._oldState = this._pendingUpdates[0].oldState, this._state = i.newState, this._observer.notify(i.newState, this._oldState, i.action), this.lastUpdate = Date.now(), this._pendingUpdates = [];
+        }
+        return s;
+      } finally {
+        this._batchingEnabled = t;
+      }
     });
-    this._state = e, this._observer = new _(this), c.log("Bloc Created", this), this._id = this.constructor.name;
+    this._state = e, this._observer = new m(this), this._id = this.constructor.name;
     const t = this.constructor;
-    this._keepAlive = t.keepAlive, this._isolated = t.isolated;
+    this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1;
   }
   get isIsolated() {
     return this._isolated;
@@ -447,7 +603,23 @@ class g {
    */
   _dispose() {
     var e;
-    this._observer.clear(), (e = this.onDispose) == null || e.call(this), c.log("BlocBase._dispose", this), c.instance.disposeBloc(this);
+    this._consumers.clear(), this._observer.clear(), (e = this.onDispose) == null || e.call(this);
+  }
+  /**
+   * @internal
+   * Sets the disposal handler for this bloc
+   */
+  _setDisposalHandler(e) {
+    this._disposalHandler = e;
+  }
+  /**
+   * @internal
+   * Schedules disposal of this bloc instance if it has no consumers
+   */
+  _scheduleDisposal() {
+    setTimeout(() => {
+      this._consumers.size === 0 && !this._keepAlive && (this._disposalHandler ? this._disposalHandler(this) : this._dispose());
+    }, 0);
   }
 }
 /**
@@ -455,45 +627,45 @@ class g {
  * Use this when state should not be shared between components.
  * @default false
  */
-s(g, "isolated", !1), /**
+n(g, "isolated", !1), /**
  * When true, the Bloc instance persists even when there are no active consumers.
  * Useful for maintaining state between component unmount/remount cycles.
  * @default false
  */
-s(g, "keepAlive", !1);
-class b extends g {
+n(g, "keepAlive", !1);
+class A extends g {
   constructor() {
     super(...arguments);
     // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
     // The handler's event parameter will be correctly typed to the specific EventConstructor
     // by the 'on' method's signature.
-    s(this, "eventHandlers", /* @__PURE__ */ new Map());
+    n(this, "eventHandlers", /* @__PURE__ */ new Map());
     /**
      * Dispatches an action/event to the Bloc.
      * If a handler is registered for this specific event type (via 'on'), it will be invoked.
      * Asynchronous handlers are awaited.
      * @param action The action/event instance to be processed.
      */
-    s(this, "add", async (t) => {
-      const n = t.constructor, i = this.eventHandlers.get(n);
+    n(this, "add", async (t) => {
+      const s = t.constructor, i = this.eventHandlers.get(s);
       if (i) {
-        const a = (r) => {
-          const l = this.state;
-          this._pushState(r, l, t);
+        const a = (o) => {
+          const c = this.state;
+          this._pushState(o, c, t);
         };
         try {
           await i(t, a);
-        } catch (r) {
-          c.error(
-            `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${n.name}':`,
-            r,
+        } catch (o) {
+          h.error(
+            `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${s.name}':`,
+            o,
             "Action:",
             t
           );
         }
       } else {
         const a = t.constructor.name || "UnnamedConstructor";
-        c.warn(
+        h.warn(
           `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${a}'. Action was:`,
           t
         );
@@ -507,16 +679,16 @@ class b extends g {
    * @param handler A function that processes the event and can emit new states.
    *                The 'event' parameter in the handler will be typed to the specific eventConstructor.
    */
-  on(t, n) {
-    this.eventHandlers.has(t) && c.warn(
+  on(t, s) {
+    this.eventHandlers.has(t) && h.warn(
       `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
       t,
-      n
+      s
     );
   }
 }
-class m extends g {
+class M extends g {
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),
@@ -526,8 +698,8 @@ class m extends g {
   emit(e) {
     if (Object.is(e, this.state))
       return;
-    const t = this.state, n = e;
-    this._pushState(n, t);
+    const t = this.state, s = e;
+    this._pushState(s, t);
   }
   /**
    * Partially updates the current state by merging it with the provided state patch.
@@ -539,34 +711,35 @@ class m extends g {
    */
   patch(e, t = !1) {
     if (typeof this.state != "object" || this.state === null) {
-      c.warn(
+      h.warn(
         "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
       );
       return;
     }
-    let n = !1;
+    let s = !1;
     if (t)
-      n = !0;
+      s = !0;
     else
       for (const i in e)
         if (Object.prototype.hasOwnProperty.call(e, i)) {
-          const r = this.state[i];
-          if (!Object.is(e[i], r)) {
-            n = !0;
+          const o = this.state[i];
+          if (!Object.is(e[i], o)) {
+            s = !0;
             break;
           }
         }
-    n && this.emit({
+    s && this.emit({
       ...this.state,
       ...e
     });
   }
 }
 export {
-  c as Blac,
-  _ as BlacObservable,
-  b as Bloc,
+  h as Blac,
+  m as BlacObservable,
+  A as Bloc,
   g as BlocBase,
-  m as Cubit
+  M as Cubit,
+  b as setBlacInstanceManager
 };
 //# sourceMappingURL=index.es.js.map