@jayfong/x-server 2.119.0 → 3.0.0

package/lib/cli/env_util.mjs

@@ -0,0 +1,207 @@
+import { asyncLimit, castArray, dedent, difference, escapeRegExp, get, isPlainObject, uniq } from "vtils";
+import path from "node:path";
+import fs from "fs-extra";
+import globby from "globby";
+import { pinyin } from "pinyin-pro";
+import { parse } from "yaml";
+// src/cli/env_util.ts
+var EnvUtil = class EnvUtil {
+	static NEWLINE = "\n";
+	static RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/;
+	static RE_NEWLINES = /\\n/g;
+	static NEWLINES_MATCH = /\r\n|\n|\r/;
+	static COMMENT_MATCH = /^#\s*(.+?)\s*$/;
+	static async getAllChannel(cwd, excludeChannels) {
+		const channelFiles = await globby([".env@*"], {
+			cwd,
+			onlyFiles: true,
+			absolute: false
+		});
+		if (channelFiles.length === 0) return [];
+		let channels = uniq(channelFiles.map((channel) => channel.split("@").pop().split(".")[0]));
+		if (excludeChannels?.length) channels = difference(channels, excludeChannels);
+		return channels;
+	}
+	static async chooseChannel(cwd, excludeChannels) {
+		const channels = await EnvUtil.getAllChannel(cwd, excludeChannels);
+		if (channels.length === 0) return void 0;
+		if (channels.length === 1) return channels[0];
+		const channelOptions = channels.sort((a, b) => a.localeCompare(b, "zh-CN")).map((channel) => {
+			const channelPinyin = pinyin(channel, {
+				type: "string",
+				pattern: "first",
+				toneType: "none",
+				separator: "",
+				removeNonZh: false,
+				nonZh: "consecutive"
+			}).toLowerCase();
+			return {
+				name: channel,
+				value: channel,
+				pinyin: channelPinyin,
+				description: `${channel}<${channelPinyin}>`
+			};
+		});
+		const { default: autocomplete } = await import("inquirer-autocomplete-standalone");
+		return await autocomplete({
+			message: "请选择渠道",
+			source: async (input) => {
+				return !input ? channelOptions : channelOptions.filter((channelOption) => {
+					return channelOption.pinyin.includes(input) || channelOption.name.includes(input);
+				});
+			}
+		}) || void 0;
+	}
+	static async withChannel(options) {
+		const successChannels = [];
+		const failedChannels = [];
+		if (options.channel?.startsWith("_")) {
+			const excludeChannels = options.channel.split("!")[1]?.split(",").filter(Boolean);
+			const channel = process.env.APP_CHANNEL || await EnvUtil.chooseChannel(options.cwd, excludeChannels);
+			console.log(`========= ${channel} =========`);
+			try {
+				await options.cb(channel);
+				successChannels.push(channel);
+			} catch (err) {
+				console.error(err);
+				failedChannels.push(channel);
+			}
+		} else if (options.channel?.startsWith("@")) {
+			const excludeChannels = options.channel.split("!")[1]?.split(",").filter(Boolean);
+			const channels = await EnvUtil.getAllChannel(options.cwd, excludeChannels);
+			await Promise.all(channels.map(asyncLimit(async (channel) => {
+				console.log(`========= ${channel} =========`);
+				try {
+					await options.cb(channel);
+					successChannels.push(channel);
+				} catch (err) {
+					console.error(err);
+					failedChannels.push(channel);
+				}
+			}, { concurrency: options.concurrency || 1 })));
+		} else {
+			if (options.channel) console.log(`========= ${options.channel} =========`);
+			try {
+				await options.cb(options.channel);
+				options.channel && successChannels.push(options.channel);
+			} catch (err) {
+				console.error(err);
+				options.channel && failedChannels.push(options.channel);
+			}
+		}
+		if (successChannels.length) console.log(`✅(${successChannels.length})：${JSON.stringify(successChannels)}`);
+		if (failedChannels.length) console.log(`❌(${failedChannels.length})：${JSON.stringify(failedChannels)}`);
+	}
+	static getFile(env, channel, noBase) {
+		const file = [".env_meta", ...noBase ? [] : [".env"]];
+		if (!noBase && channel) file.push(`.env@${channel}`);
+		if (env) {
+			file.push(`.env.${env}`);
+			if (channel) file.push(`.env@${channel}.${env}`);
+		}
+		return file;
+	}
+	static parseContent(src, _envItemMap, _envValueMap, channel) {
+		const envs = [];
+		const envObj = parse(src);
+		if (channel) {
+			const channelEnvs = envObj.__CHANNEL__;
+			if (channelEnvs && Array.isArray(channelEnvs)) {
+				for (const channelEnv of channelEnvs) if (castArray(channelEnv._).flatMap((item) => item.split(",")).includes(channel)) {
+					delete channelEnv._;
+					Object.assign(envObj, channelEnv);
+					break;
+				}
+			}
+		}
+		delete envObj.__CHANNEL__;
+		const inlineVars = (value) => {
+			if (Array.isArray(value)) return value.map(inlineVars);
+			if (isPlainObject(value)) return Object.keys(value).reduce((acc, key) => {
+				acc[key] = inlineVars(value[key]);
+				return acc;
+			}, {});
+			if (typeof value === "string") return value.replace(/\{\{\s*(.+?)\s*\}\}/g, (_, key) => get(_envValueMap || envObj, key) || process.env[key] || "");
+			return value;
+		};
+		Object.keys(envObj).forEach((key) => {
+			const value = inlineVars(envObj[key]);
+			const envItem = {
+				key,
+				value,
+				comment: src.match(new RegExp(`((#\\s*(.+?)\\s*[\\r\\n]+)+)\\s*${escapeRegExp(key)}:`))?.[1].split(/(\r\n){2,}|\r{2,}|\n{2,}/g).pop()?.replace(/^#/gm, "").trim() || ""
+			};
+			if (_envItemMap) _envItemMap[key] = envItem;
+			if (_envValueMap) _envValueMap[key] = value;
+			envs.push(envItem);
+		});
+		return envs;
+	}
+	static async parseFile(options) {
+		const envItemMap = {};
+		const envValueMap = { APP_CHANNEL: options.channel };
+		for (const file of options.file) {
+			const isEnvMeta = file === ".env_meta";
+			const envYmlFile = path.join(options.cwd, `${file}.yml`);
+			const envYamlFile = path.join(options.cwd, `${file}.yaml`);
+			const envFile = await fs.pathExists(envYmlFile) ? envYmlFile : await fs.pathExists(envYamlFile) ? envYamlFile : "";
+			if (envFile) {
+				const envContent = await fs.readFile(envFile, "utf-8");
+				EnvUtil.parseContent(envContent, isEnvMeta ? void 0 : envItemMap, envValueMap, options.channel);
+			}
+		}
+		return Object.values(envItemMap);
+	}
+	static async parseFileAsMap(options) {
+		const envsObj = { APP_CHANNEL: options.channel };
+		const envs = await EnvUtil.parseFile(options);
+		for (const env of envs) envsObj[env.key] = env.value;
+		return envsObj;
+	}
+	static async importFile(options) {
+		const envsObj = { APP_CHANNEL: options.channel };
+		const envs = await EnvUtil.parseFile(options);
+		for (const env of envs) {
+			envsObj[env.key] = env.value;
+			process.env[env.key] = env.value;
+		}
+		process.env.X_SERVER_ENVS = JSON.stringify({
+			...JSON.parse(process.env.X_SERVER_ENVS || "{}"),
+			...envsObj
+		});
+	}
+	static makeTypes(envs) {
+		return dedent`
+      declare namespace NodeJS {
+        interface ProcessEnv {
+          /**
+           * 当前环境
+           */
+          NODE_ENV: 'development' | 'production';
+          /**
+           * 当前渠道
+           */
+          APP_CHANNEL: string;
+          ${envs.map((env) => dedent`
+                ${env.comment ? dedent`
+                        /**
+                         ${env.comment.split(/[\r\n]+/g).map((line) => `* ${line.trim()}`).join("\n*\n")}
+                        */
+                      ` : ""}
+                ${env.key}: ${EnvUtil.getTypesFromValue(env.value)};
+              `).join("\n")}
+        }
+      }
+    `;
+	}
+	static async outputTypes(options) {
+		const envs = await EnvUtil.parseFile(options);
+		const outFile = path.join(options.cwd, options.outFile);
+		const types = EnvUtil.makeTypes(envs);
+		await fs.outputFile(outFile, types);
+	}
+	static getTypesFromValue(value) {
+		return Array.isArray(value) ? `Array<${value[0] ? EnvUtil.getTypesFromValue(value[0]) : "any"}>` : isPlainObject(value) ? Object.keys(value).length ? `{${Object.keys(value).map((key) => `'${key}':${EnvUtil.getTypesFromValue(value[key])}`).join(",")}}` : `Record<any, any>` : typeof value;
+	}
+};
+export { EnvUtil };

package/lib/cli/esbuild_register.d.mts

@@ -0,0 +1 @@
+export {}

package/lib/cli/esbuild_register.mjs

@@ -0,0 +1,7 @@
+import { register } from "esbuild-register/dist/node";
+// src/cli/esbuild_register.ts
+register({
+	hookIgnoreNodeModules: false,
+	hookMatcher: (filename) => filename.includes("/.x/") || !filename.includes("/node_modules/")
+});
+export {};

package/lib/cli/template_util.d.mts

@@ -0,0 +1,18 @@
+export declare class TemplateUtil {
+  /**
+   * 初始化。
+   */
+  static init(cwd: string): Promise<void>;
+  /**
+   * 初始化辅助包。
+   */
+  static initHelperPackage(cwd: string): Promise<void>;
+  /**
+   * 初始化任务。
+   */
+  static initTasks(cwd: string): Promise<void>;
+  /**
+   * 初始化模型。
+   */
+  static initModels(cwd: string): Promise<void>;
+}

package/lib/cli/template_util.mjs

@@ -0,0 +1,85 @@
+import { camelCase, dedent, snakeCase, upperFirst } from "vtils";
+import path from "node:path";
+import fs from "fs-extra";
+import { generateManyIndex } from "vscode-generate-index-standalone";
+import globby from "globby";
+// src/cli/template_util.ts
+var TemplateUtil = class {
+	/**
+	* 初始化。
+	*/
+	static async init(cwd) {
+		await Promise.all([this.initHelperPackage(cwd), this.initTasks(cwd)]);
+	}
+	/**
+	* 初始化辅助包。
+	*/
+	static async initHelperPackage(cwd) {
+		const fromDir = path.join(import.meta.dirname, "templates");
+		const toDir = path.join(cwd, "node_modules/@a/x");
+		const hasDb = await fs.pathExists(path.join(cwd, "src/db/schema.prisma"));
+		const fromFiles = await globby("*", {
+			cwd: fromDir,
+			onlyFiles: true,
+			absolute: true
+		});
+		await fs.ensureDir(toDir);
+		await Promise.all(fromFiles.map(async (fromFile) => {
+			const toFile = fromFile.replace(fromDir, toDir);
+			if (fromFile.endsWith("models.ts") && !hasDb) await fs.writeFile(toFile, "export {}");
+			else {
+				let fromFileContent = await fs.readFile(fromFile, "utf-8");
+				fromFileContent = fromFileContent.replaceAll("../../src", path.relative(toDir, `${cwd}/src`));
+				await fs.writeFile(toFile, fromFileContent);
+			}
+		}));
+		await generateManyIndex({
+			cwd,
+			patterns: ["node_modules/@a/x/*.ts"],
+			replaceFile: true
+		});
+	}
+	/**
+	* 初始化任务。
+	*/
+	static async initTasks(cwd) {
+		const tasksDir = path.join(cwd, "src/tasks");
+		const tasksIndexFile = path.join(tasksDir, "index.ts");
+		if (!await fs.pathExists(tasksIndexFile)) await fs.outputFile(tasksIndexFile, dedent`
+          // @index(['./**/*.ts', '!**/*.test.ts', '!**/_*'], f => \`export * from '\${f.path}'\`)
+          // @endindex
+        `);
+	}
+	/**
+	* 初始化模型。
+	*/
+	static async initModels(cwd) {
+		const modelsDir = path.join(cwd, "src/models");
+		const indexFile = path.join(modelsDir, "index.ts");
+		const indexFile2 = path.join(cwd, "node_modules/@a/x/models.ts");
+		const prismaClientFile = path.join(cwd, "node_modules/@a/x/prisma/internal/prismaNamespace.ts");
+		const modelNames = [...(await fs.readFile(prismaClientFile, "utf8")).match(/(?<=const ModelName).+?(?=\})/s)[0].matchAll(/(\S+?):/g)].map((match) => camelCase(match[1]));
+		await Promise.all(modelNames.map(async (modelName) => {
+			const model_name = snakeCase(modelName);
+			const ModelName = upperFirst(modelName);
+			const modelFile = path.join(modelsDir, `${model_name}.ts`);
+			if (!await fs.pathExists(modelFile)) await fs.outputFile(modelFile, dedent`
+              import { ${ModelName}BaseModel } from '@jayfong/x-server'
+
+              export class ${ModelName}Model extends ${ModelName}BaseModel {}
+              
+              export const ${modelName}Model = new ${ModelName}Model()
+            `);
+		}));
+		if (!await fs.pathExists(indexFile)) await fs.outputFile(indexFile, dedent`
+          // @index(['./**/*.ts', '!**/*.test.ts', '!**/_*'], f => \`export * from '\${f.path}'\`)
+          // @endindex
+        `);
+		await generateManyIndex({
+			cwd,
+			patterns: [indexFile, indexFile2],
+			replaceFile: true
+		});
+	}
+};
+export { TemplateUtil };

