@blac/core 2.0.0-rc-6 → 2.0.0-rc-8

package/dist/index.es.js

@@ -1,26 +1,30 @@
-var m = Object.defineProperty;
-var y = (d, e, t) => e in d ? m(d, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : d[e] = t;
+var I = Object.defineProperty;
+var y = (d, e, t) => e in d ? I(d, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : d[e] = t;
 var i = (d, e, t) => y(d, typeof e != "symbol" ? e + "" : e, t);
 const u = class u {
   getInstance() {
-    return u._instance || (u._instance = new l({ __unsafe_ignore_singleton: !0 })), u._instance;
+    return u._instance || (u._instance = new l({
+      __unsafe_ignore_singleton: !0
+    })), u._instance;
   }
   setInstance(e) {
     u._instance = e;
   }
   resetInstance() {
     const e = u._instance;
-    if (u._instance = new l({ __unsafe_ignore_singleton: !0 }), e)
+    if (u._instance = new l({
+      __unsafe_ignore_singleton: !0
+    }), e)
       for (const t of e.keepAliveBlocs)
         u._instance.keepAliveBlocs.add(t), u._instance.uidRegistry.set(t.uid, t);
   }
 };
 i(u, "_instance");
-let v = u, g = new v();
-function M(d) {
+let B = u, g = new B();
+function A(d) {
   g = d;
 }
-const c = class c {
+const r = class r {
   /**
    * Creates a new Blac instance.
    * @param options - Configuration options including singleton control
@@ -31,6 +35,10 @@ const c = class c {
     /** Map storing all registered bloc instances by their class name and ID */
     i(this, "blocInstanceMap", /* @__PURE__ */ new Map());
     /** Map storing isolated bloc instances grouped by their constructor */
+    // TODO: BlocConstructor<any> is required here for type inference to work correctly.
+    // Using BlocConstructor<BlocBase<unknown>> would break type inference when storing
+    // different bloc types in the same map. The 'any' allows proper polymorphic storage
+    // while maintaining type safety at usage sites through the BlocConstructor constraint.
     i(this, "isolatedBlocMap", /* @__PURE__ */ new Map());
     /** Map for O(1) lookup of isolated blocs by UID */
     i(this, "isolatedBlocIndex", /* @__PURE__ */ new Map());
@@ -45,7 +53,7 @@ const c = class c {
      * @param args - Arguments to log
      */
     i(this, "log", (...e) => {
-      c.enableLog && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...e);
+      r.enableLog && r.logLevel === "warn" && console.warn(`☢️ [Blac ${this.createdAt.toString()}]`, ...e), r.enableLog && r.logLevel === "log" && console.log(`☢️ [Blac ${this.createdAt.toString()}]`, ...e);
     });
     /**
      * Logs a warning message
@@ -53,7 +61,11 @@ const c = class c {
      * @param args - Additional arguments
      */
     i(this, "warn", (e, ...t) => {
-      c.enableLog && console.warn(`🚨 [Blac ${String(c.instance.createdAt)}]`, e, ...t);
+      r.enableLog && console.warn(
+        `🚨 [Blac ${String(r.instance.createdAt)}]`,
+        e,
+        ...t
+      );
     });
     /**
      * Logs an error message
@@ -61,7 +73,11 @@ const c = class c {
      * @param args - Additional arguments
      */
     i(this, "error", (e, ...t) => {
-      c.enableLog && console.error(`🚨 [Blac ${String(c.instance.createdAt)}]`, 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
@@ -84,20 +100,32 @@ const c = class c {
      */
     i(this, "disposeBloc", (e) => {
       if (e._disposalState !== "active") {
-        this.log(`[${e._name}:${String(e._id)}] disposeBloc called on already disposed bloc`);
+        this.log(
+          `[${e._name}:${String(e._id)}] disposeBloc called on already disposed bloc`
+        );
         return;
       }
       const t = e.constructor, s = this.createBlocInstanceMapKey(e._name, e._id);
-      this.log(`[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(t.isolated)}`), e._dispose(), t.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
+      this.log(
+        `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(t.isolated)}`
+      ), e._dispose(), t.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(s)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
     });
     i(this, "activateBloc", (e) => {
+      if (e._disposalState !== "active") {
+        this.log(
+          `[${e._name}:${String(e._id)}] activateBloc called on disposed bloc. Ignoring.`
+        );
+        return;
+      }
       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));
+      (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.
      * If a bloc with the given ID exists, it will be returned. Otherwise, a new instance will be created.
-     * 
+     *
      * @param blocClass - The bloc class to get or create
      * @param options - Options including:
      *   - id: The instance ID (defaults to class name if not provided)
@@ -108,24 +136,28 @@ const c = class c {
     i(this, "getBloc", (e, t = {}) => {
       const { id: s } = t, n = e, o = s ?? e.name;
       if (n.isolated) {
-        const r = this.findIsolatedBlocInstance(e, o);
-        if (r)
-          return this.log(`[${e.name}:${String(o)}] (getBloc) Found existing isolated instance.`, t), r;
+        const c = this.findIsolatedBlocInstance(e, o);
+        if (c)
+          return c;
         if (t.throwIfNotFound)
           throw new Error(`Isolated bloc ${e.name} not found`);
       } else {
-        const r = this.findRegisteredBlocInstance(e, o);
-        if (r)
-          return this.log(`[${e.name}:${String(o)}] (getBloc) Found existing registered instance.`, t), r;
+        const c = this.findRegisteredBlocInstance(e, o);
+        if (c)
+          return c;
         if (t.throwIfNotFound)
           throw new Error(`Registered bloc ${e.name} not found`);
       }
-      const a = this.createNewBlocInstance(
-        e,
-        o,
-        t
-      );
-      return this.log(`[${e.name}:${String(o)}] (getBloc) No existing instance found. Creating new one.`, t, a), a;
+      const a = this.createNewBlocInstance(e, o, t);
+      if (this.log(
+        `[${e.name}:${String(o)}] (getBloc) No existing instance found. Creating new one.`,
+        t,
+        a
+      ), !a)
+        throw new Error(
+          `[getBloc] Failed to create bloc instance for ${e.name}. This should never happen.`
+        );
+      return a;
     });
     /**
      * Gets a bloc instance or throws an error if it doesn't exist
@@ -187,7 +219,10 @@ const c = class c {
     i(this, "getMemoryStats", () => ({
       totalBlocs: this.uidRegistry.size,
       registeredBlocs: this.blocInstanceMap.size,
-      isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce((e, t) => e + t.length, 0),
+      isolatedBlocs: Array.from(this.isolatedBlocMap.values()).reduce(
+        (e, t) => e + t.length,
+        0
+      ),
       keepAliveBlocs: this.keepAliveBlocs.size,
       isolatedBlocTypes: this.isolatedBlocMap.size
     }));
@@ -202,7 +237,7 @@ const c = class c {
     });
     const { __unsafe_ignore_singleton: t = !1 } = e;
     if (!t)
-      return c.instance;
+      return r.instance;
     g.setInstance(this);
   }
   /** @deprecated Use getInstance() instead */
@@ -210,10 +245,10 @@ const c = class c {
     return g.getInstance();
   }
   static get getAllBlocs() {
-    return c.instance.getAllBlocs;
+    return r.instance.getAllBlocs;
   }
   static get log() {
-    return c.instance.log;
+    return r.instance.log;
   }
   /**
    * Gets the current Blac instance
@@ -223,13 +258,13 @@ const c = class c {
     return g.getInstance();
   }
   static get warn() {
-    return c.instance.warn;
+    return r.instance.warn;
   }
   static get error() {
-    return c.instance.error;
+    return r.instance.error;
   }
   static get disposeBloc() {
-    return c.instance.disposeBloc;
+    return r.instance.disposeBloc;
   }
   /**
    * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
@@ -283,7 +318,7 @@ const c = class c {
     const t = e.constructor, s = this.isolatedBlocMap.get(t);
     let n = !1;
     if (s) {
-      const a = s.findIndex((r) => r.uid === e.uid);
+      const a = s.findIndex((c) => c.uid === e.uid);
       a !== -1 && (s.splice(a, 1), n = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
     }
     const o = this.isolatedBlocIndex.delete(e.uid);
@@ -315,35 +350,35 @@ const c = class c {
    */
   createNewBlocInstance(e, t, s = {}) {
     const { props: n, instanceRef: o } = s, a = new e(n);
-    return a._instanceRef = o, a.props = n || null, a._updateId(t), a._setDisposalHandler((r) => this.disposeBloc(r)), a.isIsolated ? (this.registerIsolatedBlocInstance(a), a) : (this.registerBlocInstance(a), a);
+    return a._instanceRef = o, a.props = n || null, a._updateId(t), a._setDisposalHandler((c) => this.disposeBloc(c)), a.isIsolated ? (this.registerIsolatedBlocInstance(a), a) : (this.registerBlocInstance(a), a);
   }
   static get activateBloc() {
-    return c.instance.activateBloc;
+    return r.instance.activateBloc;
   }
   static get getBloc() {
-    return c.instance.getBloc;
+    return r.instance.getBloc;
   }
   static get getBlocOrThrow() {
-    return c.instance.getBlocOrThrow;
+    return r.instance.getBlocOrThrow;
   }
   static get disposeKeepAliveBlocs() {
-    return c.instance.disposeKeepAliveBlocs;
+    return r.instance.disposeKeepAliveBlocs;
   }
   static get disposeBlocs() {
-    return c.instance.disposeBlocs;
+    return r.instance.disposeBlocs;
   }
   static get getMemoryStats() {
-    return c.instance.getMemoryStats;
+    return r.instance.getMemoryStats;
   }
   static get validateConsumers() {
-    return c.instance.validateConsumers;
+    return r.instance.validateConsumers;
   }
 };
 /** Flag to enable/disable logging */
-i(c, "enableLog", !1), i(c, "resetInstance", () => {
+i(r, "enableLog", !1), i(r, "logLevel", "warn"), i(r, "resetInstance", () => {
   g.resetInstance();
 });
-let l = c;
+let l = r;
 class w {
   /**
    * Creates a new BlacObservable instance
@@ -384,7 +419,7 @@ class w {
    * @param observer - The observer to unsubscribe
    */
   unsubscribe(e) {
-    this._observers.delete(e), this.size === 0 && l.log("BlacObservable.unsubscribe: No observers left.", this.bloc);
+    this._observers.delete(e), this.size === 0 && (l.log("BlacObservable.unsubscribe: No observers left.", this.bloc), this.bloc._consumers.size === 0 && !this.bloc._keepAlive && this.bloc._disposalState === "active" && (l.log(`[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`), this.bloc._scheduleDisposal()));
   }
   /**
    * Notifies all observers of a state change
@@ -396,26 +431,26 @@ class w {
     this._observers.forEach((n) => {
       let o = !1;
       if (n.dependencyArray) {
-        const a = n.lastState, r = n.dependencyArray(e);
+        const a = n.lastState, c = n.dependencyArray(e, t);
         if (!a)
           o = !0;
-        else if (a.length !== r.length)
+        else if (a.length !== c.length)
           o = !0;
         else
-          for (let h = 0; h < r.length; h++) {
-            const _ = r[h], p = a[h] || [];
+          for (let h = 0; h < c.length; h++) {
+            const _ = a[h] || [], p = c[h] || [];
             if (_.length !== p.length) {
               o = !0;
               break;
             }
-            for (let f = 0; f < _.length; f++)
+            for (let f = 0; f < p.length; f++)
               if (!Object.is(_[f], p[f])) {
                 o = !0;
                 break;
               }
             if (o) break;
           }
-        n.lastState = r;
+        n.lastState = c;
       } else
         o = !0;
       o && n.fn(e, t, s);
@@ -428,13 +463,13 @@ class w {
     this._observers.clear();
   }
 }
-function S() {
+function b() {
   return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(d) {
     const e = Math.random() * 16 | 0;
     return (d === "x" ? e : e & 3 | 8).toString(16);
   });
 }
-class B {
+class v {
   /**
    * Creates a new BlocBase instance with the given initial state.
    * Sets up the observer, registers with the Blac manager, and initializes addons.
@@ -442,7 +477,7 @@ class B {
    * @param initialState The initial state value for this Bloc
    */
   constructor(e) {
-    i(this, "uid", S());
+    i(this, "uid", b());
     /**
      * Defines how dependencies are selected from the state for efficient updates.
      * When provided, observers will only be notified when selected dependencies change.
@@ -556,7 +591,8 @@ class B {
      * @param consumerRef Optional reference to the consumer object for cleanup validation
      */
     i(this, "_addConsumer", (e, t) => {
-      this._disposalState === "active" && (this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.set(e, new WeakRef(t))));
+      var s;
+      this._disposalState === "active" && (this._consumers.has(e) || (this._consumers.add(e), t && this._consumerRefs.set(e, new WeakRef(t)), (s = globalThis.Blac) == null || s.log(`[${this._name}:${this._id}] Consumer added. Total consumers: ${this._consumers.size}`)));
     });
     /**
      * @internal
@@ -566,7 +602,8 @@ class B {
      * @param consumerId The unique ID of the consumer being removed
      */
     i(this, "_removeConsumer", (e) => {
-      this._consumers.has(e) && (this._consumers.delete(e), this._consumerRefs.delete(e), this._consumers.size === 0 && !this._keepAlive && this._disposalState === "active" && this._scheduleDisposal());
+      var t, s;
+      this._consumers.has(e) && (this._consumers.delete(e), this._consumerRefs.delete(e), (t = globalThis.Blac) == null || t.log(`[${this._name}:${this._id}] Consumer removed. Remaining consumers: ${this._consumers.size}, keepAlive: ${this._keepAlive}`), this._consumers.size === 0 && !this._keepAlive && this._disposalState === "active" && ((s = globalThis.Blac) == null || s.log(`[${this._name}:${this._id}] No consumers left and not keep-alive. Scheduling disposal.`), this._scheduleDisposal()));
     });
     /**
      * @internal
@@ -674,13 +711,13 @@ class B {
  * Use this when state should not be shared between components.
  * @default false
  */
-i(B, "isolated", !1), /**
+i(v, "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
  */
-i(B, "keepAlive", !1);
-class b extends B {
+i(v, "keepAlive", !1);
+class S extends v {
   constructor() {
     super(...arguments);
     // Stores handlers: Map<EventConstructor (subtype of A), HandlerFunction>
@@ -746,22 +783,22 @@ class b extends B {
     const s = t.constructor, n = this.eventHandlers.get(s);
     if (n) {
       const o = (a) => {
-        const r = this.state;
-        this._pushState(a, r, t);
+        const c = this.state;
+        this._pushState(a, c, t);
       };
       try {
         await n(t, o);
       } catch (a) {
-        const r = t.constructor.name || "UnnamedConstructor", h = {
+        const c = t.constructor.name || "UnnamedConstructor", h = {
           blocName: this._name,
           blocId: String(this._id),
-          eventType: r,
+          eventType: c,
           currentState: this.state,
           action: t,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
         if (l.error(
-          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${r}':`,
+          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${c}':`,
           a,
           "Context:",
           h
@@ -780,7 +817,7 @@ class b extends B {
     }
   }
 }
-class k extends B {
+class k extends v {
   /**
    * Updates the current state and notifies all observers of the change.
    * If the new state is identical to the current state (using Object.is),
@@ -826,7 +863,7 @@ class k extends B {
     });
   }
 }
-class x {
+class $ {
   /**
    * Sets up a clean test environment
    */
@@ -853,13 +890,13 @@ class x {
     return new Promise((n, o) => {
       const a = setTimeout(() => {
         o(new Error(`Timeout waiting for state matching predicate after ${s}ms`));
-      }, s), r = e._observer.subscribe({
+      }, s), c = e._observer.subscribe({
         id: `test-waiter-${crypto.randomUUID()}`,
         fn: (h) => {
-          t(h) && (clearTimeout(a), r(), n(h));
+          t(h) && (clearTimeout(a), c(), n(h));
         }
       });
-      t(e.state) && (clearTimeout(a), r(), n(e.state));
+      t(e.state) && (clearTimeout(a), c(), n(e.state));
     });
   }
   /**
@@ -868,7 +905,7 @@ class x {
   static async expectStates(e, t, s = 5e3) {
     const n = [];
     return new Promise((o, a) => {
-      const r = setTimeout(() => {
+      const c = setTimeout(() => {
         a(new Error(
           `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(n)}`
         ));
@@ -876,12 +913,12 @@ class x {
         id: `test-expecter-${crypto.randomUUID()}`,
         fn: (_) => {
           if (n.push(_), n.length === t.length) {
-            clearTimeout(r), h();
+            clearTimeout(c), h();
             for (let p = 0; p < t.length; p++) {
-              const f = t[p], I = n[p];
-              if (JSON.stringify(f) !== JSON.stringify(I)) {
+              const f = t[p], m = n[p];
+              if (JSON.stringify(f) !== JSON.stringify(m)) {
                 a(new Error(
-                  `State mismatch at index ${p}. Expected: ${JSON.stringify(f)}, Received: ${JSON.stringify(I)}`
+                  `State mismatch at index ${p}. Expected: ${JSON.stringify(f)}, Received: ${JSON.stringify(m)}`
                 ));
                 return;
               }
@@ -893,8 +930,8 @@ class x {
     });
   }
 }
-i(x, "originalInstance");
-class A extends b {
+i($, "originalInstance");
+class M extends S {
   constructor(t) {
     super(t);
     i(this, "mockHandlers", /* @__PURE__ */ new Map());
@@ -972,14 +1009,14 @@ Memory Leak Detection Report:
 export {
   l as Blac,
   w as BlacObservable,
-  b as Bloc,
-  B as BlocBase,
-  x as BlocTest,
+  S as Bloc,
+  v as BlocBase,
+  $ as BlocTest,
   k as Cubit,
   R as MemoryLeakDetector,
-  A as MockBloc,
+  M as MockBloc,
   E as MockCubit,
-  S as generateUUID,
-  M as setBlacInstanceManager
+  b as generateUUID,
+  A as setBlacInstanceManager
 };
 //# sourceMappingURL=index.es.js.map