@jayfong/x-server 2.119.0 → 3.0.0

package/lib/cli/deploy_util.js

@@ -1,70 +0,0 @@
-import path from 'node:path';
-import fs from 'fs-extra';
-import { NodeSSH } from 'node-ssh';
-import { dedent } from 'vtils';
-export class DeployUtil {
-  static async deploy(options) {
-    const pkgContent = await fs.readJson(path.join(options.cwd, 'package.json'));
-    const appFile = path.join(options.cwd, `temp${options.channel ? `/${options.channel}` : ''}/app.${pkgContent.version}.tgz`);
-    if (!(await fs.pathExists(appFile))) {
-      throw new Error('请先构建');
-    }
-    const ssh = new NodeSSH();
-    await ssh.connect({
-      host: options.host,
-      username: options.user,
-      privateKey: options.key,
-      password: options.pass
-    });
-    const appName = pkgContent.name;
-    const appDir = `./${appName}`;
-    await ssh.execCommand(dedent`
-        set -ex
-        mkdir -p ./app_files/${appName}/${options.channel || 'dist'}
-        mkdir -p ${appDir}
-      `, {
-      cwd: options.dir,
-      onStdout: buf => console.log(buf.toString()),
-      onStderr: buf => console.log(buf.toString())
-    });
-    const remoteAppFile = `${options.dir}/app_files/${appName}/${options.channel || 'dist'}/${path.basename(appFile)}`;
-    await ssh.putFile(appFile, remoteAppFile);
-    await ssh.execCommand(dedent`
-        set -ex
-        tar -zxf ${remoteAppFile} -C ${appDir}
-        cd "${appDir}/${options.channel || 'dist'}"
-        [ -f no_install.lock ] && yarn_disable_self_update_check=true tyn
-        ${options.cmd || ''}
-        pm2 startOrReload pm2.config.js
-      `, {
-      cwd: options.dir,
-      onStdout: buf => console.log(buf.toString()),
-      onStderr: buf => console.log(buf.toString())
-    });
-    ssh.dispose();
-  }
-  static async deployEnv(options) {
-    const ssh = new NodeSSH();
-    await ssh.connect({
-      host: options.host,
-      username: options.user,
-      privateKey: options.key,
-      password: options.pass
-    });
-    await ssh.execCommand(dedent`
-        set -ex
-        curl --silent --header "Content-Type: application/json" \\
-          --request "POST" \\
-          --data ${JSON.stringify(JSON.stringify({
-      token: options.token,
-      type: 'updateEnv',
-      data: options.env
-    }))} \\
-          "http://localhost:${options.port}/$"
-      `, {
-      onStdout: buf => console.log(buf.toString()),
-      onStderr: buf => console.log(buf.toString())
-    });
-    ssh.dispose();
-  }
-}

package/lib/cli/dev_util.d.ts

@@ -1,8 +0,0 @@
-import execa from 'execa';
-export declare class DevUtil {
-    static runFile(options: {
-        file: string;
-        cwd: string;
-        runner: 'esbuild-register' | 'tsx';
-    }): execa.ExecaChildProcess<string>;
-}

package/lib/cli/dev_util.js

@@ -1,20 +0,0 @@
-import fs from 'node:fs';
-import execa from 'execa';
-import { ii } from 'vtils';
-export class DevUtil {
-  static runFile(options) {
-    return options.runner === 'tsx' ? execa('node', ['-r', require.resolve("./css_register"), ii(() => {
-      const tsxPkgFile = require.resolve('tsx/package.json');
-      const tsxJsFile = tsxPkgFile.replace('/package.json', '/dist/cli.js');
-      const tsxCjsFile = tsxPkgFile.replace('/package.json', '/dist/cli.cjs');
-      const tsxMjsFile = tsxPkgFile.replace('/package.json', '/dist/cli.mjs');
-      return fs.existsSync(tsxCjsFile) ? tsxCjsFile : fs.existsSync(tsxMjsFile) ? tsxMjsFile : tsxJsFile;
-    }), options.file], {
-      cwd: options.cwd,
-      stdio: 'inherit'
-    }) : execa('node', ['-r', require.resolve("./esbuild_register"), '-r', require.resolve("./css_register"), options.file], {
-      cwd: options.cwd,
-      stdio: 'inherit'
-    });
-  }
-}

package/lib/cli/env_util.d.ts

@@ -1,45 +0,0 @@
-export interface ParsedEnv {
-    comment: string;
-    key: string;
-    value: any;
-}
-export declare class EnvUtil {
-    static NEWLINE: string;
-    static RE_INI_KEY_VAL: RegExp;
-    static RE_NEWLINES: RegExp;
-    static NEWLINES_MATCH: RegExp;
-    static COMMENT_MATCH: RegExp;
-    static getAllChannel(cwd: string, excludeChannels?: string[]): Promise<string[]>;
-    static chooseChannel(cwd: string, excludeChannels?: string[]): Promise<string | undefined>;
-    static withChannel(options: {
-        cwd: string;
-        channel?: string;
-        concurrency?: number;
-        cb: (channel: string | undefined) => any;
-    }): Promise<void>;
-    static getFile(env?: string, channel?: string, noBase?: boolean): string[];
-    static parseContent(src: string, _envItemMap?: Record<string, ParsedEnv>, _envValueMap?: Record<string, any>, channel?: string): ParsedEnv[];
-    static parseFile(options: {
-        cwd: string;
-        file: string[];
-        channel?: string;
-    }): Promise<ParsedEnv[]>;
-    static parseFileAsMap(options: {
-        cwd: string;
-        file: string[];
-        channel?: string;
-    }): Promise<Record<string, any>>;
-    static importFile(options: {
-        cwd: string;
-        file: string[];
-        channel?: string;
-    }): Promise<void>;
-    static makeTypes(envs: ParsedEnv[]): string;
-    static outputTypes(options: {
-        cwd: string;
-        file: string[];
-        outFile: string;
-        channel?: string;
-    }): Promise<void>;
-    private static getTypesFromValue;
-}