package/lib/cli/templates/crons.ts

@@ -1,2 +1,2 @@
-// @index(['../../src/crons/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `import '${f.path}'`)
+// @index(['../../src/crons/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `import '${f.path}${f.ext}'`)
 // @endindex

package/lib/cli/templates/handlers.ts

@@ -1,3 +1,3 @@
-// @index(['../../src/handlers/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `export * as __${_.pascal(f.path.replace('/src/handlers/', ''))}__ from '${f.path}'`)
+// @index(['../../src/handlers/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `export * as __${_.pascal(f.path.replace('/src/handlers/', ''))}__ from '${f.path}${f.ext}'`)
 
 // @endindex

package/lib/cli/templates/hooks.ts

@@ -1,2 +1,2 @@
-// @index(['../../src/hooks/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `import '${f.path}'`)
+// @index(['../../src/hooks/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `import '${f.path}${f.ext}'`)
 // @endindex

package/lib/cli/templates/models.ts

@@ -3,7 +3,7 @@ import { URL } from 'node:url';
 import { x } from '@jayfong/x-server';
 import { PrismaMariaDb } from '@prisma/adapter-mariadb';
 import { isNumeric, mapValues } from 'vtils';
-import { type Prisma, PrismaClient } from './prisma/client';
+import { type Prisma, PrismaClient } from './prisma/client.ts';
 
 const dbUri = new URL(process.env.DATABASE_URL!);
 const adapter = new PrismaMariaDb({
@@ -76,12 +76,12 @@ function _makeBaseModel<TModelName extends ModelName>(name: TModelName) {
 
     public getModel = <T extends ModelName>(
       name: T,
-    ): typeof import('../../src/models')[`${T}Model`] => {
+    ): typeof import('../../src/models/index.ts')[`${T}Model`] => {
       return this.transactionClient
-        ? require('../../src/models')[`${name}Model`].transactionify(
+        ? require('../../src/models/index.ts')[`${name}Model`].transactionify(
             this.transactionClient,
           )
-        : require('../../src/models')[`${name}Model`];
+        : require('../../src/models/index.ts')[`${name}Model`];
     };
   };
 }
@@ -89,7 +89,7 @@ function _makeBaseModel<TModelName extends ModelName>(name: TModelName) {
 // @index('./prisma/internal/prismaNamespace.ts', /(?<=const ModelName).+?(?=\})/s, /(\S+?):/g, (m, _) => `export const ${m[1]}BaseModel = _makeBaseModel('${_.camel(m[1])}')`)
 // @endindex
 
-export * from './prisma/client';
+export * from './prisma/client.ts';
 
 /**
  * @deprecated 使用 runInTransaction 代替
@@ -97,12 +97,12 @@ export * from './prisma/client';
 export const startTransaction = <T>(
   cb: (
     models: {
-      [K in ModelName]: typeof import('../../src/models')[`${K}Model`];
+      [K in ModelName]: typeof import('../../src/models/index.ts')[`${K}Model`];
     },
   ) => Promise<T>,
 ): Promise<T> => {
   return prismaClient.$transaction(async _tx => {
-    const _models = require('../../src/models');
+    const _models = require('../../src/models/index.ts');
     const _cache = Object.create(null);
     return cb({
       // @index('./prisma/internal/prismaNamespace.ts', /(?<=const ModelName).+?(?=\})/s, /(\S+?):/g, (m, _) => `get ${_.camel(m[1])}() { return _cache.${_.camel(m[1])} || (_cache.${_.camel(m[1])} = _models.${_.camel(m[1])}Model.transactionify(_tx)) }, `)

package/lib/cli/templates/package.json

@@ -1,3 +1,13 @@
 {
-  "name": ".x"
+  "name": "@a/x",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    "./crons": "./crons.ts",
+    "./handlers": "./handlers.ts",
+    "./hooks": "./hooks.ts",
+    "./models": "./models.ts",
+    "./routes": "./routes.ts",
+    "./package.json": "./package.json"
+  }
 }

package/lib/cli/templates/routes.ts

@@ -1,5 +1,5 @@
 import { Handler, XServer } from '@jayfong/x-server';
-import * as handlers from './handlers';
+import * as handlers from './handlers.ts';
 
 const basePathWithHandlers: Array<[string, Record<string, Handler>]> = [
   // @index(['../../src/handlers/**/*.ts', '!**/_*', '!**/_*/**', '!**/*.test.*'], (f, _) => `['${(f.path+'/').replace(/@dev/g, '').replace('../../src/handlers/', '/').replace(/\/index\/$/, '/').split('/').map(v => _.snake(v)).join('/')}', handlers.__${_.pascal(f.path.replace('/src/handlers/', ''))}__ as any],`)
@@ -55,6 +55,7 @@ export const routes: XServer.Route[] = basePathWithHandlers.reduce<
     name => !name.startsWith('_') && name !== 'default',
   );
   for (const handlerName of validHandlerNames) {
+    if (handlerName === 'module.exports') continue;
     const path = item[1][handlerName].options.requestPath || handlerName;
     const paths = Array.isArray(path) ? path : [path];
     for (const path of paths) {

package/lib/core/ctx_storage.d.mts

@@ -0,0 +1,3 @@
+import { XHandler } from "./types.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+export declare const ctxStorage: AsyncLocalStorage<XHandler.Context>;

package/lib/core/ctx_storage.mjs

@@ -0,0 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+// src/core/ctx_storage.ts
+const ctxStorage = new AsyncLocalStorage();
+export { ctxStorage };

package/lib/core/define_bus.d.mts

@@ -0,0 +1,37 @@
+import { EventEmitter } from "node:events";
+declare class EventBus extends EventEmitter {
+  onReturnOff(event: string, listener: (...args: any[]) => any): () => any;
+}
+export declare function defineBus<T extends Record<string, any>>(): StrictEventEmitter<EventBus, T, T, "addEventListener" | "removeEventListener", "on" | "addListener" | "removeListener" | "once" | "emit" | "off" | "onReturnOff">;
+declare const assignmentCompatibilityHack: unique symbol;
+interface TypeRecord<T, U, V> {
+  ' _emitterType'?: T;
+  ' _eventsType'?: U;
+  ' _emitType'?: V;
+}
+type InnerEEMethodReturnType<T, TValue, FValue> = T extends ((...args: any[]) => any) ? ReturnType<T> extends void | undefined ? FValue : TValue : FValue;
+type EEMethodReturnType<T, S extends string, TValue, FValue = void> = S extends keyof T ? InnerEEMethodReturnType<T[S], TValue, FValue> : FValue;
+type ListenerType<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T];
+type OverriddenMethods<TEmitter, TEventRecord, TEmitRecord = TEventRecord> = {
+  on<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'on', T>;
+  on(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  addListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'addListener', T>;
+  addListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  addEventListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'addEventListener', T>;
+  addEventListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  removeListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: any[]) => any): EEMethodReturnType<TEmitter, 'removeListener', T>;
+  removeListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  removeEventListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: any[]) => any): EEMethodReturnType<TEmitter, 'removeEventListener', T>;
+  removeEventListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  once<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'once', T>;
+  once(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  emit<P extends keyof TEmitRecord, T>(this: T, event: P, ...args: ListenerType<TEmitRecord[P]>): EEMethodReturnType<TEmitter, 'emit', T>;
+  emit(event: typeof assignmentCompatibilityHack, ...args: any[]): void;
+  off<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'off', T>;
+  off(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+  onReturnOff<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): () => any;
+  onReturnOff(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): () => any;
+};
+type OverriddenKeys = keyof OverriddenMethods<any, any, any>;
+type StrictEventEmitter<TEmitterType, TEventRecord, TEmitRecord = TEventRecord, UnneededMethods extends Exclude<OverriddenKeys, keyof TEmitterType> = Exclude<OverriddenKeys, keyof TEmitterType>, NeededMethods extends Exclude<OverriddenKeys, UnneededMethods> = Exclude<OverriddenKeys, UnneededMethods>> = TypeRecord<TEmitterType, TEventRecord, TEmitRecord> & Pick<TEmitterType, Exclude<keyof TEmitterType, OverriddenKeys>> & Pick<OverriddenMethods<TEmitterType, TEventRecord, TEmitRecord>, NeededMethods>;
+export {};

package/lib/core/define_bus.mjs

@@ -0,0 +1,12 @@
+import { EventEmitter } from "node:events";
+// src/core/define_bus.ts
+var EventBus = class extends EventEmitter {
+	onReturnOff(event, listener) {
+		this.on(event, listener);
+		return () => this.off(event, listener);
+	}
+};
+function defineBus() {
+	return new EventBus();
+}
+export { defineBus };

package/lib/core/{define_cron.d.ts → define_cron.d.mts}

@@ -1,2 +1,2 @@
-import type { XCron } from './types';
-export declare function defineCron(options: XCron.Options): XCron.Cron;
+import { XCron } from "./types.mjs";
+export declare function defineCron(options: XCron.Options): XCron.Cron;

package/lib/core/define_cron.mjs

@@ -0,0 +1,11 @@
+import { CronJob } from "cron";
+// src/core/define_cron.ts
+function defineCron(options) {
+	return CronJob.from({
+		cronTime: options.expression,
+		runOnInit: options.runOnInit,
+		start: true,
+		onTick: options.handle
+	});
+}
+export { defineCron };

package/lib/core/{define_handler.d.ts → define_handler.d.mts}

@@ -1,24 +1,24 @@
-import type { FirstParameter } from 'vtils/types';
-import { Handler } from './handler';
-import type { XHandler } from './types';
+import { Handler } from "./handler.mjs";
+import { XHandler } from "./types.mjs";
+import { FirstParameter } from "vtils/types";
 export declare function defineHandler<TFn extends (...args: any[]) => Promise<any>, TReqData = FirstParameter<TFn>, TResData = Awaited<ReturnType<TFn>>>(options: XHandler.Options<TReqData, TResData, 'POST'>): Handler<TReqData, TResData, 'POST'>;
 export declare function defineHandler<TReqData extends any = void, TResData extends any = void>(options: XHandler.Options<TReqData, TResData, 'POST'>): Handler<TReqData, TResData, 'POST'>;
 export declare namespace defineHandler {
-    var POST: typeof defineHandler;
-    var GET: typeof defineHandlerGET;
-    var FILE: typeof defineHandlerFILE;
-    var WS: <TReqData extends Record<string, [any, any]>>(options: XHandler.Options<{ [K in keyof TReqData]: {
-        request: TReqData[K][0];
-        response: TReqData[K][1];
-    }; }, void, "WS">) => Handler<{ [K in keyof TReqData]: {
-        request: TReqData[K][0];
-        response: TReqData[K][1];
-    }; }, void, "WS", import("vtils/types").RequiredDeep<{ [K in keyof TReqData]: {
-        request: TReqData[K][0];
-        response: TReqData[K][1];
-    }; }>>;
-    var XML: typeof defineHandlerXML;
-    var ANY: typeof defineHandlerANY;
+  var POST: typeof defineHandler;
+  var GET: typeof defineHandlerGET;
+  var FILE: typeof defineHandlerFILE;
+  var WS: <TReqData extends Record<string, [any, any]>>(options: XHandler.Options<{ [K in keyof TReqData]: {
+    request: TReqData[K][0];
+    response: TReqData[K][1];
+  }; }, void, "WS">) => Handler<{ [K in keyof TReqData]: {
+    request: TReqData[K][0];
+    response: TReqData[K][1];
+  }; }, void, "WS", import("vtils/types").RequiredDeep<{ [K in keyof TReqData]: {
+    request: TReqData[K][0];
+    response: TReqData[K][1];
+  }; }>>;
+  var XML: typeof defineHandlerXML;
+  var ANY: typeof defineHandlerANY;
 }
 export declare function defineHandlerGET<TFn extends (...args: any[]) => Promise<any>, TReqData = FirstParameter<TFn>, TResData = Awaited<ReturnType<TFn>>>(options: XHandler.Options<TReqData, TResData, 'GET'>): Handler<TReqData, TResData, 'GET'>;
 export declare function defineHandlerGET<TReqData extends any = void, TResData extends any = void>(options: XHandler.Options<TReqData, TResData, 'GET'>): Handler<TReqData, TResData, 'GET'>;
@@ -27,4 +27,4 @@ export declare function defineHandlerFILE<TReqData extends any = void, TResData
 export declare function defineHandlerXML<TFn extends (...args: any[]) => Promise<any>, TReqData = FirstParameter<TFn>, TResData = Awaited<ReturnType<TFn>>>(options: XHandler.Options<TReqData, TResData, 'XML'>): Handler<TReqData, TResData, 'XML'>;
 export declare function defineHandlerXML<TReqData extends any = void, TResData extends any = void>(options: XHandler.Options<TReqData, TResData, 'XML'>): Handler<TReqData, TResData, 'XML'>;
 export declare function defineHandlerANY<TFn extends (...args: any[]) => Promise<any>, TReqData = FirstParameter<TFn>, TResData = Awaited<ReturnType<TFn>>>(options: XHandler.Options<TReqData, TResData, 'ANY'>): Handler<TReqData, TResData, 'ANY'>;
-export declare function defineHandlerANY<TReqData extends any = void, TResData extends any = void>(options: XHandler.Options<TReqData, TResData, 'ANY'>): Handler<TReqData, TResData, 'ANY'>;
+export declare function defineHandlerANY<TReqData extends any = void, TResData extends any = void>(options: XHandler.Options<TReqData, TResData, 'ANY'>): Handler<TReqData, TResData, 'ANY'>;

package/lib/core/define_handler.mjs

@@ -0,0 +1,44 @@
+import { Handler } from "./handler.mjs";
+// src/core/define_handler.ts
+function defineHandler(options) {
+	return new Handler({
+		...options,
+		requestMethod: "POST"
+	});
+}
+defineHandler.POST = defineHandler;
+function defineHandlerGET(options) {
+	return new Handler({
+		...options,
+		requestMethod: "GET"
+	});
+}
+defineHandler.GET = defineHandlerGET;
+function defineHandlerFILE(options) {
+	return new Handler({
+		...options,
+		requestMethod: "FILE"
+	});
+}
+defineHandler.FILE = defineHandlerFILE;
+defineHandler.WS = (options) => {
+	return new Handler({
+		...options,
+		requestMethod: "WS"
+	});
+};
+function defineHandlerXML(options) {
+	return new Handler({
+		...options,
+		requestMethod: "XML"
+	});
+}
+defineHandler.XML = defineHandlerXML;
+function defineHandlerANY(options) {
+	return new Handler({
+		...options,
+		requestMethod: "ANY"
+	});
+}
+defineHandler.ANY = defineHandlerANY;
+export { defineHandler, defineHandlerANY, defineHandlerFILE, defineHandlerGET, defineHandlerXML };

package/lib/core/define_hook.d.mts

@@ -0,0 +1,2 @@
+import { XHandler } from "./types.mjs";
+export declare function defineHook(hook: XHandler.Hook): void;

package/lib/core/define_hook.mjs

@@ -0,0 +1,6 @@
+import { Handler } from "./handler.mjs";
+// src/core/define_hook.ts
+function defineHook(hook) {
+	Handler.addHook(hook);
+}
+export { defineHook };

package/lib/core/define_server.d.mts

@@ -0,0 +1,3 @@
+import { Server } from "./server.mjs";
+import { XServer } from "./types.mjs";
+export declare function defineServer(options: XServer.Options): Promise<Server>;

package/lib/core/define_server.mjs

@@ -0,0 +1,8 @@
+import { Server } from "./server.mjs";
+// src/core/define_server.ts
+async function defineServer(options) {
+	const server = new Server(options);
+	await server.start();
+	return server;
+}
+export { defineServer };

package/lib/core/{define_task.d.ts → define_task.d.mts}

@@ -1,4 +1,4 @@
-import type { XTask } from './types';
+import { XTask } from "./types.mjs";
 export declare function defineTask<T>(options: XTask.TaskOptions<T>): XTask.Task<T>;
 export declare function defineSliceTask<T>(options: XTask.SliceTaskOptions<T, any>): XTask.SliceTaskNoKey<T>;
-export declare function defineSliceTask<T, K extends string | number>(options: XTask.SliceTaskOptions<T, K>): XTask.SliceTask<T, K>;
+export declare function defineSliceTask<T, K extends string | number>(options: XTask.SliceTaskOptions<T, K>): XTask.SliceTask<T, K>;