@blac/core 2.0.0-rc-2 → 2.0.0-rc-4

package/dist/index.es.js

@@ -1,44 +1,67 @@
-var B = Object.defineProperty;
-var m = (c, t, e) => t in c ? B(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e;
-var n = (c, t, e) => m(c, typeof t != "symbol" ? t + "" : t, e);
-var _ = /* @__PURE__ */ ((c) => (c.BLOC_DISPOSED = "BLOC_DISPOSED", c.BLOC_CREATED = "BLOC_CREATED", c.LISTENER_REMOVED = "LISTENER_REMOVED", c.LISTENER_ADDED = "LISTENER_ADDED", c.STATE_CHANGED = "STATE_CHANGED", c.BLOC_CONSUMER_REMOVED = "BLOC_CONSUMER_REMOVED", c.BLOC_CONSUMER_ADDED = "BLOC_CONSUMER_ADDED", c))(_ || {});
+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;
+    d._instance = new h({ __unsafe_ignore_singleton: !0 });
+    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(t = {}) {
+  constructor(e = {}) {
     /** Timestamp when the instance was created */
     n(this, "createdAt", Date.now());
     /** Map storing all registered bloc instances by their class name and ID */
     n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
     /** Map storing isolated bloc instances grouped by their constructor */
     n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
-    n(this, "pluginList", []);
+    /** 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 */
     n(this, "postChangesToDocument", !1);
     /**
      * Logs messages to console when logging is enabled
      * @param args - Arguments to log
      */
-    n(this, "log", (...t) => {
-      r.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...t);
+    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
      */
-    n(this, "warn", (t, ...e) => {
-      r.enableLog && console.warn(`🚨 [Blac ${String(r.instance.createdAt)}]`, t, ...e);
+    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
      */
-    n(this, "error", (t, ...e) => {
-      r.enableLog && console.error(`🚨 [Blac ${String(r.instance.createdAt)}]`, t, ...e);
+    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
@@ -46,66 +69,26 @@ const r = class r {
      */
     n(this, "resetInstance", () => {
       this.log("Reset Blac instance");
-      const t = new Map(this.blocInstanceMap), e = new Map(this.isolatedBlocMap);
-      t.forEach((s) => {
-        s._dispose();
-      }), e.forEach((s) => {
+      const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
+      e.forEach((s) => {
+        s._keepAlive || s._dispose();
+      }), t.forEach((s) => {
         s.forEach((i) => {
-          i._dispose();
+          i._keepAlive || i._dispose();
         });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), r.instance = new r({
-        __unsafe_ignore_singleton: !0
-      });
-    });
-    /**
-     * Adds a plugin to the Blac instance
-     * @param plugin - The plugin to add
-     */
-    n(this, "addPlugin", (t) => {
-      this.pluginList.findIndex((s) => s.name === t.name) === -1 && (this.log("Add plugin", t.name), this.pluginList.push(t));
-    });
-    /**
-     * Dispatches a lifecycle event to all registered plugins
-     * @param event - The lifecycle event to dispatch
-     * @param bloc - The bloc instance involved in the event
-     * @param params - Additional parameters for the event
-     */
-    n(this, "dispatchEventToPlugins", (t, e, s) => {
-      this.pluginList.forEach((i) => {
-        i.onEvent(t, e, s);
-      });
-    });
-    /**
-     * Dispatches a lifecycle event and handles related cleanup actions.
-     * This method is responsible for:
-     * - Logging the event
-     * - Handling bloc disposal when needed
-     * - Managing bloc consumer cleanup
-     * - Forwarding the event to plugins
-     * 
-     * @param event - The lifecycle event to dispatch
-     * @param bloc - The bloc instance involved in the event
-     * @param params - Additional parameters for the event
-     */
-    n(this, "dispatchEvent", (t, e, s) => {
-      switch (this.log(t, e, s), t) {
-        case "BLOC_DISPOSED":
-          this.disposeBloc(e);
-          break;
-        case "BLOC_CONSUMER_REMOVED":
-        case "LISTENER_REMOVED":
-          this.log(`[${e._name}:${String(e._id)}] Listener/Consumer removed. Listeners: ${String(e._observer.size)}, Consumers: ${String(e._consumers.size)}, KeepAlive: ${String(e._keepAlive)}`), e._observer.size === 0 && e._consumers.size === 0 && !e._keepAlive && (this.log(`[${e._name}:${String(e._id)}] No listeners or consumers left and not keepAlive. Disposing.`), e._dispose());
-          break;
-      }
-      this.dispatchEventToPlugins(t, e, s);
+      }), 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
      */
-    n(this, "disposeBloc", (t) => {
-      const e = t.constructor, s = this.createBlocInstanceMapKey(t._name, t._id);
-      this.log(`[${t._name}:${String(t._id)}] disposeBloc called. Isolated: ${String(e.isolated)}`), e.isolated ? (this.unregisterIsolatedBlocInstance(t), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(t), this.dispatchEventToPlugins("BLOC_DISPOSED", t);
+    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);
+    });
+    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));
     });
     /**
      * Gets or creates a bloc instance based on the provided class and options.
@@ -118,23 +101,27 @@ const r = class r {
      *   - instanceRef: Optional reference string for the instance
      * @returns The bloc instance
      */
-    n(this, "getBloc", (t, e = {}) => {
-      const { id: s } = e, i = t, a = s ?? t.name;
-      if (this.log(`[${t.name}:${String(a)}] getBloc called. Options:`, e), i.isolated) {
-        const o = this.findIsolatedBlocInstance(t, a);
-        if (o)
-          return this.log(`[${t.name}:${String(a)}] Found existing isolated instance.`), o;
-      }
-      if (!i.isolated) {
-        const o = this.findRegisteredBlocInstance(t, a);
-        if (o)
-          return this.log(`[${t.name}:${String(a)}] Found existing registered instance.`), o;
+    n(this, "getBloc", (e, t = {}) => {
+      const { id: s } = t, i = e, a = s ?? e.name;
+      if (i.isolated) {
+        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 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`);
       }
-      return this.log(`[${t.name}:${String(a)}] No existing instance found. Creating new one.`), this.createNewBlocInstance(
-        t,
+      const o = this.createNewBlocInstance(
+        e,
         a,
-        e
+        t
       );
+      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
@@ -144,11 +131,11 @@ const r = class r {
      *   - props: Properties to pass to the bloc constructor
      *   - instanceRef: Optional reference string for the instance
      */
-    n(this, "getBlocOrThrow", (t, e = {}) => {
-      const s = t.isolated, i = e.id || t.name, a = s ? this.findIsolatedBlocInstance(t, i) : this.findRegisteredBlocInstance(t, 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 ${t.name} not found`);
+      throw new Error(`Bloc ${e.name} not found`);
     });
     /**
      * Gets all instances of a specific bloc class
@@ -157,27 +144,85 @@ const r = class r {
      *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
      * @returns Array of matching bloc instances
      */
-    n(this, "getAllBlocs", (t, e = {}) => {
+    n(this, "getAllBlocs", (e, t = {}) => {
       const s = [];
       if (this.blocInstanceMap.forEach((i) => {
-        i.constructor === t && s.push(i);
-      }), e.searchIsolated !== !1) {
-        const i = this.isolatedBlocMap.get(t);
+        i.constructor === e && s.push(i);
+      }), t.searchIsolated !== !1) {
+        const i = this.isolatedBlocMap.get(e);
         i && s.push(...i.map((a) => a));
       }
       return s;
     });
-    const { __unsafe_ignore_singleton: e = !1 } = t;
-    if (!e)
+    /**
+     * 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 r.instance;
-    r.instance = this;
+    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 r.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
@@ -185,24 +230,24 @@ const r = class r {
    * @param id - The instance ID
    * @returns A unique key string in the format "className:id"
    */
-  createBlocInstanceMapKey(t, e) {
-    return `${t}:${String(e)}`;
+  createBlocInstanceMapKey(e, t) {
+    return `${e}:${String(t)}`;
   }
   /**
    * Unregister a bloc instance from the main registry
    * @param bloc - The bloc instance to unregister
    */
-  unregisterBlocInstance(t) {
-    const e = this.createBlocInstanceMapKey(t._name, t._id);
-    this.blocInstanceMap.delete(e);
+  unregisterBlocInstance(e) {
+    const t = this.createBlocInstanceMapKey(e._name, e._id);
+    this.blocInstanceMap.delete(t), this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e);
   }
   /**
    * Registers a bloc instance in the main registry
    * @param bloc - The bloc instance to register
    */
-  registerBlocInstance(t) {
-    const e = this.createBlocInstanceMapKey(t._name, t._id);
-    this.blocInstanceMap.set(e, t);
+  registerBlocInstance(e) {
+    const t = this.createBlocInstanceMapKey(e._name, e._id);
+    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
@@ -210,39 +255,44 @@ const r = class r {
    * @param id - The instance ID
    * @returns The found bloc instance or undefined if not found
    */
-  findRegisteredBlocInstance(t, e) {
-    if (t.isolated) return;
-    const i = this.createBlocInstanceMapKey(t.name, e), a = this.blocInstanceMap.get(i);
-    return a && this.log(`[${t.name}:${String(e)}] Found registered instance. Returning.`), a;
+  findRegisteredBlocInstance(e, t) {
+    if (e.isolated) return;
+    const i = this.createBlocInstanceMapKey(e.name, t);
+    return this.blocInstanceMap.get(i);
   }
   /**
    * Registers an isolated bloc instance in the isolated registry
    * @param bloc - The isolated bloc instance to register
    */
-  registerIsolatedBlocInstance(t) {
-    const e = t.constructor, s = this.isolatedBlocMap.get(e);
-    s ? s.push(t) : this.isolatedBlocMap.set(e, [t]);
+  registerIsolatedBlocInstance(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(t) {
-    const e = t.constructor, s = this.isolatedBlocMap.get(e);
+  unregisterIsolatedBlocInstance(e) {
+    const t = e.constructor, s = this.isolatedBlocMap.get(t);
     if (s) {
-      const i = s.findIndex((a) => a._id === t._id);
-      i !== -1 && s.splice(i, 1), s.length === 0 && this.isolatedBlocMap.delete(e);
+      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(t, e) {
-    if (!t.isolated) return;
-    const i = this.isolatedBlocMap.get(t);
-    if (!i) return;
-    const a = i.find((o) => o._id === e);
-    return a && this.log(`[${t.name}:${String(e)}] Found isolated instance. Returning.`), a;
+  findIsolatedBlocInstance(e, t) {
+    if (!e.isolated) return;
+    const i = this.isolatedBlocMap.get(e);
+    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
@@ -252,25 +302,47 @@ const r = class r {
    * @param instanceRef - Optional reference string for the instance
    * @returns The newly created bloc instance
    */
-  createNewBlocInstance(t, e, s = {}) {
-    const { props: i, instanceRef: a } = s, o = new t(i);
-    return o._instanceRef = a, o.props = i || null, o._updateId(e), o.isIsolated ? (this.registerIsolatedBlocInstance(o), o) : (this.registerBlocInstance(o), o);
+  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 */
-n(r, "instance", new r()), n(r, "getAllBlocs", r.instance.getAllBlocs), n(r, "addPlugin", r.instance.addPlugin), /** Flag to enable/disable logging */
-n(r, "enableLog", !1), n(r, "log", r.instance.log), n(r, "warn", r.instance.warn), n(r, "error", r.instance.error), n(r, "resetInstance", r.instance.resetInstance), n(r, "getBloc", r.instance.getBloc), n(r, "getBlocOrThrow", r.instance.getBlocOrThrow);
+/** Flag to enable/disable logging */
+n(r, "enableLog", !1), n(r, "resetInstance", () => {
+  u.resetInstance();
+});
 let h = r;
-class D {
+class m {
   /**
    * Creates a new BlacObservable instance
    * @param bloc - The Bloc instance to observe
    */
-  constructor(t) {
+  constructor(e) {
     /** The Bloc instance this observable is associated with */
     n(this, "bloc");
     n(this, "_observers", /* @__PURE__ */ new Set());
-    this.bloc = t;
+    this.bloc = e;
   }
   /**
    * Gets the number of active observers
@@ -291,18 +363,17 @@ class D {
    * @param observer - The observer to subscribe
    * @returns A function that can be called to unsubscribe the observer
    */
-  subscribe(t) {
-    return this._observers.add(t), h.instance.dispatchEvent(_.LISTENER_ADDED, this.bloc, { listenerId: t.id }), t.lastState || (t.lastState = t.dependencyArray ? t.dependencyArray(this.bloc.state) : []), () => {
-      this.unsubscribe(t);
+  subscribe(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);
     };
   }
   /**
    * Unsubscribes an observer from state changes
    * @param observer - The observer to unsubscribe
    */
-  unsubscribe(t) {
-    var e;
-    (e = t.dispose) == null || e.call(t), this._observers.delete(t), h.instance.dispatchEvent(_.LISTENER_REMOVED, this.bloc, { listenerId: t.id });
+  unsubscribe(e) {
+    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
@@ -310,52 +381,48 @@ class D {
    * @param oldState - The previous state value
    * @param action - Optional action that triggered the state change
    */
-  notify(t, e, s) {
+  notify(e, t, s) {
     this._observers.forEach((i) => {
       let a = !1;
       if (i.dependencyArray) {
-        const o = i.lastState || [], g = i.dependencyArray(t);
-        for (let p = 0; p < g.length; p++) {
-          const S = g[p], l = o[p] || [];
-          for (let d = 0; d < S.length; d++)
-            if (!Object.is(S[d], l[d])) {
+        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 = g;
+        i.lastState = c;
       } else
         a = !0;
-      a && i.fn(t, e, s);
+      a && i.fn(e, t, s);
     });
   }
   /**
-   * Disposes of all observers and clears the observer set
+   * Clears the observer set
    */
-  dispose() {
-    this._observers.forEach((t) => {
-      this.unsubscribe(t);
+  clear() {
+    this._observers.forEach((e) => {
+      this.unsubscribe(e);
     }), this._observers.clear();
   }
 }
-class E {
+class g {
   /**
    * Creates a new BlocBase instance with the given initial state.
    * Sets up the observer, registers with the Blac manager, and initializes addons.
    * 
    * @param initialState The initial state value for this Bloc
    */
-  constructor(t) {
+  constructor(e) {
+    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.
      */
     n(this, "defaultDependencySelector");
-    /**
-     * @internal
-     * Optional array of addons to extend the functionality of this Bloc.
-     */
-    n(this, "_addons");
     /**
      * @internal
      * Indicates if this specific Bloc instance is isolated from others of the same type.
@@ -366,11 +433,6 @@ class E {
      * Observable responsible for managing state listeners and notifying consumers.
      */
     n(this, "_observer");
-    /**
-     * @internal
-     * Reference to the global Blac manager instance.
-     */
-    n(this, "_blac", h.getInstance());
     /**
      * The unique identifier for this Bloc instance.
      * Defaults to the class name, but can be customized.
@@ -413,9 +475,9 @@ class E {
      * 
      * @param id The new ID to assign to this Bloc instance
      */
-    n(this, "_updateId", (t) => {
-      const e = this._id;
-      !t || t === e || (this._id = t);
+    n(this, "_updateId", (e) => {
+      const t = this._id;
+      !e || e === t || (this._id = e);
     });
     /**
      * @internal
@@ -427,15 +489,21 @@ class E {
      * Set of consumer IDs currently listening to this Bloc's state changes.
      */
     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
      */
-    n(this, "_addConsumer", (t) => {
-      this._consumers.add(t), this._blac.dispatchEvent(_.BLOC_CONSUMER_ADDED, this, { consumerId: t });
+    n(this, "_addConsumer", (e, t) => {
+      this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.add(t));
     });
     /**
      * @internal
@@ -444,22 +512,25 @@ class E {
      * 
      * @param consumerId The unique ID of the consumer being removed
      */
-    n(this, "_removeConsumer", (t) => {
-      this._blac.log(`[${this._name}:${String(this._id ?? "default_id")}] Removing consumer: ${t}`), this._consumers.delete(t), this._blac.dispatchEvent(_.BLOC_CONSUMER_REMOVED, this, { consumerId: t });
+    n(this, "_removeConsumer", (e) => {
+      this._consumers.has(e) && (this._consumers.delete(e), this._consumers.size === 0 && !this._keepAlive && this._scheduleDisposal());
     });
     /**
      * @internal
-     * Initializes all registered addons for this Bloc instance.
-     * Calls the onInit lifecycle method on each addon if defined.
-     */
-    n(this, "_connectAddons", () => {
-      const { _addons: t } = this;
-      t && t.forEach((e) => {
-        var s;
-        (s = e.onInit) == null || s.call(e, this);
-      });
-    });
+     * 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.
@@ -468,12 +539,42 @@ class E {
      * @param oldState The previous state for comparison
      * @param action Optional metadata about what caused the state change
      */
-    n(this, "_pushState", (t, e, s) => {
-      this._state = t, this._observer.notify(t, e, s), 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 = t, this._observer = new D(this), this._blac.dispatchEvent(_.BLOC_CREATED, this), this._id = this.constructor.name;
-    const e = this.constructor;
-    this._keepAlive = e.keepAlive, this._isolated = e.isolated, this._addons = e.addons, this._connectAddons();
+    this._state = e, this._observer = new m(this), this._id = this.constructor.name;
+    const t = this.constructor;
+    this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1;
   }
   get isIsolated() {
     return this._isolated;
@@ -501,8 +602,24 @@ class E {
    * Notifies the Blac manager and clears all observers.
    */
   _dispose() {
-    var t;
-    this._observer.dispose(), this._blac.dispatchEvent(_.BLOC_DISPOSED, this), (t = this.onDispose) == null || t.call(this);
+    var e;
+    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);
   }
 }
 /**
@@ -510,59 +627,13 @@ class E {
  * Use this when state should not be shared between components.
  * @default false
  */
-n(E, "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
  */
-n(E, "keepAlive", !1);
-class M extends E {
-  /**
-   * Updates the current state and notifies all observers of the change.
-   * If the new state is identical to the current state (using Object.is),
-   * no update will occur.
-   * @param state - The new state to set
-   */
-  emit(t) {
-    if (Object.is(t, this.state))
-      return;
-    const e = this.state, s = t;
-    this._pushState(s, e);
-  }
-  /**
-   * Partially updates the current state by merging it with the provided state patch.
-   * This method is only applicable when the state is an object type.
-   * 
-   * @param statePatch - A partial state object containing only the properties to update
-   * @param ignoreChangeCheck - If true, skips checking if the state has actually changed
-   * @throws {TypeError} If the state is not an object type
-   */
-  patch(t, e = !1) {
-    if (typeof this.state != "object" || this.state === null) {
-      h.warn(
-        "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
-      );
-      return;
-    }
-    let s = !1;
-    if (e)
-      s = !0;
-    else
-      for (const i in t)
-        if (Object.prototype.hasOwnProperty.call(t, i)) {
-          const o = this.state[i];
-          if (!Object.is(t[i], o)) {
-            s = !0;
-            break;
-          }
-        }
-    s && this.emit({
-      ...this.state,
-      ...t
-    });
-  }
-}
-class w extends E {
+n(g, "keepAlive", !1);
+class A extends g {
   constructor() {
     super(...arguments);
     // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
@@ -575,28 +646,28 @@ class w extends E {
      * Asynchronous handlers are awaited.
      * @param action The action/event instance to be processed.
      */
-    n(this, "add", async (e) => {
-      const s = e.constructor, i = this.eventHandlers.get(s);
+    n(this, "add", async (t) => {
+      const s = t.constructor, i = this.eventHandlers.get(s);
       if (i) {
         const a = (o) => {
-          const g = this.state;
-          this._pushState(o, g, e);
+          const c = this.state;
+          this._pushState(o, c, t);
         };
         try {
-          await i(e, a);
+          await i(t, a);
         } catch (o) {
           h.error(
             `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${s.name}':`,
             o,
             "Action:",
-            e
+            t
           );
         }
       } else {
-        const a = e.constructor.name || "UnnamedConstructor";
+        const a = t.constructor.name || "UnnamedConstructor";
         h.warn(
           `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${a}'. Action was:`,
-          e
+          t
         );
       }
     });
@@ -608,63 +679,67 @@ class w extends E {
    * @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(e, s) {
-    this.eventHandlers.has(e) && h.warn(
-      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${e.name}' already registered. It will be overwritten.`
+  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(
-      e,
+      t,
       s
     );
   }
 }
-function I(c) {
-  switch (c) {
-    case "localStorage":
-      return localStorage;
-    case "sessionStorage":
-      return sessionStorage;
-    default:
-      return localStorage;
+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),
+   * no update will occur.
+   * @param state - The new state to set
+   */
+  emit(e) {
+    if (Object.is(e, this.state))
+      return;
+    const t = this.state, s = e;
+    this._pushState(s, t);
   }
-}
-function $(c = {}) {
-  const {
-    keyPrefix: t = "blac",
-    keyName: e,
-    defaultValue: s,
-    storageType: i = "localStorage"
-  } = c, a = (l) => `${t}:${String(l)}`, o = (l) => {
-    var d;
-    try {
-      const u = I(i).getItem(a(l));
-      if (typeof u != "string")
-        return s;
-      const f = JSON.parse(u);
-      return typeof f.v < "u" ? f.v : s;
-    } catch (u) {
-      return (d = c.onError) == null || d.call(c, u), s;
-    }
-  }, g = (l) => {
-    const d = e ?? l._id, u = o(d);
-    l._pushState(u, null);
-  };
-  let p = "";
-  return {
-    name: "Persist",
-    onInit: g,
-    onEmit: ({ newState: l, cubit: d }) => {
-      const u = e ?? d._id, f = JSON.stringify({ v: l });
-      f !== p && (I(i).setItem(a(u), f), p = f);
+  /**
+   * Partially updates the current state by merging it with the provided state patch.
+   * This method is only applicable when the state is an object type.
+   * 
+   * @param statePatch - A partial state object containing only the properties to update
+   * @param ignoreChangeCheck - If true, skips checking if the state has actually changed
+   * @throws {TypeError} If the state is not an object type
+   */
+  patch(e, t = !1) {
+    if (typeof this.state != "object" || this.state === null) {
+      h.warn(
+        "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
+      );
+      return;
     }
-  };
+    let s = !1;
+    if (t)
+      s = !0;
+    else
+      for (const i in e)
+        if (Object.prototype.hasOwnProperty.call(e, i)) {
+          const o = this.state[i];
+          if (!Object.is(e[i], o)) {
+            s = !0;
+            break;
+          }
+        }
+    s && this.emit({
+      ...this.state,
+      ...e
+    });
+  }
 }
 export {
   h as Blac,
-  _ as BlacLifecycleEvent,
-  D as BlacObservable,
-  w as Bloc,
-  E as BlocBase,
+  m as BlacObservable,
+  A as Bloc,
+  g as BlocBase,
   M as Cubit,
-  $ as Persist
+  b as setBlacInstanceManager
 };
 //# sourceMappingURL=index.es.js.map