package/lib/cli/env_util.js

@@ -1,246 +0,0 @@
-import path from 'node:path';
-import fs from 'fs-extra';
-import globby from 'globby';
-import { pinyin } from 'pinyin-pro';
-import { asyncLimit, castArray, dedent, difference, escapeRegExp, get, isPlainObject, uniq } from 'vtils';
-import { parse as yamlParse } from 'yaml';
-export class EnvUtil {
-  static async getAllChannel(cwd, excludeChannels) {
-    const channelFiles = await globby(['.env@*'], {
-      cwd: 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 undefined;
-    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}>`
-      };
-    });
-    // @ts-ignore
-    const {
-      default: autocomplete
-    } = await import('inquirer-autocomplete-standalone');
-    const selectedChannel = await autocomplete({
-      message: '请选择渠道',
-      source: async input => {
-        return !input ? channelOptions : channelOptions.filter(channelOption => {
-          return channelOption.pinyin.includes(input) || channelOption.name.includes(input);
-        });
-      }
-    });
-    return selectedChannel || undefined;
-  }
-  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 = yamlParse(src);
-    if (channel) {
-      const channelEnvs = envObj.__CHANNEL__;
-      if (channelEnvs && Array.isArray(channelEnvs)) {
-        for (const channelEnv of channelEnvs) {
-          const channels = castArray(channelEnv._).flatMap(item => item.split(','));
-          if (channels.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: key,
-        value: 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 ? undefined : 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;
-  }
-}
-EnvUtil.NEWLINE = '\n';
-EnvUtil.RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/;
-EnvUtil.RE_NEWLINES = /\\n/g;
-EnvUtil.NEWLINES_MATCH = /\r\n|\n|\r/;
-EnvUtil.COMMENT_MATCH = /^#\s*(.+?)\s*$/;

package/lib/cli/esbuild_register.js

@@ -1,5 +0,0 @@
-import { register } from 'esbuild-register/dist/node';
-register({
-  hookIgnoreNodeModules: false,
-  hookMatcher: filename => filename.includes('/.x/') || !filename.includes('/node_modules/')
-});

package/lib/cli/template_util.d.ts

@@ -1,18 +0,0 @@
-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.js

@@ -1,95 +0,0 @@
-import path from 'node:path';
-import fs from 'fs-extra';
-import globby from 'globby';
-import { generateManyIndex } from 'vscode-generate-index-standalone';
-import { camelCase, dedent, snakeCase, upperFirst } from 'vtils';
-export class TemplateUtil {
-  /**
-   * 初始化。
-   */
-  static async init(cwd) {
-    await Promise.all([this.initHelperPackage(cwd), this.initTasks(cwd)]);
-  }
-
-  /**
-   * 初始化辅助包。
-   */
-  static async initHelperPackage(cwd) {
-    const fromDir = path.join(__dirname, 'templates');
-    const toDir = path.join(cwd, 'node_modules/.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);
-      // 对于 models.ts, 项目未使用数据库相关功能时不生成
-      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: cwd,
-      patterns: ['node_modules/.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/.x/models.ts');
-    const prismaClientFile = path.join(cwd, 'node_modules/.x/prisma/internal/prismaNamespace.ts');
-    const prismaClientFileContent = await fs.readFile(prismaClientFile, 'utf8');
-    const modelNames = [...prismaClientFileContent.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: cwd,
-      patterns: [indexFile, indexFile2],
-      replaceFile: true
-    });
-  }
-}

package/lib/core/ctx_storage.d.ts

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

package/lib/core/ctx_storage.js

@@ -1,2 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-export const ctxStorage = new AsyncLocalStorage();

package/lib/core/define_bus.d.ts

@@ -1,37 +0,0 @@
-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.js

@@ -1,27 +0,0 @@
-import { EventEmitter } from 'node:events';
-class EventBus extends EventEmitter {
-  onReturnOff(event, listener) {
-    this.on(event, listener);
-    return () => this.off(event, listener);
-  }
-}
-export function defineBus() {
-  const eventEmitter = new EventBus();
-  return eventEmitter;
-}
-
-// strict-event-emitter-types
-// https://github.com/bterlson/strict-event-emitter-types/blob/9ed45fc68a69f0b7f85ce4e5fe11ff53cc6a009e/src/index.ts
-
-// the overridden signatures need to be assignment compatible, but
-// due to how tuple types work[0] it's not possible to be assignment
-// compatible anymore. This hack fixes it with a unique symbol that
-// won't ever show up in parameter help etc.
-//
-// Unfortunately, this has the result of giving a poor error message when
-// you mix up types.
-// 0: https://github.com/Microsoft/TypeScript/issues/26013)
-
-// TODO: Stash under a symbol key once TS compiler bug is fixed
-
-// EventEmitter method overrides

package/lib/core/define_cron.js

@@ -1,9 +0,0 @@
-import { CronJob } from 'cron';
-export function defineCron(options) {
-  return CronJob.from({
-    cronTime: options.expression,
-    runOnInit: options.runOnInit,
-    start: true,
-    onTick: options.handle
-  });
-}

package/lib/core/define_handler.js

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

package/lib/core/define_hook.d.ts

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

package/lib/core/define_hook.js

@@ -1,4 +0,0 @@
-import { Handler } from "./handler";
-export function defineHook(hook) {
-  Handler.addHook(hook);
-}

package/lib/core/define_server.d.ts

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

package/lib/core/define_server.js

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