@blac/core 2.0.0-rc-13 → 2.0.0-rc-16

package/dist/index.es.js

@@ -1,1992 +0,0 @@
-var R = Object.defineProperty;
-var O = (c, e, t) => e in c ? R(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
-var i = (c, e, t) => O(c, typeof e != "symbol" ? e + "" : e, t);
-class H {
-  /**
-   * Creates a new BlacObservable instance
-   * @param bloc - The Bloc instance to observe
-   */
-  constructor(e) {
-    /** The Bloc instance this observable is associated with */
-    i(this, "bloc");
-    i(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.size;
-  }
-  /**
-   * Gets the set of all observers
-   * @returns The Set of all BlacObserver instances
-   */
-  get observers() {
-    return this._observers;
-  }
-  /**
-   * Subscribes an observer to state changes
-   * @param observer - The observer to subscribe
-   * @returns A function that can be called to unsubscribe the observer
-   */
-  subscribe(e) {
-    const t = this.bloc._disposalState;
-    return t === y.DISPOSED || t === y.DISPOSING ? (u.log(
-      "BlacObservable.subscribe: Cannot subscribe to disposed/disposing bloc.",
-      this.bloc,
-      e
-    ), () => {
-    }) : (u.log(
-      "BlacObservable.subscribe: Subscribing observer.",
-      this.bloc,
-      e
-    ), this._observers.add(e), t === y.DISPOSAL_REQUESTED && (u.log(
-      "BlacObservable.subscribe: Cancelling disposal due to new subscription.",
-      this.bloc
-    ), this.bloc._atomicStateTransition(
-      y.DISPOSAL_REQUESTED,
-      y.ACTIVE
-    )), () => {
-      u.log(
-        "BlacObservable.subscribe: Unsubscribing observer.",
-        this.bloc,
-        e
-      ), this.unsubscribe(e);
-    });
-  }
-  /**
-   * Unsubscribes an observer from state changes
-   * @param observer - The observer to unsubscribe
-   */
-  unsubscribe(e) {
-    this._observers.delete(e), this.size === 0 && (u.log("BlacObservable.unsubscribe: No observers left.", this.bloc), this.bloc._consumers.size === 0 && !this.bloc._keepAlive && this.bloc._disposalState === y.ACTIVE && (u.log(
-      `[${this.bloc._name}:${this.bloc._id}] No observers or consumers left. Scheduling disposal.`
-    ), this.bloc._scheduleDisposal()));
-  }
-  /**
-   * Notifies all observers of a state change
-   * @param newState - The new state value
-   * @param oldState - The previous state value
-   * @param action - Optional action that triggered the state change
-   */
-  notify(e, t, s) {
-    this._observers.forEach((r) => {
-      let n = !1;
-      if (r.dependencyArray) {
-        const o = r.lastState, a = r.dependencyArray(
-          e,
-          t,
-          this.bloc
-        );
-        if (!o)
-          n = !0;
-        else if (o.length !== a.length)
-          n = !0;
-        else
-          for (let l = 0; l < a.length; l++)
-            if (!Object.is(o[l], a[l])) {
-              n = !0;
-              break;
-            }
-        r.lastState = a;
-      } else
-        n = !0;
-      n && r.fn(e, t, s);
-    }), u.instance.plugins.notifyStateChanged(this.bloc, t, e);
-  }
-  /**
-   * Clears the observer set
-   */
-  clear() {
-    this._observers.clear();
-  }
-}
-function $() {
-  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-    const e = Math.random() * 16 | 0;
-    return (c === "x" ? e : e & 3 | 8).toString(16);
-  });
-}
-class V {
-  constructor() {
-    i(this, "plugins", /* @__PURE__ */ new Map());
-    i(this, "executionOrder", []);
-    i(this, "attached", !1);
-  }
-  /**
-   * Add a bloc plugin
-   */
-  add(e) {
-    if (this.plugins.has(e.name))
-      throw new Error(`Plugin '${e.name}' is already registered`);
-    e.capabilities && this.validateCapabilities(e), this.plugins.set(e.name, e), this.executionOrder.push(e.name);
-  }
-  /**
-   * Remove a bloc plugin
-   */
-  remove(e) {
-    const t = this.plugins.get(e);
-    if (!t) return !1;
-    if (this.attached && t.onDetach)
-      try {
-        t.onDetach();
-      } catch (s) {
-        console.error(`Plugin '${e}' error in onDetach:`, s);
-      }
-    return this.plugins.delete(e), this.executionOrder = this.executionOrder.filter((s) => s !== e), !0;
-  }
-  /**
-   * Get a plugin by name
-   */
-  get(e) {
-    return this.plugins.get(e);
-  }
-  /**
-   * Get all plugins in execution order
-   */
-  getAll() {
-    return this.executionOrder.map((e) => this.plugins.get(e));
-  }
-  /**
-   * Clear all plugins
-   */
-  clear() {
-    if (this.attached) {
-      for (const e of this.getAll())
-        if (e.onDetach)
-          try {
-            e.onDetach();
-          } catch (t) {
-            console.error(`Plugin '${e.name}' error in onDetach:`, t);
-          }
-    }
-    this.plugins.clear(), this.executionOrder = [], this.attached = !1;
-  }
-  /**
-   * Attach all plugins to a bloc
-   */
-  attach(e) {
-    if (this.attached)
-      throw new Error("Plugins are already attached");
-    for (const t of this.getAll())
-      if (t.onAttach)
-        try {
-          t.onAttach(e);
-        } catch (s) {
-          console.error(`Plugin '${t.name}' error in onAttach:`, s), this.remove(t.name);
-        }
-    this.attached = !0;
-  }
-  /**
-   * Transform state through all plugins
-   */
-  transformState(e, t) {
-    let s = t;
-    for (const r of this.getAll())
-      if (r.transformState && this.canTransformState(r))
-        try {
-          s = r.transformState(e, s);
-        } catch (n) {
-          console.error(`Plugin '${r.name}' error in transformState:`, n);
-        }
-    return s;
-  }
-  /**
-   * Transform event through all plugins
-   */
-  transformEvent(e) {
-    let t = e;
-    for (const s of this.getAll()) {
-      if (t === null) break;
-      if (s.transformEvent && this.canInterceptEvents(s))
-        try {
-          t = s.transformEvent(t);
-        } catch (r) {
-          console.error(`Plugin '${s.name}' error in transformEvent:`, r);
-        }
-    }
-    return t;
-  }
-  /**
-   * Notify plugins of state change
-   */
-  notifyStateChange(e, t) {
-    for (const s of this.getAll())
-      if (s.onStateChange && this.canReadState(s))
-        try {
-          s.onStateChange(e, t);
-        } catch (r) {
-          console.error(`Plugin '${s.name}' error in onStateChange:`, r);
-        }
-  }
-  /**
-   * Notify plugins of event
-   */
-  notifyEvent(e) {
-    for (const t of this.getAll())
-      if (t.onEvent && this.canReadState(t))
-        try {
-          t.onEvent(e);
-        } catch (s) {
-          console.error(`Plugin '${t.name}' error in onEvent:`, s);
-        }
-  }
-  /**
-   * Notify plugins of error
-   */
-  notifyError(e, t) {
-    for (const s of this.getAll())
-      if (s.onError)
-        try {
-          s.onError(e, t);
-        } catch (r) {
-          console.error(`Plugin '${s.name}' error in onError:`, r);
-        }
-  }
-  validateCapabilities(e) {
-    const t = e.capabilities;
-    if (t.transformState && !t.readState)
-      throw new Error(`Plugin '${e.name}': transformState requires readState capability`);
-    if (t.interceptEvents && !t.readState)
-      throw new Error(`Plugin '${e.name}': interceptEvents requires readState capability`);
-  }
-  canReadState(e) {
-    return !e.capabilities || e.capabilities.readState !== !1;
-  }
-  canTransformState(e) {
-    return !e.capabilities || e.capabilities.transformState === !0;
-  }
-  canInterceptEvents(e) {
-    return !e.capabilities || e.capabilities.interceptEvents === !0;
-  }
-}
-var y = /* @__PURE__ */ ((c) => (c.ACTIVE = "active", c.DISPOSAL_REQUESTED = "disposal_requested", c.DISPOSING = "disposing", c.DISPOSED = "disposed", c))(y || {});
-class k {
-  /**
-   * 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(e) {
-    i(this, "uid", $());
-    /**
-     * Defines how dependencies are selected from the state for efficient updates.
-     * When provided, observers will only be notified when selected dependencies change.
-     */
-    i(this, "defaultDependencySelector");
-    /**
-     * @internal
-     * Indicates if this specific Bloc instance is isolated from others of the same type.
-     */
-    i(this, "_isolated", !1);
-    /**
-     * @internal
-     * Observable responsible for managing state listeners and notifying consumers.
-     */
-    i(this, "_observer");
-    /**
-     * The unique identifier for this Bloc instance.
-     * Defaults to the class name, but can be customized.
-     */
-    i(this, "_id");
-    /**
-     * @internal
-     * Reference string used internally for tracking and debugging.
-     */
-    i(this, "_instanceRef");
-    /**
-     * @internal
-     * Indicates if this specific Bloc instance should be kept alive when no consumers are present.
-     */
-    i(this, "_keepAlive", !1);
-    /**
-     * @readonly
-     * Timestamp when this Bloc instance was created, useful for debugging and performance tracking.
-     */
-    i(this, "_createdAt", Date.now());
-    /**
-     * @internal
-     * Atomic disposal state to prevent race conditions
-     */
-    i(this, "_disposalState", "active");
-    /**
-     * @internal
-     * Timestamp when disposal was requested (for React Strict Mode grace period)
-     */
-    i(this, "_disposalRequestTime", 0);
-    /**
-     * @internal
-     * The current state of the Bloc.
-     */
-    i(this, "_state");
-    /**
-     * @internal
-     * The previous state of the Bloc, maintained for comparison and history.
-     */
-    i(this, "_oldState");
-    /**
-     * Props passed during Bloc instance creation.
-     * Can be used to configure or parameterize the Bloc's behavior.
-     */
-    i(this, "props", null);
-    /**
-     * @internal
-     * Flag to prevent batching race conditions
-     */
-    i(this, "_batchingLock", !1);
-    /**
-     * @internal
-     * Pending batched updates
-     */
-    i(this, "_pendingUpdates", []);
-    /**
-     * @internal
-     * Map of consumer IDs to their WeakRef objects for proper cleanup
-     */
-    i(this, "_consumerRefs", /* @__PURE__ */ new Map());
-    /**
-     * Plugin registry for this bloc instance
-     */
-    i(this, "_plugins");
-    /**
-     * @internal
-     * Validates that all consumer references are still alive
-     * Removes dead consumers automatically
-     */
-    i(this, "_validateConsumers", () => {
-      const e = [];
-      for (const [t, s] of this._consumerRefs)
-        s.deref() === void 0 && e.push(t);
-      for (const t of e)
-        this._consumers.delete(t), this._consumerRefs.delete(t);
-      this._consumers.size === 0 && !this._keepAlive && this._disposalState === "active" && this._scheduleDisposal();
-    });
-    /**
-     * @internal
-     * Updates the Bloc instance's ID to a new value.
-     * Only updates if the new ID is defined and different from the current one.
-     *
-     * @param id The new ID to assign to this Bloc instance
-     */
-    i(this, "_updateId", (e) => {
-      const t = this._id;
-      !e || e === t || (this._id = e);
-    });
-    /**
-     * @internal
-     * Optional function to be called when the Bloc is disposed.
-     */
-    i(this, "onDispose");
-    /**
-     * @internal
-     * Set of consumer IDs currently listening to this Bloc's state changes.
-     */
-    i(this, "_consumers", /* @__PURE__ */ new Set());
-    /**
-     * @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
-     */
-    i(this, "_addConsumer", (e, t) => {
-      var s;
-      return this._disposalState !== "active" ? !1 : (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}`
-      )), !0);
-    });
-    /**
-     * @internal
-     * Unregisters a consumer from this Bloc instance.
-     * Notifies the Blac manager that a consumer has been removed.
-     *
-     * @param consumerId The unique ID of the consumer being removed
-     */
-    i(this, "_removeConsumer", (e) => {
-      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
-     * Handler function for disposal (can be set by Blac manager)
-     */
-    i(this, "_disposalHandler");
-    i(this, "lastUpdate", Date.now());
-    /**
-     * @internal
-     * Flag to indicate if batching is enabled for this bloc
-     */
-    i(this, "_batchingEnabled", !1);
-    /**
-     * @internal
-     * Updates the state and notifies all observers of the change.
-     *
-     * @param newState The new state to be set
-     * @param oldState The previous state for comparison
-     * @param action Optional metadata about what caused the state change
-     */
-    i(this, "_pushState", (e, t, s) => {
-      if (e === void 0 || s !== void 0 && typeof s != "object" && typeof s != "function")
-        return;
-      let r = e;
-      try {
-        r = this._plugins.transformState(t, e);
-      } catch (n) {
-        this._plugins.notifyError(n, {
-          phase: "state-change",
-          operation: "transformState"
-        });
-      }
-      if (this._batchingEnabled) {
-        this._pendingUpdates.push({ newState: r, oldState: t, action: s }), this._oldState = t, this._state = r;
-        return;
-      }
-      this._oldState = t, this._state = r;
-      try {
-        this._plugins.notifyStateChange(t, r);
-      } catch (n) {
-        console.error("Error notifying bloc plugins of state change:", n);
-      }
-      this._observer.notify(r, t, s), this.lastUpdate = Date.now();
-    });
-    /**
-     * Enables batching for multiple state updates
-     * @param batchFn Function to execute with batching enabled
-     */
-    i(this, "batch", (e) => {
-      if (this._batchingLock)
-        return e();
-      this._batchingLock = !0, this._batchingEnabled = !0, this._pendingUpdates = [];
-      try {
-        const t = e();
-        if (this._pendingUpdates.length > 0) {
-          const s = this._pendingUpdates[this._pendingUpdates.length - 1];
-          this._observer.notify(
-            s.newState,
-            s.oldState,
-            s.action
-          ), this.lastUpdate = Date.now();
-        }
-        return t;
-      } finally {
-        this._batchingEnabled = !1, this._batchingLock = !1, this._pendingUpdates = [];
-      }
-    });
-    this._state = e, this._observer = new H(this), this._id = this.constructor.name;
-    const t = this.constructor;
-    if (this._keepAlive = typeof t.keepAlive == "boolean" ? t.keepAlive : !1, this._isolated = typeof t.isolated == "boolean" ? t.isolated : !1, this._plugins = new V(), t.plugins && Array.isArray(t.plugins))
-      for (const s of t.plugins)
-        this.addPlugin(s);
-  }
-  get isIsolated() {
-    return this._isolated;
-  }
-  get isKeepAlive() {
-    return this._keepAlive;
-  }
-  /**
-   * Returns the current state of the Bloc.
-   * Use this getter to access the state in a read-only manner.
-   * Returns the state even during transitional lifecycle states for React compatibility.
-   */
-  get state() {
-    return this._disposalState === "disposed" ? this._state : this._state;
-  }
-  /**
-   * Returns whether this Bloc instance has been disposed.
-   * @returns true if the bloc is in DISPOSED state
-   */
-  get isDisposed() {
-    return this._disposalState === "disposed";
-  }
-  /**
-   * @internal
-   * Returns the name of the Bloc class for identification and debugging.
-   */
-  get _name() {
-    return this.constructor.name;
-  }
-  /**
-   * @internal
-   * Performs atomic state transition using compare-and-swap semantics
-   * @param expectedState The expected current state
-   * @param newState The desired new state
-   * @returns Result indicating success/failure and state information
-   */
-  _atomicStateTransition(e, t) {
-    var s, r, n, o;
-    if (this._disposalState === e) {
-      const a = this._disposalState;
-      return this._disposalState = t, (s = globalThis.Blac) != null && s.enableLog && ((r = globalThis.Blac) == null || r.log(
-        `[${this._name}:${this._id}] State transition: ${a} -> ${t} (SUCCESS)`
-      )), {
-        success: !0,
-        currentState: t,
-        previousState: a
-      };
-    }
-    return (n = globalThis.Blac) != null && n.enableLog && ((o = globalThis.Blac) == null || o.log(
-      `[${this._name}:${this._id}] State transition failed: expected ${e}, current ${this._disposalState}`
-    )), {
-      success: !1,
-      currentState: this._disposalState,
-      previousState: e
-    };
-  }
-  /**
-   * @internal
-   * Cleans up resources and removes this Bloc from the system.
-   * Notifies the Blac manager and clears all observers.
-   */
-  _dispose() {
-    var t;
-    let e = this._atomicStateTransition(
-      "active",
-      "disposing"
-      /* DISPOSING */
-    );
-    if (e.success || (e = this._atomicStateTransition(
-      "disposal_requested",
-      "disposing"
-      /* DISPOSING */
-    )), !e.success)
-      return !1;
-    try {
-      return this._consumers.clear(), this._consumerRefs.clear(), this._observer.clear(), (t = this.onDispose) == null || t.call(this), this._atomicStateTransition(
-        "disposing",
-        "disposed"
-        /* DISPOSED */
-      ).success;
-    } catch (s) {
-      throw this._disposalState = "active", s;
-    }
-  }
-  /**
-   * @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
-   * Uses atomic state transitions to prevent race conditions
-   */
-  _scheduleDisposal() {
-    if (!this._atomicStateTransition(
-      "active",
-      "disposal_requested"
-      /* DISPOSAL_REQUESTED */
-    ).success)
-      return;
-    if (!(this._consumers.size === 0 && !this._keepAlive)) {
-      this._atomicStateTransition(
-        "disposal_requested",
-        "active"
-        /* ACTIVE */
-      );
-      return;
-    }
-    this._disposalRequestTime = Date.now(), queueMicrotask(() => {
-      this._consumers.size === 0 && !this._keepAlive && this._observer.size === 0 && this._disposalState === "disposal_requested" ? this._disposalHandler ? this._disposalHandler(this) : this._dispose() : this._atomicStateTransition(
-        "disposal_requested",
-        "active"
-        /* ACTIVE */
-      );
-    });
-  }
-  /**
-   * Notify observers of a state change
-   * @internal Used by plugins for state hydration
-   * @param newState The new state
-   * @param oldState The old state
-   */
-  _notifyObservers(e, t) {
-    this._observer.notify(e, t);
-  }
-  /**
-   * Add a plugin to this bloc instance
-   */
-  addPlugin(e) {
-    if (this._plugins.add(e), this._disposalState === "active")
-      try {
-        e.onAttach && e.onAttach(this);
-      } catch (t) {
-        throw console.error(`Failed to attach plugin '${e.name}':`, t), this._plugins.remove(e.name), t;
-      }
-  }
-  /**
-   * Remove a plugin from this bloc instance
-   */
-  removePlugin(e) {
-    return this._plugins.remove(e);
-  }
-  /**
-   * Get a plugin by name
-   */
-  getPlugin(e) {
-    return this._plugins.get(e);
-  }
-  /**
-   * Get all plugins
-   */
-  getPlugins() {
-    return this._plugins.getAll();
-  }
-  /**
-   * @internal
-   * Activate plugins when bloc becomes active
-   */
-  _activatePlugins() {
-    if (this._disposalState === "active")
-      try {
-        this._plugins.attach(this);
-      } catch (e) {
-        console.error(`Failed to activate plugins for ${this._name}:`, e);
-      }
-  }
-}
-/**
- * When true, every consumer will receive its own unique instance of this Bloc.
- * Use this when state should not be shared between components.
- * @default false
- */
-i(k, "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(k, "keepAlive", !1);
-class U {
-  constructor() {
-    i(this, "plugins", /* @__PURE__ */ new Map());
-    i(this, "metrics", /* @__PURE__ */ new Map());
-    i(this, "executionOrder", []);
-  }
-  /**
-   * Add a system plugin
-   */
-  add(e) {
-    if (this.plugins.has(e.name))
-      throw new Error(`Plugin '${e.name}' is already registered`);
-    this.plugins.set(e.name, e), this.executionOrder.push(e.name), this.initializeMetrics(e.name);
-  }
-  /**
-   * Remove a system plugin
-   */
-  remove(e) {
-    return this.plugins.get(e) ? (this.plugins.delete(e), this.metrics.delete(e), this.executionOrder = this.executionOrder.filter((s) => s !== e), !0) : !1;
-  }
-  /**
-   * Get a plugin by name
-   */
-  get(e) {
-    return this.plugins.get(e);
-  }
-  /**
-   * Get all plugins in execution order
-   */
-  getAll() {
-    return this.executionOrder.map((e) => this.plugins.get(e));
-  }
-  /**
-   * Clear all plugins
-   */
-  clear() {
-    this.plugins.clear(), this.metrics.clear(), this.executionOrder = [];
-  }
-  /**
-   * Execute a hook on all plugins
-   */
-  executeHook(e, t, s) {
-    for (const r of this.executionOrder) {
-      const n = this.plugins.get(r), o = n[e];
-      if (typeof o != "function") continue;
-      const a = performance.now();
-      try {
-        o.apply(n, t), this.recordSuccess(r, e, a);
-      } catch (l) {
-        this.recordError(r, e, l), s ? s(l, n) : console.error(`Plugin '${r}' error in hook '${e}':`, l);
-      }
-    }
-  }
-  /**
-   * Bootstrap all plugins
-   */
-  bootstrap() {
-    this.executeHook("beforeBootstrap", []), this.executeHook("afterBootstrap", []);
-  }
-  /**
-   * Shutdown all plugins
-   */
-  shutdown() {
-    this.executeHook("beforeShutdown", []), this.executeHook("afterShutdown", []);
-  }
-  /**
-   * Notify plugins of bloc creation
-   */
-  notifyBlocCreated(e) {
-    this.executeHook("onBlocCreated", [e]);
-  }
-  /**
-   * Notify plugins of bloc disposal
-   */
-  notifyBlocDisposed(e) {
-    this.executeHook("onBlocDisposed", [e]);
-  }
-  /**
-   * Notify plugins of state change
-   */
-  notifyStateChanged(e, t, s) {
-    this.executeHook("onStateChanged", [e, t, s]);
-  }
-  /**
-   * Notify plugins of event addition
-   */
-  notifyEventAdded(e, t) {
-    this.executeHook("onEventAdded", [e, t]);
-  }
-  /**
-   * Notify plugins of errors
-   */
-  notifyError(e, t, s) {
-    this.executeHook("onError", [e, t, s], (r, n) => {
-      console.error(`Plugin '${n.name}' error handler failed:`, r);
-    });
-  }
-  /**
-   * Get metrics for a plugin
-   */
-  getMetrics(e) {
-    return this.metrics.get(e);
-  }
-  initializeMetrics(e) {
-    this.metrics.set(e, /* @__PURE__ */ new Map());
-  }
-  recordSuccess(e, t, s) {
-    const r = this.metrics.get(e), n = r.get(t) || {
-      executionTime: 0,
-      executionCount: 0,
-      errorCount: 0
-    }, o = performance.now() - s;
-    r.set(t, {
-      ...n,
-      executionTime: n.executionTime + o,
-      executionCount: n.executionCount + 1,
-      lastExecutionTime: o
-    });
-  }
-  recordError(e, t, s) {
-    const r = this.metrics.get(e), n = r.get(t) || {
-      executionTime: 0,
-      executionCount: 0,
-      errorCount: 0
-    };
-    r.set(t, {
-      ...n,
-      errorCount: n.errorCount + 1,
-      lastError: s
-    });
-  }
-}
-const _ = class _ {
-  getInstance() {
-    return _._instance || (_._instance = new u({
-      __unsafe_ignore_singleton: !0
-    })), _._instance;
-  }
-  setInstance(e) {
-    _._instance = e;
-  }
-  resetInstance() {
-    const e = _._instance;
-    if (_._instance = new u({
-      __unsafe_ignore_singleton: !0
-    }), e)
-      for (const t of e.keepAliveBlocs)
-        _._instance.keepAliveBlocs.add(t), _._instance.uidRegistry.set(t.uid, t);
-  }
-};
-i(_, "_instance");
-let E = _, S = new E();
-function W(c) {
-  S = c;
-}
-const h = class h {
-  /**
-   * Creates a new Blac instance.
-   * @param options - Configuration options including singleton control
-   */
-  constructor(e = {}) {
-    /** Timestamp when the instance was created */
-    i(this, "createdAt", Date.now());
-    /** 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 */
-    // 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());
-    /** Map tracking UIDs to prevent memory leaks */
-    i(this, "uidRegistry", /* @__PURE__ */ new Map());
-    /** Set of keep-alive blocs for controlled cleanup */
-    i(this, "keepAliveBlocs", /* @__PURE__ */ new Set());
-    /** Flag to control whether changes should be posted to document */
-    i(this, "postChangesToDocument", !1);
-    /** System plugin registry */
-    i(this, "plugins", new U());
-    /**
-     * Logs messages to console when logging is enabled
-     * @param args - Arguments to log
-     */
-    i(this, "log", (...e) => {
-      h.logSpy && h.logSpy(e), h.enableLog && h.logLevel, h.enableLog && h.logLevel;
-    });
-    /**
-     * Logs a warning message
-     * @param message - Warning message
-     * @param args - Additional arguments
-     */
-    i(this, "warn", (e, ...t) => {
-      h.enableLog;
-    });
-    /**
-     * Logs an error message
-     * @param message - Error message
-     * @param args - Additional arguments
-     */
-    i(this, "error", (e, ...t) => {
-      h.enableLog;
-    });
-    /**
-     * Resets the Blac instance to a new one, disposing non-keepAlive blocs
-     * from the old instance.
-     */
-    i(this, "resetInstance", () => {
-      this.log("Reset Blac instance");
-      const e = new Map(this.blocInstanceMap), t = new Map(this.isolatedBlocMap);
-      e.forEach((s) => {
-        !s._keepAlive && s._disposalState === y.ACTIVE && this.disposeBloc(s);
-      }), t.forEach((s) => {
-        s.forEach((r) => {
-          !r._keepAlive && r._disposalState === y.ACTIVE && this.disposeBloc(r);
-        });
-      }), this.blocInstanceMap.clear(), this.isolatedBlocMap.clear(), this.isolatedBlocIndex.clear(), S.resetInstance();
-    });
-    /**
-     * Disposes of a bloc instance by removing it from the appropriate registry
-     * @param bloc - The bloc instance to dispose
-     */
-    i(this, "disposeBloc", (e) => {
-      const t = e._disposalState;
-      if (![
-        y.ACTIVE,
-        y.DISPOSAL_REQUESTED
-      ].includes(t)) {
-        this.log(
-          `[${e._name}:${String(e._id)}] disposeBloc called on bloc in invalid state: ${t}`
-        );
-        return;
-      }
-      const r = e.constructor, n = this.createBlocInstanceMapKey(e._name, e._id);
-      this.log(
-        `[${e._name}:${String(e._id)}] disposeBloc called. Isolated: ${String(r.isolated)}`
-      ), e._dispose(), this.plugins.notifyBlocDisposed(e), r.isolated ? (this.unregisterIsolatedBlocInstance(e), this.blocInstanceMap.delete(n)) : this.unregisterBlocInstance(e), this.log("dispatched bloc", e);
-    });
-    i(this, "activateBloc", (e) => {
-      if (e._disposalState !== y.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));
-    });
-    /**
-     * 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)
-     *   - props: Properties to pass to the bloc constructor
-     *   - instanceRef: Optional reference string for the instance
-     * @returns The bloc instance
-     */
-    i(this, "getBloc", (e, t = {}) => {
-      const { id: s, forceNewInstance: r } = t, n = e, o = s ?? e.name;
-      if (this.log(`[${e.name}:${String(o)}] (getBloc) Called:`, {
-        options: t,
-        base: n
-      }), !r)
-        if (n.isolated) {
-          const l = this.findIsolatedBlocInstance(
-            e,
-            t.instanceRef ?? o
-          );
-          if (l)
-            return l;
-          if (t.throwIfNotFound)
-            throw new Error(`Isolated bloc ${e.name} not found`);
-        } else {
-          const l = this.findRegisteredBlocInstance(
-            e,
-            o
-          );
-          if (l)
-            return l;
-          if (t.throwIfNotFound)
-            throw new Error(`Registered bloc ${e.name} not found`);
-        }
-      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
-     * @param blocClass - The bloc class to get
-     * @param options - Options including:
-     *   - id: The instance ID (defaults to class name if not provided)
-     *   - props: Properties to pass to the bloc constructor
-     *   - instanceRef: Optional reference string for the instance
-     */
-    i(this, "getBlocOrThrow", (e, t = {}) => {
-      const s = e.isolated, r = t.id || e.name, n = s ? this.findIsolatedBlocInstance(e, r) : this.findRegisteredBlocInstance(e, r);
-      if (n)
-        return n;
-      throw new Error(`Bloc ${e.name} not found`);
-    });
-    /**
-     * Gets all instances of a specific bloc class
-     * @param blocClass - The bloc class to search for
-     * @param options - Options including:
-     *   - searchIsolated: Whether to search in isolated blocs (defaults to bloc's isolated property)
-     * @returns Array of matching bloc instances
-     */
-    i(this, "getAllBlocs", (e, t = {}) => {
-      const s = [];
-      if (this.blocInstanceMap.forEach((r) => {
-        r.constructor === e && s.push(r);
-      }), t.searchIsolated !== !1) {
-        const r = this.isolatedBlocMap.get(e);
-        r && s.push(...r.map((n) => n));
-      }
-      return s;
-    });
-    /**
-     * Disposes all keep-alive blocs of a specific type
-     * @param blocClass - The bloc class to dispose
-     */
-    i(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
-     */
-    i(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 r of s)
-          e(r) && t.push(r);
-      t.forEach((s) => s._dispose());
-    });
-    /**
-     * Gets memory usage statistics for debugging
-     */
-    i(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
-     */
-    i(this, "validateConsumers", () => {
-      for (const e of this.uidRegistry.values())
-        e._validateConsumers(), e._consumers.size === 0 && !e._keepAlive && e._disposalState === y.ACTIVE && setTimeout(() => {
-          e._consumers.size === 0 && !e._keepAlive && e._disposalState === y.ACTIVE && this.disposeBloc(e);
-        }, 1e3);
-    });
-    const { __unsafe_ignore_singleton: t = !1 } = e;
-    if (!t)
-      return h.instance;
-    S.setInstance(this), this.plugins.bootstrap();
-  }
-  static get instance() {
-    return S.getInstance();
-  }
-  static get getAllBlocs() {
-    return h.instance.getAllBlocs;
-  }
-  /** Get current configuration */
-  static get config() {
-    return { ...this._config };
-  }
-  /**
-   * Set or update Blac configuration
-   * @param config - Partial configuration to merge with existing config
-   * @throws Error if configuration is invalid
-   */
-  static setConfig(e) {
-    if (e.proxyDependencyTracking !== void 0 && typeof e.proxyDependencyTracking != "boolean")
-      throw new Error("BlacConfig.proxyDependencyTracking must be a boolean");
-    if (e.exposeBlacInstance !== void 0 && typeof e.exposeBlacInstance != "boolean")
-      throw new Error("BlacConfig.exposeBlacInstance must be a boolean");
-    this._config = {
-      ...this._config,
-      ...e
-    }, this.enableLog && this.instance.log("Blac config updated:", this._config);
-  }
-  static get log() {
-    return h.instance.log;
-  }
-  /**
-   * Gets the current Blac instance
-   * @returns The Blac instance
-   */
-  static getInstance() {
-    return S.getInstance();
-  }
-  static get warn() {
-    return h.instance.warn;
-  }
-  static get error() {
-    return h.instance.error;
-  }
-  static get disposeBloc() {
-    return h.instance.disposeBloc;
-  }
-  /**
-   * Creates a unique key for a bloc instance in the map based on the bloc class name and instance ID
-   * @param blocClassName - The name of the bloc class
-   * @param id - The instance ID
-   * @returns A unique key string in the format "className:id"
-   */
-  createBlocInstanceMapKey(e, t) {
-    return `${e}:${String(t)}`;
-  }
-  /**
-   * Unregister a bloc instance from the main registry
-   * @param bloc - The bloc instance to unregister
-   */
-  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(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
-   * @param blocClass - The bloc class to search for
-   * @param id - The instance ID
-   * @returns The found bloc instance or undefined if not found
-   */
-  findRegisteredBlocInstance(e, t) {
-    if (e.isolated) return;
-    const r = this.createBlocInstanceMapKey(e.name, t);
-    return this.blocInstanceMap.get(r);
-  }
-  /**
-   * Registers an isolated bloc instance in the isolated registry
-   * @param bloc - The isolated bloc instance to register
-   */
-  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(e) {
-    const t = e.constructor, s = this.isolatedBlocMap.get(t);
-    let r = !1;
-    if (s) {
-      const o = s.findIndex((a) => a.uid === e.uid);
-      o !== -1 && (s.splice(o, 1), r = !0), s.length === 0 && this.isolatedBlocMap.delete(t);
-    }
-    const n = this.isolatedBlocIndex.delete(e.uid);
-    this.uidRegistry.delete(e.uid), this.keepAliveBlocs.delete(e), r !== n && this.warn(
-      `[Blac] Inconsistent state detected during isolated bloc cleanup for ${e._name}:${e.uid}. Map removal: ${r}, Index removal: ${n}`
-    );
-  }
-  /**
-   * Finds an isolated bloc instance by its class and ID (O(n) lookup)
-   */
-  findIsolatedBlocInstance(e, t) {
-    if (!e.isolated) return;
-    const r = this.isolatedBlocMap.get(e);
-    return r ? r.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
-   * @param blocClass - The bloc class to instantiate
-   * @param id - The instance ID
-   * @param props - Properties to pass to the bloc constructor
-   * @param instanceRef - Optional reference string for the instance
-   * @returns The newly created bloc instance
-   */
-  createNewBlocInstance(e, t, s = {}) {
-    const { props: r, instanceRef: n } = s, o = new e(r);
-    return o._instanceRef = n, o.props = r || null, o._updateId(t), o._setDisposalHandler((a) => this.disposeBloc(a)), o.isIsolated ? this.registerIsolatedBlocInstance(o) : this.registerBlocInstance(o), o._activatePlugins(), this.plugins.notifyBlocCreated(o), o;
-  }
-  static get activateBloc() {
-    return h.instance.activateBloc;
-  }
-  static get getBloc() {
-    return h.instance.getBloc;
-  }
-  static get getBlocOrThrow() {
-    return h.instance.getBlocOrThrow;
-  }
-  static get disposeKeepAliveBlocs() {
-    return h.instance.disposeKeepAliveBlocs;
-  }
-  static get disposeBlocs() {
-    return h.instance.disposeBlocs;
-  }
-  static get getMemoryStats() {
-    return h.instance.getMemoryStats;
-  }
-  static get validateConsumers() {
-    return h.instance.validateConsumers;
-  }
-  /**
-   * Bootstrap the Blac instance and all plugins
-   */
-  bootstrap() {
-    this.plugins.bootstrap();
-  }
-  /**
-   * Shutdown the Blac instance and all plugins
-   */
-  shutdown() {
-    this.plugins.shutdown();
-    for (const e of this.blocInstanceMap.values())
-      e._keepAlive || this.disposeBloc(e);
-    for (const e of this.isolatedBlocMap.values())
-      for (const t of e)
-        t._keepAlive || this.disposeBloc(t);
-  }
-};
-/** Private static configuration */
-i(h, "_config", {
-  exposeBlacInstance: !1,
-  proxyDependencyTracking: !0
-}), /** Flag to enable/disable logging */
-i(h, "enableLog", !1), i(h, "logLevel", "warn"), i(h, "logSpy", null), i(h, "resetInstance", () => {
-  S.resetInstance();
-});
-let u = h;
-class j extends k {
-  constructor() {
-    super(...arguments);
-    i(this, "eventHandlers", /* @__PURE__ */ new Map());
-    /**
-     * @internal
-     * Event queue to ensure sequential processing of async events
-     */
-    i(this, "_eventQueue", []);
-    /**
-     * @internal
-     * Flag indicating if an event is currently being processed
-     */
-    i(this, "_isProcessingEvent", !1);
-    /**
-     * Dispatches an action/event to the Bloc.
-     * Events are queued and processed sequentially to prevent race conditions.
-     * @param action The action/event instance to be processed.
-     */
-    i(this, "add", async (t) => {
-      let s = t;
-      try {
-        s = this._plugins.transformEvent(t);
-      } catch (r) {
-        console.error("Error transforming event:", r);
-      }
-      if (s !== null) {
-        try {
-          this._plugins.notifyEvent(s);
-        } catch (r) {
-          console.error("Error notifying plugins of event:", r);
-        }
-        u.instance.plugins.notifyEventAdded(this, s), this._eventQueue.push(s), this._isProcessingEvent || await this._processEventQueue();
-      }
-    });
-  }
-  /**
-   * Registers an event handler for a specific event type.
-   * This method is typically called in the constructor of a derived Bloc class.
-   * @param eventConstructor The constructor of the event to handle (e.g., LoadDataEvent).
-   * @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, s) {
-    this.eventHandlers.has(t) && u.warn(
-      `[Bloc ${this._name}:${String(this._id)}] Handler for event '${t.name}' already registered. It will be overwritten.`
-    ), this.eventHandlers.set(
-      t,
-      s
-    );
-  }
-  /**
-   * @internal
-   * Processes events from the queue sequentially
-   */
-  async _processEventQueue() {
-    if (!this._isProcessingEvent) {
-      this._isProcessingEvent = !0;
-      try {
-        for (; this._eventQueue.length > 0; ) {
-          const t = this._eventQueue.shift();
-          await this._processEvent(t);
-        }
-      } finally {
-        this._isProcessingEvent = !1;
-      }
-    }
-  }
-  /**
-   * @internal
-   * Processes a single event
-   */
-  async _processEvent(t) {
-    const s = t.constructor, r = this.eventHandlers.get(s);
-    if (r) {
-      const n = (o) => {
-        const a = this.state;
-        this._pushState(o, a, t);
-      };
-      try {
-        await r(t, n);
-      } catch (o) {
-        const a = t.constructor.name || "UnnamedConstructor", l = {
-          blocName: this._name,
-          blocId: String(this._id),
-          eventType: a,
-          currentState: this.state,
-          action: t,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (u.error(
-          `[Bloc ${this._name}:${String(this._id)}] Error in event handler for '${a}':`,
-          o,
-          "Context:",
-          l
-        ), o instanceof Error)
-          try {
-            this._plugins.notifyError(o, {
-              phase: "event-processing",
-              operation: "handler",
-              metadata: { event: t }
-            }), u.instance.plugins.notifyError(o, this, {
-              phase: "event-processing",
-              operation: "handler",
-              metadata: { event: t }
-            });
-          } catch (d) {
-            console.error("Error notifying plugins:", d);
-          }
-        if (o instanceof Error && o.name === "CriticalError")
-          throw o;
-      }
-    } else {
-      const n = t.constructor.name || "UnnamedConstructor";
-      u.warn(
-        `[Bloc ${this._name}:${String(this._id)}] No handler registered for action type: '${n}'.`,
-        "Registered handlers:",
-        Array.from(this.eventHandlers.keys()).map((o) => o.name),
-        "Action was:",
-        t
-      );
-    }
-  }
-}
-class z extends k {
-  /**
-   * @internal
-   * Protected method for useBloc to call
-   */
-  _updateProps(e) {
-    var s;
-    const t = this.props;
-    this.props = e, (s = this.onPropsChanged) == null || s.call(this, t, 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(e) {
-    if (Object.is(e, this.state))
-      return;
-    const t = this.state, s = e;
-    this._pushState(s, t);
-  }
-  /**
-   * 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) {
-      u.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 r in e)
-        if (Object.prototype.hasOwnProperty.call(e, r)) {
-          const o = this.state[r];
-          if (!Object.is(e[r], o)) {
-            s = !0;
-            break;
-          }
-        }
-    s && this.emit({
-      ...this.state,
-      ...e
-    });
-  }
-}
-class L {
-  constructor(e) {
-    this.props = e;
-  }
-}
-function N(c, e) {
-  if (Object.is(c, e))
-    return !0;
-  if (typeof c != "object" || c === null || typeof e != "object" || e === null)
-    return !1;
-  const t = Object.keys(c), s = Object.keys(e);
-  if (t.length !== s.length)
-    return !1;
-  for (let r = 0; r < t.length; r++) {
-    const n = t[r];
-    if (!Object.prototype.hasOwnProperty.call(e, n) || !Object.is(c[n], e[n]))
-      return !1;
-  }
-  return !0;
-}
-class q {
-  /**
-   * Sets up a clean test environment
-   */
-  static setUp() {
-    this.originalInstance = u.instance, u.resetInstance(), u.enableLog = !1;
-  }
-  /**
-   * Tears down the test environment and restores original state
-   */
-  static tearDown() {
-    u.resetInstance();
-  }
-  /**
-   * Creates a test bloc with automatic cleanup
-   */
-  static createBloc(e, ...t) {
-    const s = new e(...t);
-    return u.activateBloc(s), s;
-  }
-  /**
-   * Waits for a bloc to emit a specific state
-   */
-  static async waitForState(e, t, s = 5e3) {
-    return new Promise((r, n) => {
-      const o = setTimeout(() => {
-        n(
-          new Error(
-            `Timeout waiting for state matching predicate after ${s}ms`
-          )
-        );
-      }, s), a = e._observer.subscribe({
-        id: `test-waiter-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        fn: (l) => {
-          t(l) && (clearTimeout(o), a(), r(l));
-        }
-      });
-      t(e.state) && (clearTimeout(o), a(), r(e.state));
-    });
-  }
-  /**
-   * Expects a bloc to emit specific states in order
-   */
-  static async expectStates(e, t, s = 5e3) {
-    const r = [];
-    return new Promise((n, o) => {
-      const a = setTimeout(() => {
-        o(
-          new Error(
-            `Timeout waiting for states. Expected: ${JSON.stringify(t)}, Received: ${JSON.stringify(r)}`
-          )
-        );
-      }, s), l = e._observer.subscribe({
-        id: `test-expecter-${crypto.randomUUID()}`,
-        fn: (d) => {
-          if (r.push(d), r.length === t.length) {
-            clearTimeout(a), l();
-            for (let f = 0; f < t.length; f++) {
-              const m = t[f], v = r[f];
-              if (JSON.stringify(m) !== JSON.stringify(v)) {
-                o(
-                  new Error(
-                    `State mismatch at index ${f}. Expected: ${JSON.stringify(m)}, Received: ${JSON.stringify(v)}`
-                  )
-                );
-                return;
-              }
-            }
-            n();
-          }
-        }
-      });
-    });
-  }
-}
-i(q, "originalInstance");
-class F extends j {
-  constructor(t) {
-    super(t);
-    i(this, "mockHandlers", /* @__PURE__ */ new Map());
-  }
-  /**
-   * Mock an event handler for testing
-   */
-  mockEventHandler(t, s) {
-    this.on(t, s);
-  }
-  /**
-   * Get the number of registered handlers
-   */
-  getHandlerCount() {
-    return this.eventHandlers.size;
-  }
-  /**
-   * Check if a handler is registered for an event type
-   */
-  hasHandler(t) {
-    return this.eventHandlers.has(t);
-  }
-}
-class G extends z {
-  constructor(t) {
-    super(t);
-    i(this, "stateHistory", []);
-    this.stateHistory.push(t);
-  }
-  /**
-   * Override emit to track state history
-   */
-  emit(t) {
-    this.stateHistory.push(t), super.emit(t);
-  }
-  /**
-   * Get the history of all states
-   */
-  getStateHistory() {
-    return [...this.stateHistory];
-  }
-  /**
-   * Clear state history
-   */
-  clearStateHistory() {
-    this.stateHistory = [this.state];
-  }
-}
-class J {
-  constructor() {
-    i(this, "initialStats");
-    this.initialStats = u.getMemoryStats();
-  }
-  /**
-   * Check for memory leaks and return a report
-   */
-  checkForLeaks() {
-    const e = u.getMemoryStats(), t = e.registeredBlocs > this.initialStats.registeredBlocs || e.isolatedBlocs > this.initialStats.isolatedBlocs || e.keepAliveBlocs > this.initialStats.keepAliveBlocs, s = `
-Memory Leak Detection Report:
-- Initial registered blocs: ${this.initialStats.registeredBlocs}
-- Current registered blocs: ${e.registeredBlocs}
-- Initial isolated blocs: ${this.initialStats.isolatedBlocs}  
-- Current isolated blocs: ${e.isolatedBlocs}
-- Initial keep-alive blocs: ${this.initialStats.keepAliveBlocs}
-- Current keep-alive blocs: ${e.keepAliveBlocs}
-- Potential leaks detected: ${t ? "YES" : "NO"}
-    `.trim();
-    return {
-      hasLeaks: t,
-      report: s,
-      stats: e
-    };
-  }
-}
-class K {
-  constructor() {
-    i(this, "consumers", /* @__PURE__ */ new WeakMap());
-    i(this, "registrationCount", 0);
-    i(this, "activeConsumers", 0);
-  }
-  register(e, t) {
-    this.registrationCount++, this.consumers.get(e) || this.activeConsumers++, this.consumers.set(e, {
-      id: t,
-      lastNotified: Date.now(),
-      hasRendered: !1,
-      stateAccesses: /* @__PURE__ */ new Set(),
-      classAccesses: /* @__PURE__ */ new Set(),
-      stateValues: /* @__PURE__ */ new Map(),
-      classValues: /* @__PURE__ */ new Map(),
-      accessCount: 0,
-      lastAccessTime: 0,
-      firstAccessTime: 0
-    });
-  }
-  unregister(e) {
-    e && this.consumers.get(e) && (this.consumers.delete(e), this.activeConsumers = Math.max(0, this.activeConsumers - 1));
-  }
-  trackAccess(e, t, s, r) {
-    const n = this.consumers.get(e);
-    if (!n) return;
-    const o = Date.now();
-    n.firstAccessTime || (n.firstAccessTime = o), n.accessCount++, n.lastAccessTime = o, t === "state" ? (n.stateAccesses.add(s), r !== void 0 && n.stateValues.set(s, { value: r, lastAccessTime: o })) : (n.classAccesses.add(s), r !== void 0 && n.classValues.set(s, { value: r, lastAccessTime: o }));
-  }
-  resetTracking(e) {
-    const t = this.consumers.get(e);
-    t && (t.stateAccesses.clear(), t.classAccesses.clear(), t.stateValues.clear(), t.classValues.clear(), t.accessCount = 0, t.firstAccessTime = 0);
-  }
-  getDependencies(e) {
-    const t = this.consumers.get(e);
-    return t ? {
-      statePaths: Array.from(t.stateAccesses),
-      classPaths: Array.from(t.classAccesses)
-    } : null;
-  }
-  hasValuesChanged(e, t, s) {
-    const r = this.consumers.get(e);
-    if (!r) return !0;
-    let n = !1;
-    const o = Date.now();
-    if (r.stateValues.size === 0 && r.classValues.size === 0 && (r.stateAccesses.size > 0 || r.classAccesses.size > 0))
-      return !0;
-    for (const [a, l] of r.stateValues)
-      try {
-        const d = this.getValueAtPath(t, a);
-        d !== l.value && (r.stateValues.set(a, {
-          value: d,
-          lastAccessTime: o
-        }), n = !0);
-      } catch {
-        n = !0;
-      }
-    for (const [a, l] of r.classValues)
-      try {
-        const d = this.getValueAtPath(s, a);
-        d !== l.value && (r.classValues.set(a, {
-          value: d,
-          lastAccessTime: o
-        }), n = !0);
-      } catch {
-        n = !0;
-      }
-    return n;
-  }
-  shouldNotifyConsumer(e, t) {
-    const s = this.consumers.get(e);
-    if (!s) return !1;
-    for (const r of t) {
-      if (s.stateAccesses.has(r) || s.classAccesses.has(r)) return !0;
-      for (const n of s.stateAccesses)
-        if (r.startsWith(n + ".") || n.startsWith(r + "."))
-          return !0;
-    }
-    return !1;
-  }
-  updateLastNotified(e) {
-    const t = this.consumers.get(e);
-    t && (t.lastNotified = Date.now());
-  }
-  getConsumerInfo(e) {
-    return this.consumers.get(e);
-  }
-  setHasRendered(e, t) {
-    const s = this.consumers.get(e);
-    s && (s.hasRendered = t);
-  }
-  hasConsumer(e) {
-    return this.consumers.has(e);
-  }
-  getStats() {
-    return {
-      totalRegistrations: this.registrationCount,
-      activeConsumers: this.activeConsumers
-    };
-  }
-  getValueAtPath(e, t) {
-    const s = t.split(".");
-    let r = e;
-    for (const n of s) {
-      if (r == null) return;
-      r = r[n];
-    }
-    return r;
-  }
-}
-const x = /* @__PURE__ */ new WeakMap();
-let p = {
-  stateProxiesCreated: 0,
-  classProxiesCreated: 0,
-  cacheHits: 0,
-  cacheMisses: 0,
-  propertyAccesses: 0,
-  nestedProxiesCreated: 0,
-  totalProxiesCreated: 0,
-  createdAt: Date.now()
-};
-class I {
-  static createStateProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: r, path: n = "" } = e;
-    if (!s || !r || typeof t != "object" || t === null)
-      return t;
-    let o = x.get(t);
-    o || (o = /* @__PURE__ */ new WeakMap(), x.set(t, o));
-    const a = o.get(s);
-    if (a)
-      return p.cacheHits++, a;
-    p.cacheMisses++;
-    const l = {
-      get(f, m) {
-        if (typeof m == "symbol" || m === "constructor")
-          return Reflect.get(f, m);
-        const v = n ? `${n}.${m}` : m;
-        p.propertyAccesses++;
-        const g = Reflect.get(f, m), B = g && typeof g === "object" && g !== null ? void 0 : g;
-        if (r.trackAccess(s, "state", v, B), g && typeof g == "object" && g !== null) {
-          const w = Object.getPrototypeOf(g) === Object.prototype, T = Array.isArray(g);
-          if (w || T)
-            return p.nestedProxiesCreated++, I.createStateProxy({
-              target: g,
-              consumerRef: s,
-              consumerTracker: r,
-              path: v
-            });
-        }
-        return g;
-      },
-      has(f, m) {
-        return m in f;
-      },
-      ownKeys(f) {
-        return Reflect.ownKeys(f);
-      },
-      getOwnPropertyDescriptor(f, m) {
-        return Reflect.getOwnPropertyDescriptor(f, m);
-      },
-      set() {
-        return !1;
-      },
-      deleteProperty() {
-        return !1;
-      }
-    }, d = new Proxy(t, l);
-    return o.set(s, d), p.stateProxiesCreated++, p.totalProxiesCreated++, d;
-  }
-  static createClassProxy(e) {
-    const { target: t, consumerRef: s, consumerTracker: r } = e;
-    if (!s || !r)
-      return t;
-    let n = x.get(t);
-    n || (n = /* @__PURE__ */ new WeakMap(), x.set(t, n));
-    const o = n.get(s);
-    if (o)
-      return p.cacheHits++, o;
-    p.cacheMisses++;
-    const a = {
-      get(d, f) {
-        const m = Reflect.get(d, f);
-        let v = !1, g = d;
-        const A = /* @__PURE__ */ new WeakSet(), P = 10;
-        let B = 0;
-        for (; g && !v && B < P && !A.has(g); ) {
-          A.add(g);
-          try {
-            const C = Object.getOwnPropertyDescriptor(
-              g,
-              f
-            );
-            if (C && C.get) {
-              v = !0;
-              break;
-            }
-            g = Object.getPrototypeOf(g), B++;
-          } catch {
-            break;
-          }
-        }
-        if (!v)
-          return m;
-        p.propertyAccesses++;
-        const w = m, M = w !== null && typeof w != "object" ? w : void 0;
-        return r.trackAccess(
-          s,
-          "class",
-          String(f),
-          M
-        ), m;
-      },
-      has(d, f) {
-        return f in d;
-      },
-      ownKeys(d) {
-        return Reflect.ownKeys(d);
-      },
-      getOwnPropertyDescriptor(d, f) {
-        return Reflect.getOwnPropertyDescriptor(d, f);
-      }
-    }, l = new Proxy(t, a);
-    return n.set(s, l), p.classProxiesCreated++, p.totalProxiesCreated++, l;
-  }
-  static getProxyState(e) {
-    return I.createStateProxy({
-      target: e.state,
-      consumerRef: e.consumerRef,
-      consumerTracker: e.consumerTracker
-    });
-  }
-  static getProxyBlocInstance(e) {
-    return I.createClassProxy({
-      target: e.blocInstance,
-      consumerRef: e.consumerRef,
-      consumerTracker: e.consumerTracker
-    });
-  }
-  static getStats() {
-    const e = Date.now() - p.createdAt;
-    return {
-      ...p,
-      totalProxies: p.stateProxiesCreated + p.classProxiesCreated,
-      cacheEfficiency: p.cacheHits + p.cacheMisses > 0 ? `${(p.cacheHits / (p.cacheHits + p.cacheMisses) * 100).toFixed(1)}%` : "N/A",
-      lifetime: `${e}ms`,
-      proxiesPerSecond: e > 0 ? (p.totalProxiesCreated / (e / 1e3)).toFixed(2) : "N/A"
-    };
-  }
-  static resetStats() {
-    p = {
-      stateProxiesCreated: 0,
-      classProxiesCreated: 0,
-      cacheHits: 0,
-      cacheMisses: 0,
-      propertyAccesses: 0,
-      nestedProxiesCreated: 0,
-      totalProxiesCreated: 0,
-      createdAt: Date.now()
-    };
-  }
-}
-const b = class b {
-  constructor(e, t) {
-    i(this, "id", `consumer-${$()}`);
-    i(this, "blocConstructor");
-    i(this, "componentRef", { current: {} });
-    i(this, "blocInstance");
-    // Core components
-    i(this, "consumerTracker");
-    i(this, "lastProps");
-    i(this, "unmountTime", 0);
-    i(this, "mountTime", 0);
-    // Dependency tracking
-    i(this, "dependencyValues");
-    i(this, "isUsingDependencies", !1);
-    // Lifecycle state
-    i(this, "hasMounted", !1);
-    i(this, "mountCount", 0);
-    i(this, "options");
-    i(this, "createStateProxy", (e) => I.createStateProxy({
-      target: e.target,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this
-    }));
-    i(this, "createClassProxy", (e) => I.createClassProxy({
-      target: e.target,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this
-    }));
-    i(this, "createSubscription", (e) => this.blocInstance._observer.subscribe({
-      id: this.id,
-      fn: (s, r) => {
-        var n;
-        if (this.isUsingDependencies && ((n = this.options) != null && n.dependencies)) {
-          const o = this.options.dependencies(this.blocInstance);
-          if (!this.hasDependencyValuesChanged(
-            this.dependencyValues,
-            o
-          ))
-            return;
-          this.dependencyValues = o;
-        } else if (u.config.proxyDependencyTracking) {
-          const o = this.consumerTracker.getConsumerInfo(
-            this.componentRef.current
-          );
-          if (o && o.hasRendered && !this.consumerTracker.hasValuesChanged(
-            this.componentRef.current,
-            s,
-            this.blocInstance
-          ))
-            return;
-        } else {
-          e.onChange();
-          return;
-        }
-        e.onChange();
-      }
-    }));
-    i(this, "mount", () => {
-      var e, t;
-      if (this.isUsingDependencies && ((e = this.options) != null && e.dependencies) && (this.dependencyValues = this.options.dependencies(this.blocInstance)), this.mountCount++, this.blocInstance._addConsumer(this.id, this.componentRef.current), !this.hasMounted && (this.hasMounted = !0, this.mountTime = Date.now(), (t = this.options) != null && t.onMount))
-        try {
-          this.options.onMount(this.blocInstance);
-        } catch (s) {
-          throw s;
-        }
-    });
-    i(this, "unmount", () => {
-      var e;
-      if (this.unmountTime = Date.now(), this.consumerTracker.unregister(this.componentRef.current), this.blocInstance._removeConsumer(this.id), b.propsOwners.get(this.blocInstance) === this.id && b.propsOwners.delete(this.blocInstance), (e = this.options) != null && e.onUnmount)
-        try {
-          this.options.onUnmount(this.blocInstance);
-        } catch {
-        }
-    });
-    i(this, "getProxyState", (e) => this.isUsingDependencies || !u.config.proxyDependencyTracking ? e : I.getProxyState({
-      state: e,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this
-    }));
-    i(this, "getProxyBlocInstance", () => this.isUsingDependencies || !u.config.proxyDependencyTracking ? this.blocInstance : I.getProxyBlocInstance({
-      blocInstance: this.blocInstance,
-      consumerRef: this.componentRef.current,
-      consumerTracker: this
-    }));
-    this.options = t, this.blocConstructor = e.blocConstructor, this.componentRef = e.componentRef, this.isUsingDependencies = !!(t != null && t.dependencies), this.consumerTracker = new K(), this.blocInstance = this.updateBlocInstance(), this.consumerTracker.register(e.componentRef.current, this.id), this.isUsingDependencies && (t != null && t.dependencies) && (this.dependencyValues = t.dependencies(this.blocInstance)), (t == null ? void 0 : t.props) !== void 0 && this.updateProps(t.props);
-  }
-  trackAccess(e, t, s, r) {
-    this.consumerTracker.trackAccess(e, t, s, r);
-  }
-  getConsumerDependencies(e) {
-    return this.consumerTracker.getDependencies(e);
-  }
-  shouldNotifyConsumer(e, t) {
-    const s = this.consumerTracker.getConsumerInfo(e);
-    return !s || !s.hasRendered ? !0 : this.consumerTracker.shouldNotifyConsumer(e, t);
-  }
-  updateLastNotified(e) {
-    this.consumerTracker.updateLastNotified(e), this.consumerTracker.setHasRendered(e, !0);
-  }
-  resetConsumerTracking() {
-    this.consumerTracker.resetTracking(this.componentRef.current);
-  }
-  updateBlocInstance() {
-    var e, t;
-    return this.blocInstance = u.instance.getBloc(this.blocConstructor, {
-      props: (e = this.options) == null ? void 0 : e.props,
-      id: (t = this.options) == null ? void 0 : t.id,
-      instanceRef: this.id
-    }), this.blocInstance;
-  }
-  // Expose calledOnMount for backward compatibility
-  get calledOnMount() {
-    return this.hasMounted;
-  }
-  updateProps(e) {
-    const t = this.blocInstance;
-    if (b.propsOwners.has(t) || b.propsOwners.set(t, this.id), b.propsOwners.get(t) !== this.id) {
-      u.warn(
-        `[BlacAdapter] Attempted to set props on ${t.constructor.name} from non-owner adapter`
-      );
-      return;
-    }
-    t._disposalState === y.DISPOSED || t._disposalState === y.DISPOSING || N(this.lastProps, e) || ("add" in t && typeof t.add == "function" ? t.add(new L(e)) : "_updateProps" in t && typeof t._updateProps == "function" && t._updateProps(e), this.lastProps = e);
-  }
-  hasDependencyValuesChanged(e, t) {
-    if (!e || e.length !== t.length) return !0;
-    for (let s = 0; s < e.length; s++)
-      if (!Object.is(e[s], t[s]))
-        return !0;
-    return !1;
-  }
-};
-// Props ownership tracking
-i(b, "propsOwners", /* @__PURE__ */ new WeakMap());
-let D = b;
-export {
-  u as Blac,
-  D as BlacAdapter,
-  H as BlacObservable,
-  j as Bloc,
-  k as BlocBase,
-  y as BlocLifecycleState,
-  V as BlocPluginRegistry,
-  q as BlocTest,
-  K as ConsumerTracker,
-  z as Cubit,
-  J as MemoryLeakDetector,
-  F as MockBloc,
-  G as MockCubit,
-  L as PropsUpdated,
-  I as ProxyFactory,
-  U as SystemPluginRegistry,
-  $ as generateUUID,
-  W as setBlacInstanceManager,
-  N as shallowEqual
-};
-//# sourceMappingURL=index.es.js.map