wooks 0.5.20 → 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 wooksjs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -1,124 +1,146 @@
-'use strict';
+"use strict";
+//#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));
 
-var logger = require('@prostojs/logger');
-var router = require('@prostojs/router');
-var eventCore = require('@wooksjs/event-core');
+//#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 logger.ProstoLogger({
-        level: 4,
-        transports: [
-            logger.createConsoleTransort({
-                format: logger.coloredConsole,
-            }),
-        ],
-    }, topic);
-}
-
-class Wooks {
-    constructor(opts) {
-        this.router = new router.ProstoRouter({
-            silent: true,
-            ...opts?.router,
-        });
-        this.logger = opts?.logger || getDefaultLogger(`${''}[wooks]`);
-    }
-    getRouter() {
-        return this.router;
-    }
-    getLogger(topic) {
-        if (this.logger instanceof logger.ProstoLogger) {
-            return this.logger.createTopic(topic);
-        }
-        return this.logger;
-    }
-    getLoggerOptions() {
-        if (this.logger instanceof logger.ProstoLogger) {
-            return this.logger.getOptions();
-        }
-        return {};
-    }
-    lookup(method, path) {
-        const found = this.getRouter().lookup(method, path || '');
-        eventCore.useAsyncEventContext().store('routeParams').value = found?.ctx?.params || {};
-        if (found?.route?.handlers.length) {
-            eventCore.getContextInjector().hook(method, 'Handler:routed', found.route.path);
-        }
-        else {
-            eventCore.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);
-    }
+	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(`${"\x1B[96m"}[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;
 function clearGlobalWooks() {
-    gWooks = undefined;
+	gWooks = undefined;
 }
 function getGlobalWooks(logger, routerOpts) {
-    if (!gWooks) {
-        gWooks = new Wooks({
-            logger,
-            router: routerOpts,
-        });
-    }
-    return gWooks;
-}
-class WooksAdapterBase {
-    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;
-    }
-    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);
-    }
+	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);
+	}
+};
 
-Object.defineProperty(exports, "useEventId", {
+//#endregion
+exports.Wooks = Wooks
+exports.WooksAdapterBase = WooksAdapterBase
+exports.clearGlobalWooks = clearGlobalWooks
+exports.getGlobalWooks = getGlobalWooks
+Object.defineProperty(exports, 'useEventId', {
   enumerable: true,
-  get: function () { return eventCore.useEventId; }
+  get: function () {
+    return __wooksjs_event_core.useEventId;
+  }
 });
-Object.defineProperty(exports, "useEventLogger", {
+Object.defineProperty(exports, 'useEventLogger', {
   enumerable: true,
-  get: function () { return eventCore.useEventLogger; }
+  get: function () {
+    return __wooksjs_event_core.useEventLogger;
+  }
 });
-Object.defineProperty(exports, "useRouteParams", {
+Object.defineProperty(exports, 'useRouteParams', {
   enumerable: true,
-  get: function () { return eventCore.useRouteParams; }
-});
-exports.Wooks = Wooks;
-exports.WooksAdapterBase = WooksAdapterBase;
-exports.clearGlobalWooks = clearGlobalWooks;
-exports.getGlobalWooks = getGlobalWooks;
+  get: function () {
+    return __wooksjs_event_core.useRouteParams;
+  }
+});

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import * as _prostojs_router from '@prostojs/router';
-import { ProstoRouter } from '@prostojs/router';
 import { TConsoleBase, TProstoLoggerOptions } from '@prostojs/logger';
+import { ProstoRouter, TParsedSegment, TProstoRouterPathHandle } from '@prostojs/router';
+export { TProstoRouterPathHandle } from '@prostojs/router';
 import { TEventOptions } from '@wooksjs/event-core';
 export { useEventId, useEventLogger, useRouteParams } from '@wooksjs/event-core';
 
@@ -23,43 +23,22 @@ declare class Wooks {
     getLoggerOptions(): TProstoLoggerOptions;
     lookup(method: string, path: string): {
         handlers: TWooksHandler[] | null;
-        segments: _prostojs_router.TParsedSegment[] | null;
+        segments: TParsedSegment[] | null;
         firstStatic: string | null;
         path: string | null;
     };
-    on<ResType = unknown, ParamsType = Record<string, string | string[]>>(method: string, path: string, handler: TWooksHandler<ResType>): _prostojs_router.TProstoRouterPathHandle<ParamsType>;
+    on<ResType = unknown, ParamsType = Record<string, string | string[]>>(method: string, path: string, handler: TWooksHandler<ResType>): TProstoRouterPathHandle<ParamsType>;
 }
-/**
- * Clear global wooks instance
- *
- * (useful for tests or dev-mode)
- */
 declare function clearGlobalWooks(): void;
-/**
- * Creates global wooks singleton instance to share across adapters
- * @param logger
- * @param routerOpts
- * @returns
- */
 declare function getGlobalWooks(logger?: TConsoleBase, routerOpts?: TWooksOptions['router']): Wooks;
 declare class WooksAdapterBase {
     protected wooks: Wooks;
     constructor(wooks?: Wooks | WooksAdapterBase, logger?: TConsoleBase, routerOpts?: TWooksOptions['router']);
     getWooks(): 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: string): TConsoleBase;
-    protected getLoggerOptions(): TProstoLoggerOptions<Record<string, never>>;
+    protected getLoggerOptions(): TProstoLoggerOptions;
     protected mergeEventOptions(opts?: TEventOptions): TEventOptions;
-    on<ResType = unknown, ParamsType = Record<string, string | string[]>>(method: string, path: string, handler: TWooksHandler<ResType>): _prostojs_router.TProstoRouterPathHandle<ParamsType>;
+    on<ResType = unknown, ParamsType = Record<string, string | string[]>>(method: string, path: string, handler: TWooksHandler<ResType>): TProstoRouterPathHandle<ParamsType>;
 }
 
 export { type TWooksHandler, type TWooksOptions, Wooks, WooksAdapterBase, clearGlobalWooks, getGlobalWooks };

package/dist/index.mjs

@@ -1,108 +1,101 @@
-import { ProstoLogger, createConsoleTransort, coloredConsole } from '@prostojs/logger';
-import { ProstoRouter } from '@prostojs/router';
-import { useAsyncEventContext, getContextInjector } from '@wooksjs/event-core';
-export { useEventId, useEventLogger, useRouteParams } from '@wooksjs/event-core';
+import { ProstoLogger, coloredConsole, createConsoleTransort } from "@prostojs/logger";
+import { ProstoRouter } from "@prostojs/router";
+import { getContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams } from "@wooksjs/event-core";
 
+//#region packages/wooks/src/wooks.ts
 function getDefaultLogger(topic) {
-    return new ProstoLogger({
-        level: 4,
-        transports: [
-            createConsoleTransort({
-                format: coloredConsole,
-            }),
-        ],
-    }, topic);
-}
-
-class Wooks {
-    constructor(opts) {
-        this.router = new ProstoRouter({
-            silent: true,
-            ...opts?.router,
-        });
-        this.logger = opts?.logger || getDefaultLogger(`${''}[wooks]`);
-    }
-    getRouter() {
-        return this.router;
-    }
-    getLogger(topic) {
-        if (this.logger instanceof ProstoLogger) {
-            return this.logger.createTopic(topic);
-        }
-        return this.logger;
-    }
-    getLoggerOptions() {
-        if (this.logger instanceof ProstoLogger) {
-            return this.logger.getOptions();
-        }
-        return {};
-    }
-    lookup(method, path) {
-        const found = this.getRouter().lookup(method, path || '');
-        useAsyncEventContext().store('routeParams').value = found?.ctx?.params || {};
-        if (found?.route?.handlers.length) {
-            getContextInjector().hook(method, 'Handler:routed', found.route.path);
-        }
-        else {
-            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);
-    }
+	return new ProstoLogger({
+		level: 4,
+		transports: [createConsoleTransort({ format: coloredConsole })]
+	}, topic);
 }
+var Wooks = class {
+	router;
+	logger;
+	constructor(opts) {
+		this.router = new ProstoRouter({
+			silent: true,
+			...opts?.router
+		});
+		this.logger = opts?.logger || getDefaultLogger(`${"\x1B[96m"}[wooks]`);
+	}
+	getRouter() {
+		return this.router;
+	}
+	getLogger(topic) {
+		if (this.logger instanceof ProstoLogger) return this.logger.createTopic(topic);
+		return this.logger;
+	}
+	getLoggerOptions() {
+		if (this.logger instanceof ProstoLogger) return this.logger.getOptions();
+		return {};
+	}
+	lookup(method, path) {
+		const found = this.getRouter().lookup(method, path || "");
+		useAsyncEventContext().store("routeParams").value = found?.ctx?.params || {};
+		if (found?.route?.handlers.length) getContextInjector().hook(method, "Handler:routed", found.route.path);
+else 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;
 function clearGlobalWooks() {
-    gWooks = undefined;
+	gWooks = undefined;
 }
 function getGlobalWooks(logger, routerOpts) {
-    if (!gWooks) {
-        gWooks = new Wooks({
-            logger,
-            router: routerOpts,
-        });
-    }
-    return gWooks;
-}
-class WooksAdapterBase {
-    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;
-    }
-    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);
-    }
+	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);
+	}
+};
 
-export { Wooks, WooksAdapterBase, clearGlobalWooks, getGlobalWooks };
+//#endregion
+export { Wooks, WooksAdapterBase, clearGlobalWooks, getGlobalWooks, useEventId, useEventLogger, useRouteParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wooks",
-  "version": "0.5.20",
+  "version": "0.6.0",
   "description": "wooks",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -11,9 +11,9 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
+      "types": "./dist/index.d.ts",
       "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/index.mjs"
     }
   },
   "repository": {
@@ -39,9 +39,18 @@
     "url": "https://github.com/wooksjs/wooksjs/issues"
   },
   "dependencies": {
-    "@prostojs/router": "^0.2.1",
     "@prostojs/logger": "^0.4.3",
-    "@wooksjs/event-core": "0.5.20"
+    "@prostojs/router": "^0.2.1",
+    "@wooksjs/event-core": "^0.6.0"
+  },
+  "homepage": "https://github.com/wooksjs/wooksjs/tree/main/packages/wooks#readme",
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8",
+    "@wooksjs/event-http": "^0.6.0",
+    "@wooksjs/http-body": "^0.6.0"
   },
-  "homepage": "https://github.com/wooksjs/wooksjs/tree/main/packages/wooks#readme"
-}
+  "scripts": {
+    "build": "rolldown -c ../../rolldown.config.mjs"
+  }
+}