@blac/core 2.0.13 → 2.0.14

package/dist/Cubit-CXxh9iol.js

@@ -1,260 +1,302 @@
-import { c as BLAC_DEFAULTS } from "./StateContainerRegistry-BK57H92E.js";
-import { t as getRegistry } from "./config-ispAzOZV.js";
+import { c as BLAC_DEFAULTS } from './StateContainerRegistry-BK57H92E.js';
+import { t as getRegistry } from './config-ispAzOZV.js';
 //#region src/utils/idGenerator.ts
 /**
-* Generate simple ID with timestamp and random (no counter tracking)
-*
-* Format: `${prefix}:${timestamp}_${random}`
-*
-* @param prefix - Prefix for the ID
-* @returns Branded ID string
-*
-* @example
-* ```ts
-* const id = generateSimpleId('CounterBloc');
-* // Returns: "CounterBloc:1698765432100_a3k9d7f2q"
-* ```
-*/
+ * Generate simple ID with timestamp and random (no counter tracking)
+ *
+ * Format: `${prefix}:${timestamp}_${random}`
+ *
+ * @param prefix - Prefix for the ID
+ * @returns Branded ID string
+ *
+ * @example
+ * ```ts
+ * const id = generateSimpleId('CounterBloc');
+ * // Returns: "CounterBloc:1698765432100_a3k9d7f2q"
+ * ```
+ */
 function generateSimpleId(prefix, affix) {
-	if (affix) return `${prefix}:${affix}`;
-	return `${prefix}:${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  if (affix) return `${prefix}:${affix}`;
+  return `${prefix}:${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 }
 //#endregion
 //#region src/core/symbols.ts
-const EMIT = Symbol("blac.emit");
+const EMIT = Symbol('blac.emit');
 //#endregion
 //#region src/core/StateContainer.ts
 const EMPTY_DEPS = /* @__PURE__ */ new Map();
 var StateContainer = class {
-	static {
-		this.__excludeFromDevTools = false;
-	}
-	get dependencies() {
-		return this._dependencies ?? EMPTY_DEPS;
-	}
-	depend(Type, instanceKey) {
-		if (!this._dependencies) this._dependencies = /* @__PURE__ */ new Map();
-		this._dependencies.set(Type, instanceKey ?? BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
-		return () => this._registry.ensure(Type, instanceKey);
-	}
-	constructor(initialState) {
-		this._listeners = /* @__PURE__ */ new Set();
-		this._disposed = false;
-		this._hydrationStatus = "idle";
-		this._changedWhileHydrating = false;
-		this._hydrationPromise = null;
-		this._hydrationPromiseSettled = false;
-		this._config = {};
-		this._systemEventHandlers = /* @__PURE__ */ new Map();
-		this._dependencies = null;
-		this._hasStateChangeHandlers = false;
-		this._registry = getRegistry();
-		this.name = this.constructor.name;
-		this.debug = false;
-		this.instanceId = generateSimpleId(this.constructor.name, "main");
-		this.createdAt = Date.now();
-		this.onSystemEvent = (event, handler) => {
-			let handlers = this._systemEventHandlers.get(event);
-			if (!handlers) {
-				handlers = /* @__PURE__ */ new Set();
-				this._systemEventHandlers.set(event, handlers);
-			}
-			handlers.add(handler);
-			if (event === "stateChanged") this._hasStateChangeHandlers = true;
-			return () => {
-				handlers?.delete(handler);
-				if (event === "stateChanged" && handlers?.size === 0) this._hasStateChangeHandlers = false;
-			};
-		};
-		this._state = initialState;
-	}
-	initConfig(config) {
-		this._config = { ...config };
-		this.name = this._config.name || this.constructor.name;
-		this.debug = this._config.debug ?? false;
-		this.instanceId = generateSimpleId(this.constructor.name, this._config.instanceId);
-		this._registry.emit("created", this);
-	}
-	get state() {
-		return this._state;
-	}
-	get isDisposed() {
-		return this._disposed;
-	}
-	get hydrationStatus() {
-		return this._hydrationStatus;
-	}
-	get hydrationError() {
-		return this._hydrationError;
-	}
-	get isHydrated() {
-		return this._hydrationStatus === "hydrated";
-	}
-	get changedWhileHydrating() {
-		return this._changedWhileHydrating;
-	}
-	subscribe(listener) {
-		if (this._disposed) throw new Error(`Cannot subscribe to disposed container ${this.name}`);
-		this._listeners.add(listener);
-		return () => this._listeners.delete(listener);
-	}
-	dispose() {
-		if (this._disposed) return;
-		if (this.debug) console.log(`[${this.name}] Disposing...`);
-		this._disposed = true;
-		if (this._hydrationStatus === "hydrating") this.failHydration(/* @__PURE__ */ new Error(`Hydration cancelled because ${this.name} was disposed`));
-		this.emitSystemEvent("dispose", void 0);
-		this._listeners.clear();
-		this._systemEventHandlers.clear();
-		this._registry.emit("disposed", this);
-		if (this.debug) console.log(`[${this.name}] Disposed successfully`);
-	}
-	[EMIT](newState) {
-		this.applyState(newState, "default");
-	}
-	emit(newState) {
-		this[EMIT](newState);
-	}
-	beginHydration() {
-		if (this._disposed) throw new Error(`Cannot begin hydration for disposed container ${this.name}`);
-		this._changedWhileHydrating = false;
-		this._hydrationError = void 0;
-		this._hydrationPromise = null;
-		this._resolveHydrationPromise = void 0;
-		this._rejectHydrationPromise = void 0;
-		this._hydrationPromiseSettled = false;
-		this.ensureHydrationPromise();
-		this.setHydrationStatus("hydrating");
-	}
-	applyHydratedState(newState) {
-		if (this._disposed) return false;
-		if (this._hydrationStatus !== "hydrating" || this._changedWhileHydrating) return false;
-		this.applyState(newState, "hydration");
-		return true;
-	}
-	finishHydration() {
-		if (this._hydrationStatus !== "hydrating") {
-			if (this._hydrationStatus === "hydrated") return;
-			if (this._hydrationStatus === "error") this.ensureHydrationPromise();
-		}
-		this.setHydrationStatus("hydrated");
-		this.resolveHydration();
-	}
-	failHydration(error) {
-		const err = error instanceof Error ? error : /* @__PURE__ */ new Error(`Hydration failed: ${String(error)}`);
-		this._hydrationError = err;
-		this.setHydrationStatus("error", err);
-		this.rejectHydration(err);
-	}
-	waitForHydration() {
-		if (this._hydrationStatus === "idle" || this._hydrationStatus === "hydrated") return Promise.resolve();
-		if (this._hydrationStatus === "error") return Promise.reject(this._hydrationError ?? /* @__PURE__ */ new Error(`Hydration failed for container ${this.name}`));
-		return this.ensureHydrationPromise();
-	}
-	applyState(newState, source) {
-		if (this._disposed) throw new Error(`Cannot emit state from disposed container ${this.name}`);
-		if (this._state === newState) return;
-		const previousState = this._state;
-		this._state = newState;
-		if (this._listeners.size === 0 && !this._hasStateChangeHandlers && this._hydrationStatus !== "hydrating") {
-			if (this._registry.hasStateChangedListeners) this._registry.notifyStateChanged(this, previousState, newState);
-			return;
-		}
-		if (this._hydrationStatus === "hydrating" && source !== "hydration") this._changedWhileHydrating = true;
-		if (this._hasStateChangeHandlers) {
-			const handlers = this._systemEventHandlers.get("stateChanged");
-			const payload = {
-				state: newState,
-				previousState
-			};
-			for (const handler of handlers) try {
-				handler(payload);
-			} catch (error) {
-				console.error(`[${this.name}] Error in system event handler:`, error);
-			}
-		}
-		if (this._listeners.size > 0) {
-			let count = 0;
-			const size = this._listeners.size;
-			for (const listener of this._listeners) {
-				if (++count > size) break;
-				try {
-					listener(newState);
-				} catch (error) {
-					console.error(`[${this.name}] Error in listener:`, error);
-				}
-			}
-		}
-		if (this._registry.hasStateChangedListeners) this._registry.notifyStateChanged(this, previousState, newState);
-	}
-	setHydrationStatus(status, error) {
-		const previousStatus = this._hydrationStatus;
-		this._hydrationStatus = status;
-		this._hydrationError = error;
-		this.emitSystemEvent("hydrationChanged", {
-			status,
-			previousStatus,
-			error,
-			changedWhileHydrating: this._changedWhileHydrating
-		});
-	}
-	ensureHydrationPromise() {
-		if (!this._hydrationPromise || this._hydrationPromiseSettled) {
-			this._hydrationPromiseSettled = false;
-			this._hydrationPromise = new Promise((resolve, reject) => {
-				this._resolveHydrationPromise = () => {
-					if (this._hydrationPromiseSettled) return;
-					this._hydrationPromiseSettled = true;
-					resolve();
-				};
-				this._rejectHydrationPromise = (error) => {
-					if (this._hydrationPromiseSettled) return;
-					this._hydrationPromiseSettled = true;
-					reject(error);
-				};
-			});
-			this._hydrationPromise.catch(() => {});
-		}
-		return this._hydrationPromise;
-	}
-	resolveHydration() {
-		this._resolveHydrationPromise?.();
-	}
-	rejectHydration(error) {
-		this.ensureHydrationPromise();
-		this._rejectHydrationPromise?.(error);
-	}
-	emitSystemEvent(event, payload) {
-		const handlers = this._systemEventHandlers.get(event);
-		if (!handlers) return;
-		for (const handler of handlers) try {
-			handler(payload);
-		} catch (error) {
-			console.error(`[${this.name}] Error in system event handler:`, error);
-		}
-	}
+  static {
+    this.__excludeFromDevTools = false;
+  }
+  get dependencies() {
+    return this._dependencies ?? EMPTY_DEPS;
+  }
+  depend(Type, instanceKey) {
+    if (!this._dependencies) this._dependencies = /* @__PURE__ */ new Map();
+    this._dependencies.set(
+      Type,
+      instanceKey ?? BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY,
+    );
+    return () => this._registry.ensure(Type, instanceKey);
+  }
+  constructor(initialState) {
+    this._listeners = /* @__PURE__ */ new Set();
+    this._disposed = false;
+    this._hydrationStatus = 'idle';
+    this._changedWhileHydrating = false;
+    this._hydrationPromise = null;
+    this._hydrationPromiseSettled = false;
+    this._config = {};
+    this._systemEventHandlers = /* @__PURE__ */ new Map();
+    this._dependencies = null;
+    this._hasStateChangeHandlers = false;
+    this._registry = getRegistry();
+    this.name = this.constructor.name;
+    this.debug = false;
+    this.instanceId = generateSimpleId(this.constructor.name, 'main');
+    this.createdAt = Date.now();
+    this.onSystemEvent = (event, handler) => {
+      let handlers = this._systemEventHandlers.get(event);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        this._systemEventHandlers.set(event, handlers);
+      }
+      handlers.add(handler);
+      if (event === 'stateChanged') this._hasStateChangeHandlers = true;
+      return () => {
+        handlers?.delete(handler);
+        if (event === 'stateChanged' && handlers?.size === 0)
+          this._hasStateChangeHandlers = false;
+      };
+    };
+    this._state = initialState;
+  }
+  initConfig(config) {
+    this._config = { ...config };
+    this.name = this._config.name || this.constructor.name;
+    this.debug = this._config.debug ?? false;
+    this.instanceId = generateSimpleId(
+      this.constructor.name,
+      this._config.instanceId,
+    );
+    this._registry.emit('created', this);
+  }
+  get state() {
+    return this._state;
+  }
+  get isDisposed() {
+    return this._disposed;
+  }
+  get hydrationStatus() {
+    return this._hydrationStatus;
+  }
+  get hydrationError() {
+    return this._hydrationError;
+  }
+  get isHydrated() {
+    return this._hydrationStatus === 'hydrated';
+  }
+  get changedWhileHydrating() {
+    return this._changedWhileHydrating;
+  }
+  subscribe(listener) {
+    if (this._disposed)
+      throw new Error(`Cannot subscribe to disposed container ${this.name}`);
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  dispose() {
+    if (this._disposed) return;
+    if (this.debug) console.log(`[${this.name}] Disposing...`);
+    this._disposed = true;
+    if (this._hydrationStatus === 'hydrating')
+      this.failHydration(
+        /* @__PURE__ */ new Error(
+          `Hydration cancelled because ${this.name} was disposed`,
+        ),
+      );
+    this.emitSystemEvent('dispose', void 0);
+    this._listeners.clear();
+    this._systemEventHandlers.clear();
+    this._registry.emit('disposed', this);
+    if (this.debug) console.log(`[${this.name}] Disposed successfully`);
+  }
+  [EMIT](newState) {
+    this.applyState(newState, 'default');
+  }
+  emit(newState) {
+    this[EMIT](newState);
+  }
+  beginHydration() {
+    if (this._disposed)
+      throw new Error(
+        `Cannot begin hydration for disposed container ${this.name}`,
+      );
+    this._changedWhileHydrating = false;
+    this._hydrationError = void 0;
+    this._hydrationPromise = null;
+    this._resolveHydrationPromise = void 0;
+    this._rejectHydrationPromise = void 0;
+    this._hydrationPromiseSettled = false;
+    this.ensureHydrationPromise();
+    this.setHydrationStatus('hydrating');
+  }
+  applyHydratedState(newState) {
+    if (this._disposed) return false;
+    if (this._hydrationStatus !== 'hydrating' || this._changedWhileHydrating)
+      return false;
+    this.applyState(newState, 'hydration');
+    return true;
+  }
+  finishHydration() {
+    if (this._hydrationStatus !== 'hydrating') {
+      if (this._hydrationStatus === 'hydrated') return;
+      if (this._hydrationStatus === 'error') this.ensureHydrationPromise();
+    }
+    this.setHydrationStatus('hydrated');
+    this.resolveHydration();
+  }
+  failHydration(error) {
+    const err =
+      error instanceof Error
+        ? error
+        : /* @__PURE__ */ new Error(`Hydration failed: ${String(error)}`);
+    this._hydrationError = err;
+    this.setHydrationStatus('error', err);
+    this.rejectHydration(err);
+  }
+  waitForHydration() {
+    if (
+      this._hydrationStatus === 'idle' ||
+      this._hydrationStatus === 'hydrated'
+    )
+      return Promise.resolve();
+    if (this._hydrationStatus === 'error')
+      return Promise.reject(
+        this._hydrationError ??
+          /* @__PURE__ */ new Error(
+            `Hydration failed for container ${this.name}`,
+          ),
+      );
+    return this.ensureHydrationPromise();
+  }
+  applyState(newState, source) {
+    if (this._disposed)
+      throw new Error(`Cannot emit state from disposed container ${this.name}`);
+    if (this._state === newState) return;
+    const previousState = this._state;
+    this._state = newState;
+    if (
+      this._listeners.size === 0 &&
+      !this._hasStateChangeHandlers &&
+      this._hydrationStatus !== 'hydrating'
+    ) {
+      if (this._registry.hasStateChangedListeners)
+        this._registry.notifyStateChanged(this, previousState, newState);
+      return;
+    }
+    if (this._hydrationStatus === 'hydrating' && source !== 'hydration')
+      this._changedWhileHydrating = true;
+    if (this._hasStateChangeHandlers) {
+      const handlers = this._systemEventHandlers.get('stateChanged');
+      const payload = {
+        state: newState,
+        previousState,
+      };
+      for (const handler of handlers)
+        try {
+          handler(payload);
+        } catch (error) {
+          console.error(`[${this.name}] Error in system event handler:`, error);
+        }
+    }
+    if (this._listeners.size > 0) {
+      let count = 0;
+      const size = this._listeners.size;
+      for (const listener of this._listeners) {
+        if (++count > size) break;
+        try {
+          listener(newState);
+        } catch (error) {
+          console.error(`[${this.name}] Error in listener:`, error);
+        }
+      }
+    }
+    if (this._registry.hasStateChangedListeners)
+      this._registry.notifyStateChanged(this, previousState, newState);
+  }
+  setHydrationStatus(status, error) {
+    const previousStatus = this._hydrationStatus;
+    this._hydrationStatus = status;
+    this._hydrationError = error;
+    this.emitSystemEvent('hydrationChanged', {
+      status,
+      previousStatus,
+      error,
+      changedWhileHydrating: this._changedWhileHydrating,
+    });
+  }
+  ensureHydrationPromise() {
+    if (!this._hydrationPromise || this._hydrationPromiseSettled) {
+      this._hydrationPromiseSettled = false;
+      this._hydrationPromise = new Promise((resolve, reject) => {
+        this._resolveHydrationPromise = () => {
+          if (this._hydrationPromiseSettled) return;
+          this._hydrationPromiseSettled = true;
+          resolve();
+        };
+        this._rejectHydrationPromise = (error) => {
+          if (this._hydrationPromiseSettled) return;
+          this._hydrationPromiseSettled = true;
+          reject(error);
+        };
+      });
+      this._hydrationPromise.catch(() => {});
+    }
+    return this._hydrationPromise;
+  }
+  resolveHydration() {
+    this._resolveHydrationPromise?.();
+  }
+  rejectHydration(error) {
+    this.ensureHydrationPromise();
+    this._rejectHydrationPromise?.(error);
+  }
+  emitSystemEvent(event, payload) {
+    const handlers = this._systemEventHandlers.get(event);
+    if (!handlers) return;
+    for (const handler of handlers)
+      try {
+        handler(payload);
+      } catch (error) {
+        console.error(`[${this.name}] Error in system event handler:`, error);
+      }
+  }
 };
 //#endregion
 //#region src/core/Cubit.ts
 var Cubit = class extends StateContainer {
-	constructor(initialState) {
-		super(initialState);
-		this.patch = ((partial) => {
-			if (typeof this.state !== "object" || this.state === null) throw new Error("patch() is only available for object state types");
-			for (const key of Object.keys(partial)) if (!Object.is(this.state[key], partial[key])) {
-				this[EMIT]({
-					...this.state,
-					...partial
-				});
-				return;
-			}
-		});
-	}
-	emit(newState) {
-		this[EMIT](newState);
-	}
+  constructor(initialState) {
+    super(initialState);
+    this.patch = (partial) => {
+      if (typeof this.state !== 'object' || this.state === null)
+        throw new Error('patch() is only available for object state types');
+      for (const key of Object.keys(partial))
+        if (!Object.is(this.state[key], partial[key])) {
+          this[EMIT]({
+            ...this.state,
+            ...partial,
+          });
+          return;
+        }
+    };
+  }
+  emit(newState) {
+    this[EMIT](newState);
+  }
 };
 //#endregion
 export { StateContainer as n, EMIT as r, Cubit as t };
 
-//# sourceMappingURL=Cubit-CXxh9iol.js.map
+//# sourceMappingURL=Cubit-CXxh9iol.js.map