wooks/dist/index.cjs

wooks

//#region rolldown:runtime
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: ((k) => from[k]).bind(null, key),
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));

//#endregion
const __prostojs_logger = __toESM(require("@prostojs/logger"));
const __prostojs_router = __toESM(require("@prostojs/router"));
const __wooksjs_event_core = __toESM(require("@wooksjs/event-core"));

//#region packages/wooks/src/wooks.ts
function getDefaultLogger(topic) {
	return new __prostojs_logger.ProstoLogger({
		level: 4,
		transports: [(0, __prostojs_logger.createConsoleTransort)({ format: __prostojs_logger.coloredConsole })]
	}, topic);
}
var Wooks = class {
	router;
	logger;
	constructor(opts) {
		this.router = new __prostojs_router.ProstoRouter({
			silent: true,
			...opts?.router
		});
		this.logger = opts?.logger || getDefaultLogger(`[wooks]`);
	}
	getRouter() {
		return this.router;
	}
	getLogger(topic) {
		if (this.logger instanceof __prostojs_logger.ProstoLogger) return this.logger.createTopic(topic);
		return this.logger;
	}
	getLoggerOptions() {
		if (this.logger instanceof __prostojs_logger.ProstoLogger) return this.logger.getOptions();
		return {};
	}
	lookup(method, path) {
		const found = this.getRouter().lookup(method, path || "");
		(0, __wooksjs_event_core.useAsyncEventContext)().store("routeParams").value = found?.ctx?.params || {};
		if (found?.route?.handlers.length) (0, __wooksjs_event_core.getContextInjector)().hook(method, "Handler:routed", found.route.path);
		else (0, __wooksjs_event_core.getContextInjector)().hook(method, "Handler:not_found");
		return {
			handlers: found?.route?.handlers || null,
			segments: found?.route?.segments || null,
			firstStatic: found?.route?.firstStatic || null,
			path: found?.route?.path || null
		};
	}
	on(method, path, handler) {
		return this.router.on(method, path, handler);
	}
};
let gWooks;
/**
* Clear global wooks instance
*
* (useful for tests or dev-mode)
*/
function clearGlobalWooks() {
	gWooks = void 0;
}
/**
* Creates global wooks singleton instance to share across adapters
* @param logger
* @param routerOpts
* @returns
*/
function getGlobalWooks(logger, routerOpts) {
	if (!gWooks) gWooks = new Wooks({
		logger,
		router: routerOpts
	});
	return gWooks;
}
var WooksAdapterBase = class WooksAdapterBase {
	wooks;
	constructor(wooks, logger, routerOpts) {
		if (wooks && wooks instanceof WooksAdapterBase) this.wooks = wooks.getWooks();
		else if (wooks && wooks instanceof Wooks) this.wooks = wooks;
		else this.wooks = getGlobalWooks(logger, routerOpts);
	}
	getWooks() {
		return this.wooks;
	}
	/**
	* Get logger instance for application logs
	* ```js
	* const app = createHttpApp()
	* const logger = app.getLogger('[app-logger]')
	* logger.log('My App log message')
	* ```
	* @param topic topic for logger
	* @returns logger instance
	*/
	getLogger(topic) {
		return this.getWooks().getLogger(topic);
	}
	getLoggerOptions() {
		return this.getWooks().getLoggerOptions();
	}
	mergeEventOptions(opts) {
		return {
			...opts,
			eventLogger: {
				...this.getLoggerOptions(),
				...opts?.eventLogger
			}
		};
	}
	on(method, path, handler) {
		return this.wooks.on(method, path, handler);
	}
};

//#endregion
exports.Wooks = Wooks;
exports.WooksAdapterBase = WooksAdapterBase;
exports.clearGlobalWooks = clearGlobalWooks;
exports.getGlobalWooks = getGlobalWooks;
Object.defineProperty(exports, 'useEventId', {
  enumerable: true,
  get: function () {
    return __wooksjs_event_core.useEventId;
  }
});
Object.defineProperty(exports, 'useEventLogger', {
  enumerable: true,
  get: function () {
    return __wooksjs_event_core.useEventLogger;
  }
});
Object.defineProperty(exports, 'useRouteParams', {
  enumerable: true,
  get: function () {
    return __wooksjs_event_core.useRouteParams;
  }
});