@blac/core 2.0.0-rc.14 → 2.0.0-rc.16

package/dist/index.cjs

@@ -834,7 +834,9 @@ var StateContainerRegistry = class {
 	*/
 	on(event, listener) {
 		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
-		this.listeners.get(event).add(listener);
+		const instance = this.listeners.get(event);
+		if (!instance) throw new Error(`${BLAC_ERROR_PREFIX} Failed to register listener for event '${event}'`);
+		instance.add(listener);
 		return () => {
 			this.listeners.get(event)?.delete(listener);
 		};
@@ -881,12 +883,12 @@ function getPluginManager() {
 *
 * @example
 * ```ts
-* class CounterBloc extends StateContainer<number> {
+* class CounterBloc extends StateContainer<{ count: number }> {
 *   constructor() {
-*     super(0);
+*     super({ count: 0 });
 *   }
 *   increment() {
-*     this.emit(this.state + 1);
+*     this.emit({ count: this.state.count + 1 });
 *   }
 * }
 * ```
@@ -1236,33 +1238,70 @@ var Cubit = class extends StateContainer {
 //#endregion
 //#region src/core/Vertex.ts
 /**
-* Event-driven state container that processes events to update state.
-* Use with event handlers registered via the on() method.
+* Event-driven state container using discriminated union events.
+* Extends StateContainer with event-based state transitions and
+* compile-time exhaustive checking for event handlers.
 *
-* @template S - State type
-* @template E - Event type (extends BaseEvent)
+* @template S - State type (must be an object)
+* @template E - Event union type (discriminated by 'type' property)
 * @template P - Props type (optional)
+*
+* @example
+* ```typescript
+* type CounterEvent =
+*   | { type: 'increment'; amount: number }
+*   | { type: 'decrement' }
+*   | { type: 'reset' };
+*
+* class CounterVertex extends Vertex<{ count: number }, CounterEvent> {
+*   constructor() {
+*     super({ count: 0 });
+*     this.createHandlers({
+*       increment: (event, emit) => {
+*         emit({ count: this.state.count + event.amount });
+*       },
+*       decrement: (_, emit) => {
+*         emit({ count: this.state.count - 1 });
+*       },
+*       reset: (_, emit) => {
+*         emit({ count: 0 });
+*       },
+*     });
+*   }
+*
+*   increment = (amount = 1) => this.add({ type: 'increment', amount });
+* }
+* ```
 */
 var Vertex = class extends StateContainer {
 	constructor(initialState) {
 		super(initialState);
-		this.eventHandlers = /* @__PURE__ */ new Map();
+		this.handlers = /* @__PURE__ */ new Map();
 		this.isProcessing = false;
 		this.eventQueue = [];
-		this.on = (EventClass, handler) => {
-			const className = EventClass.name;
-			const registrations = this.eventHandlers.get(className) || [];
-			registrations.push({
-				eventClass: EventClass,
-				handler
-			});
-			this.eventHandlers.set(className, registrations);
-		};
 		this.add = (event) => {
-			StateContainer._registry.emit("eventAdded", this, event);
-			this.processEvent(event);
+			const enrichedEvent = this.enrichEvent(event);
+			StateContainer._registry.emit("eventAdded", this, enrichedEvent);
+			this.processEvent(enrichedEvent);
+		};
+	}
+	/**
+	* Register all event handlers with exhaustive type checking.
+	* TypeScript will error if any event type from the union is missing.
+	*
+	* @param handlers - Map of event type to handler function
+	*/
+	createHandlers(handlers) {
+		for (const [eventType, handler] of Object.entries(handlers)) this.handlers.set(eventType, handler);
+	}
+	/** @internal */
+	enrichEvent(event) {
+		return {
+			...event,
+			timestamp: Date.now()
 		};
 	}
+	/** @internal */
 	processEvent(event) {
 		if (this.isProcessing) {
 			this.eventQueue.push(event);
@@ -1279,26 +1318,27 @@ var Vertex = class extends StateContainer {
 			this.isProcessing = false;
 		}
 	}
+	/** @internal */
 	handleEvent(event) {
-		const className = event.constructor.name;
-		const registrations = this.eventHandlers.get(className);
-		if (!registrations || registrations.length === 0) {
-			if (this.debug) console.warn(`No handler registered for event: ${className}`);
+		const handler = this.handlers.get(event.type);
+		if (!handler) {
+			if (this.debug) console.warn(`No handler registered for event type: ${event.type}`);
 			return;
 		}
 		const emitFn = (state) => {
 			this.emit(state);
 		};
-		for (const registration of registrations) try {
-			registration.handler(event, emitFn);
+		try {
+			handler(event, emitFn);
 		} catch (error$1) {
-			if (this.debug) console.error(`Error handling event ${className}:`, error$1);
+			if (this.debug) console.error(`Error handling event ${event.type}:`, error$1);
 			this.onEventError(event, error$1);
 		}
 	}
 	/**
-	* Handle errors that occur during event processing.
-	* Override this method to implement custom error handling.
+	* Called when an error occurs during event processing.
+	* Override to implement custom error handling.
+	*
 	* @param _event - The event that caused the error
 	* @param _error - The error that occurred
 	*/
@@ -2036,6 +2076,67 @@ function configureLogger(opts) {
 	defaultLogger = createLogger(currentConfig);
 }
 
+//#endregion
+//#region src/config.ts
+const defaultConfig = {
+	devMode: process.env.NODE_ENV !== "production",
+	logger: {
+		enabled: false,
+		level: LogLevel.INFO
+	}
+};
+let globalConfig = { ...defaultConfig };
+/**
+* Configure global defaults for @blac/core.
+*
+* @example
+* ```ts
+* import { configureBlac, LogLevel } from '@blac/core';
+*
+* configureBlac({
+*   devMode: true,
+*   logger: {
+*     enabled: true,
+*     level: LogLevel.DEBUG
+*   }
+* });
+* ```
+*
+* @param config - Partial configuration to merge with defaults
+*/
+function configureBlac(config) {
+	globalConfig = {
+		...globalConfig,
+		...config,
+		logger: {
+			...globalConfig.logger,
+			...config.logger
+		}
+	};
+	if (config.logger) configureLogger(config.logger);
+}
+/**
+* Get the current global configuration.
+* @internal
+*/
+function getBlacConfig() {
+	return globalConfig;
+}
+/**
+* Check if development mode is enabled.
+*/
+function isDevMode() {
+	return globalConfig.devMode;
+}
+/**
+* Reset configuration to defaults (useful for testing).
+* @internal
+*/
+function resetBlacConfig() {
+	globalConfig = { ...defaultConfig };
+	configureLogger(defaultConfig.logger);
+}
+
 //#endregion
 //#region src/decorators/blac.ts
 /**
@@ -2087,6 +2188,7 @@ exports.captureTrackedPaths = captureTrackedPaths;
 exports.clearActiveTracker = clearActiveTracker;
 exports.clearExternalDependencies = clearExternalDependencies;
 exports.commitTrackedGetters = commitTrackedGetters;
+exports.configureBlac = configureBlac;
 exports.configureLogger = configureLogger;
 exports.createArrayProxy = createArrayProxy;
 exports.createAutoTrackSnapshot = createAutoTrackSnapshot;
@@ -2112,6 +2214,7 @@ exports.generateId = generateId;
 exports.generateIsolatedKey = generateIsolatedKey;
 exports.generateSimpleId = generateSimpleId;
 exports.getActiveTracker = getActiveTracker;
+exports.getBlacConfig = getBlacConfig;
 exports.getDescriptor = getDescriptor;
 exports.getGetterExecutionContext = getGetterExecutionContext;
 exports.getPluginManager = getPluginManager;
@@ -2127,6 +2230,7 @@ exports.initAutoTrackState = initAutoTrackState;
 exports.initManualDepsState = initManualDepsState;
 exports.initNoTrackState = initNoTrackState;
 exports.invalidateRenderCache = invalidateRenderCache;
+exports.isDevMode = isDevMode;
 exports.isExcludedFromDevTools = isExcludedFromDevTools;
 exports.isGetter = isGetter;
 exports.isIsolatedClass = isIsolatedClass;
@@ -2134,6 +2238,7 @@ exports.isIsolatedKey = isIsolatedKey;
 exports.isKeepAliveClass = isKeepAliveClass;
 exports.isProxyable = isProxyable;
 exports.parsePath = parsePath;
+exports.resetBlacConfig = resetBlacConfig;
 exports.resetGetterTracker = resetGetterTracker;
 exports.setActiveTracker = setActiveTracker;
 exports.shallowEqual = shallowEqual;