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

package/dist/index.es.js

@@ -1,111 +1,71 @@
 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))(_ || {});
-const r = class r {
+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 {
   /**
    * 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());
+    s(this, "createdAt", Date.now());
     /** Map storing all registered bloc instances by their class name and ID */
-    n(this, "blocInstanceMap", /* @__PURE__ */ new Map());
+    s(this, "blocInstanceMap", /* @__PURE__ */ new Map());
     /** Map storing isolated bloc instances grouped by their constructor */
-    n(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
-    n(this, "pluginList", []);
+    s(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
     /** Flag to control whether changes should be posted to document */
-    n(this, "postChangesToDocument", !1);
+    s(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);
+    s(this, "log", (...e) => {
+      o.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);
+    s(this, "warn", (e, ...t) => {
+      o.enableLog && console.warn(`🚨 [Blac ${String(o.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);
+    s(this, "error", (e, ...t) => {
+      o.enableLog && console.error(`🚨 [Blac ${String(o.instance.createdAt)}]`, e, ...t);
     });
     /**
      * Resets the Blac instance to a new one, disposing non-keepAlive blocs
      * from the old instance.
      */
-    n(this, "resetInstance", () => {
+    s(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) => {
-        s.forEach((i) => {
+      const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
+      e.forEach((n) => {
+        n._dispose();
+      }), t.forEach((n) => {
+        n.forEach((i) => {
           i._dispose();
         });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), r.instance = new r({
+      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), o.instance = new o({
         __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);
-    });
     /**
      * 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);
+    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);
+    });
+    s(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 +78,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;
+    s(this, "getBloc", (e, t = {}) => {
+      const { id: n } = t, i = e, a = n ?? 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;
+        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;
+        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 r = this.createNewBlocInstance(
+        e,
         a,
-        e
+        t
       );
+      return this.log(`[${e.name}:${String(a)}] (getBloc) No existing instance found. Creating new one.`, t, r), r;
     });
     /**
      * Gets a bloc instance or throws an error if it doesn't exist
@@ -144,11 +108,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);
+    s(this, "getBlocOrThrow", (e, t = {}) => {
+      const n = e.isolated, i = t.id || e.name, a = n ? 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 +121,27 @@ 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 = {}) => {
-      const s = [];
+    s(this, "getAllBlocs", (e, t = {}) => {
+      const n = [];
       if (this.blocInstanceMap.forEach((i) => {
-        i.constructor === t && s.push(i);
-      }), e.searchIsolated !== !1) {
-        const i = this.isolatedBlocMap.get(t);
-        i && s.push(...i.map((a) => a));
+        i.constructor === e && n.push(i);
+      }), t.searchIsolated !== !1) {
+        const i = this.isolatedBlocMap.get(e);
+        i && n.push(...i.map((a) => a));
       }
-      return s;
+      return n;
     });
-    const { __unsafe_ignore_singleton: e = !1 } = t;
-    if (!e)
-      return r.instance;
-    r.instance = this;
+    const { __unsafe_ignore_singleton: t = !1 } = e;
+    if (!t)
+      return o.instance;
+    o.instance = this;
   }
   /**
    * Gets the singleton instance of Blac
    * @returns The Blac instance
    */
   static getInstance() {
-    return r.instance;
+    return o.instance;
   }
   /**
    * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
@@ -185,24 +149,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);
   }
   /**
    * 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);
   }
   /**
    * Finds a registered bloc instance by its class and ID
@@ -210,39 +174,37 @@ 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, n = this.isolatedBlocMap.get(t);
+    n ? n.push(e) : this.isolatedBlocMap.set(t, [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);
-    if (s) {
-      const i = s.findIndex((a) => a._id === t._id);
-      i !== -1 && s.splice(i, 1), s.length === 0 && this.isolatedBlocMap.delete(e);
+  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);
     }
   }
   /**
    * Finds an isolated bloc instance by its class and ID
    */
-  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((r) => r._id === t) : void 0;
   }
   /**
    * Creates a new bloc instance and registers it in the appropriate registry
@@ -252,33 +214,32 @@ 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, 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);
   }
 };
 /** 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);
-let h = r;
-class D {
+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 _ {
   /**
    * 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");
-    // private _observers = new Set<BlacObserver<S>>();
-    n(this, "_observers", []);
-    this.bloc = t;
+    s(this, "bloc");
+    s(this, "_observers", /* @__PURE__ */ new Set());
+    this.bloc = e;
   }
   /**
    * Gets the number of active observers
    * @returns The number of observers currently subscribed
    */
   get size() {
-    return this._observers.length;
+    return this._observers.size;
   }
   /**
    * Gets the set of all observers
@@ -292,17 +253,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.push(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 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);
     };
   }
   /**
    * Unsubscribes an observer from state changes
    * @param observer - The observer to unsubscribe
    */
-  unsubscribe(t) {
-    this._observers = this._observers.filter((e) => e.id !== t.id), h.instance.dispatchEvent(_.LISTENER_REMOVED, this.bloc, { listenerId: t.id });
+  unsubscribe(e) {
+    this._observers.delete(e), this.size === 0 && (c.log("BlacObservable.unsubscribe: No observers left. Disposing bloc.", this.bloc), this.bloc._dispose());
   }
   /**
    * Notifies all observers of a state change
@@ -310,103 +271,98 @@ class D {
    * @param oldState - The previous state value
    * @param action - Optional action that triggered the state change
    */
-  notify(t, e, s) {
+  notify(e, t, n) {
     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], d = o[p] || [];
-          for (let l = 0; l < S.length; l++)
-            if (!Object.is(S[l], d[l])) {
+        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])) {
               a = !0;
               break;
             }
         }
-        i.lastState = g;
+        i.lastState = l;
       } else
         a = !0;
-      a && i.fn(t, e, s);
+      a && i.fn(e, t, n);
     });
   }
   /**
-   * Disposes of all observers and clears the observer set
+   * Clears the observer set
    */
-  dispose() {
-    this._observers.forEach((t) => {
-      var e;
-      this.unsubscribe(t), (e = t.dispose) == null || e.call(t);
-    }), this._observers = [];
+  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) {
+    s(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");
+    s(this, "defaultDependencySelector");
     /**
      * @internal
      * Indicates if this specific Bloc instance is isolated from others of the same type.
      */
-    n(this, "_isolated", !1);
+    s(this, "_isolated", !1);
     /**
      * @internal
      * Observable responsible for managing state listeners and notifying consumers.
      */
-    n(this, "_observer");
+    s(this, "_observer");
     /**
      * @internal
      * Reference to the global Blac manager instance.
      */
-    n(this, "_blac", h.getInstance());
+    s(this, "_blac", c.getInstance());
     /**
      * The unique identifier for this Bloc instance.
      * Defaults to the class name, but can be customized.
      */
-    n(this, "_id");
+    s(this, "_id");
     /**
      * @internal
      * Reference string used internally for tracking and debugging.
      */
-    n(this, "_instanceRef");
+    s(this, "_instanceRef");
     /**
      * @internal
      * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
      */
-    n(this, "_keepAlive", !1);
+    s(this, "_keepAlive", !1);
     /**
      * @readonly
      * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
      */
-    n(this, "_createdAt", Date.now());
+    s(this, "_createdAt", Date.now());
     /**
      * @internal
      * The current state of the Bloc.
      */
-    n(this, "_state");
+    s(this, "_state");
     /**
      * @internal
      * The previous state of the Bloc, maintained for comparison and history.
      */
-    n(this, "_oldState");
+    s(this, "_oldState");
     /**
      * Props passed during Bloc instance creation.
      * Can be used to configure or parameterize the Bloc's behavior.
      */
-    n(this, "props", null);
+    s(this, "props", null);
     /**
      * @internal
      * Updates the Bloc instance's ID to a new value.
@@ -414,20 +370,20 @@ 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);
+    s(this, "_updateId", (e) => {
+      const t = this._id;
+      !e || e === t || (this._id = e);
     });
     /**
      * @internal
      * Optional function to be called when the Bloc is disposed.
      */
-    n(this, "onDispose");
+    s(this, "onDispose");
     /**
      * @internal
      * Set of consumer IDs currently listening to this Bloc's state changes.
      */
-    n(this, "_consumers", /* @__PURE__ */ new Set());
+    s(this, "_consumers", /* @__PURE__ */ new Set());
     /**
      * @internal
      * Registers a new consumer to this Bloc instance.
@@ -435,8 +391,8 @@ class E {
      * 
      * @param consumerId The unique ID of the consumer being added
      */
-    n(this, "_addConsumer", (t) => {
-      this._consumers.add(t), this._blac.dispatchEvent(_.BLOC_CONSUMER_ADDED, this, { consumerId: t });
+    s(this, "_addConsumer", (e) => {
+      this._consumers.has(e) || (this._consumers.add(e), c.log("BlocBase._addConsumer", this, e));
     });
     /**
      * @internal
@@ -445,22 +401,10 @@ 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 });
-    });
-    /**
-     * @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);
-      });
+    s(this, "_removeConsumer", (e) => {
+      this._consumers.has(e) && (this._consumers.delete(e), c.log("BlocBase._removeConsumer", this, e));
     });
-    n(this, "lastUpdate", Date.now());
+    s(this, "lastUpdate", Date.now());
     /**
      * @internal
      * Updates the state and notifies all observers of the change.
@@ -469,12 +413,12 @@ 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();
+    s(this, "_pushState", (e, t, n) => {
+      this._state = e, this._observer.notify(e, t, n), this.lastUpdate = Date.now();
     });
-    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 _(this), c.log("Bloc Created", this), this._id = this.constructor.name;
+    const t = this.constructor;
+    this._keepAlive = t.keepAlive, this._isolated = t.isolated;
   }
   get isIsolated() {
     return this._isolated;
@@ -502,8 +446,8 @@ 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._observer.clear(), (e = this.onDispose) == null || e.call(this), c.log("BlocBase._dispose", this), c.instance.disposeBloc(this);
   }
 }
 /**
@@ -511,93 +455,47 @@ class E {
  * Use this when state should not be shared between components.
  * @default false
  */
-n(E, "isolated", !1), /**
+s(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 {
+s(g, "keepAlive", !1);
+class b 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.
-    n(this, "eventHandlers", /* @__PURE__ */ new Map());
+    s(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.
      */
-    n(this, "add", async (e) => {
-      const s = e.constructor, i = this.eventHandlers.get(s);
+    s(this, "add", async (t) => {
+      const n = t.constructor, i = this.eventHandlers.get(n);
       if (i) {
-        const a = (o) => {
-          const g = this.state;
-          this._pushState(o, g, e);
+        const a = (r) => {
+          const l = this.state;
+          this._pushState(r, l, t);
         };
         try {
-          await i(e, a);
-        } catch (o) {
-          h.error(
-            `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${s.name}':`,
-            o,
+          await i(t, a);
+        } catch (r) {
+          c.error(
+            `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${n.name}':`,
+            r,
             "Action:",
-            e
+            t
           );
         }
       } else {
-        const a = e.constructor.name || "UnnamedConstructor";
-        h.warn(
+        const a = t.constructor.name || "UnnamedConstructor";
+        c.warn(
           `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${a}'. Action was:`,
-          e
+          t
         );
       }
     });
@@ -609,63 +507,66 @@ 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, n) {
+    this.eventHandlers.has(t) && c.warn(
+      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
     ), this.eventHandlers.set(
-      e,
-      s
+      t,
+      n
     );
   }
 }
-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, n = e;
+    this._pushState(n, t);
   }
-}
-function $(c = {}) {
-  const {
-    keyPrefix: t = "blac",
-    keyName: e,
-    defaultValue: s,
-    storageType: i = "localStorage"
-  } = c, a = (d) => `${t}:${String(d)}`, o = (d) => {
-    var l;
-    try {
-      const u = I(i).getItem(a(d));
-      if (typeof u != "string")
-        return s;
-      const f = JSON.parse(u);
-      return typeof f.v < "u" ? f.v : s;
-    } catch (u) {
-      return (l = c.onError) == null || l.call(c, u), s;
-    }
-  }, g = (d) => {
-    const l = e ?? d._id, u = o(l);
-    d._pushState(u, null);
-  };
-  let p = "";
-  return {
-    name: "Persist",
-    onInit: g,
-    onEmit: ({ newState: d, cubit: l }) => {
-      const u = e ?? l._id, f = JSON.stringify({ v: d });
-      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) {
+      c.warn(
+        "Cubit.patch: was called on a cubit where the state is not an object. This is a no-op."
+      );
+      return;
     }
-  };
+    let n = !1;
+    if (t)
+      n = !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;
+            break;
+          }
+        }
+    n && this.emit({
+      ...this.state,
+      ...e
+    });
+  }
 }
 export {
-  h as Blac,
-  _ as BlacLifecycleEvent,
-  D as BlacObservable,
-  w as Bloc,
-  E as BlocBase,
-  M as Cubit,
-  $ as Persist
+  c as Blac,
+  _ as BlacObservable,
+  b as Bloc,
+  g as BlocBase,
+  m as Cubit
 };
 //# sourceMappingURL=index.es.js.map