@midwayjs/piscina 4.0.0-beta.1

package/README.md

@@ -0,0 +1,3 @@
+# @midwayjs/background-task
+
+Execute async tasks in background with Midway Framework.

package/dist/configuration.d.ts

@@ -0,0 +1,6 @@
+import { ILifeCycle, IMidwayContainer } from '@midwayjs/core';
+export declare class PiscinaConfiguration implements ILifeCycle {
+    onReady(container: IMidwayContainer): Promise<void>;
+    onStop(container: IMidwayContainer): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiscinaConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const manager_1 = require("./manager");
+let PiscinaConfiguration = class PiscinaConfiguration {
+    async onReady(container) {
+        await container.getAsync(manager_1.PiscinaServiceFactory);
+    }
+    async onStop(container) {
+        const factory = await container.getAsync(manager_1.PiscinaServiceFactory);
+        await factory.stop();
+    }
+};
+exports.PiscinaConfiguration = PiscinaConfiguration;
+exports.PiscinaConfiguration = PiscinaConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'piscina',
+        importConfigs: [
+            {
+                default: {
+                    piscina: {},
+                    midwayLogger: {
+                        clients: {
+                            piscinaWorkerLogger: {
+                                fileLogName: 'midway-piscina-worker.log',
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+    })
+], PiscinaConfiguration);
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const PISCINA_TASK_KEY = "decorator:piscina_task";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PISCINA_TASK_KEY = void 0;
+exports.PISCINA_TASK_KEY = 'decorator:piscina_task';
+//# sourceMappingURL=constants.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Piscina Task 装饰器
+ * 用于标记 Worker 中的任务类
+ *
+ * @example
+ * ```typescript
+ * @PiscinaTask('calculate')
+ * export class CalculateTask {
+ *   async execute(payload: any) {
+ *     return payload.a + payload.b;
+ *   }
+ * }
+ * ```
+ */
+export declare function PiscinaTask(handler: string): ClassDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiscinaTask = PiscinaTask;
+const core_1 = require("@midwayjs/core");
+const constants_1 = require("./constants");
+/**
+ * Piscina Task 装饰器
+ * 用于标记 Worker 中的任务类
+ *
+ * @example
+ * ```typescript
+ * @PiscinaTask('calculate')
+ * export class CalculateTask {
+ *   async execute(payload: any) {
+ *     return payload.a + payload.b;
+ *   }
+ * }
+ * ```
+ */
+function PiscinaTask(handler) {
+    return (target) => {
+        core_1.DecoratorManager.saveModule(constants_1.PISCINA_TASK_KEY, target);
+        // 保存 handler 名称到元数据
+        core_1.MetadataManager.defineMetadata(constants_1.PISCINA_TASK_KEY, { handler }, target);
+        (0, core_1.Provide)()(target);
+        (0, core_1.Scope)(core_1.ScopeEnum.Request)(target);
+    };
+}
+//# sourceMappingURL=decorator.js.map

package/dist/framework.d.ts

@@ -0,0 +1,23 @@
+import { BaseFramework, IMidwayBootstrapOptions } from '@midwayjs/core';
+import { Application, Context } from './interface';
+/**
+ * Piscina Worker Framework
+ * 用于在 Worker 线程中启动 Midway 应用
+ */
+export declare class PiscinaWorkerFramework extends BaseFramework<Application, Context, any> {
+    protected frameworkLoggerName: string;
+    private taskHandlers;
+    applicationInitialize(options: IMidwayBootstrapOptions): Promise<void>;
+    configure(): {};
+    getFrameworkName(): string;
+    run(): Promise<void>;
+    /**
+     * 根据 handler 名称执行任务
+     */
+    executeTask<T = any, R = any>(handler: string, payload?: T): Promise<R>;
+    /**
+     * 获取所有已注册的 handler
+     */
+    getTaskHandlers(): string[];
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiscinaWorkerFramework = void 0;
+const core_1 = require("@midwayjs/core");
+const constants_1 = require("./constants");
+/**
+ * Piscina Worker Framework
+ * 用于在 Worker 线程中启动 Midway 应用
+ */
+let PiscinaWorkerFramework = class PiscinaWorkerFramework extends core_1.BaseFramework {
+    frameworkLoggerName = 'piscinaWorkerLogger';
+    taskHandlers = new Map();
+    async applicationInitialize(options) {
+        this.app = {};
+    }
+    configure() {
+        return {};
+    }
+    getFrameworkName() {
+        return 'piscinaWorker';
+    }
+    async run() {
+        // 加载所有标记了 @PiscinaTask 的任务类
+        const taskModules = core_1.DecoratorManager.listModule(constants_1.PISCINA_TASK_KEY);
+        for (const module of taskModules) {
+            const metadata = core_1.MetadataManager.getMetadata(constants_1.PISCINA_TASK_KEY, module);
+            if (metadata && metadata.handler) {
+                this.taskHandlers.set(metadata.handler, module);
+            }
+        }
+    }
+    /**
+     * 根据 handler 名称执行任务
+     */
+    async executeTask(handler, payload) {
+        const TaskClass = this.taskHandlers.get(handler);
+        if (!TaskClass) {
+            throw new core_1.MidwayCommonError(`Task handler "${handler}" not found. Did you forget to use @PiscinaTask('${handler}') decorator?`);
+        }
+        const ctx = this.app.createAnonymousContext();
+        const taskInstance = await ctx.requestContext.getAsync(TaskClass);
+        if (!taskInstance || typeof taskInstance.execute !== 'function') {
+            throw new core_1.MidwayCommonError(`Task "${handler}" must implement execute method`);
+        }
+        return await taskInstance.execute(payload);
+    }
+    /**
+     * 获取所有已注册的 handler
+     */
+    getTaskHandlers() {
+        return Array.from(this.taskHandlers.keys());
+    }
+};
+exports.PiscinaWorkerFramework = PiscinaWorkerFramework;
+exports.PiscinaWorkerFramework = PiscinaWorkerFramework = __decorate([
+    (0, core_1.Framework)()
+], PiscinaWorkerFramework);
+//# sourceMappingURL=framework.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { PiscinaConfiguration as Configuration } from './configuration';
+export { PiscinaWorkerFramework as framework } from './framework';
+export * from './manager';
+export * from './decorator';
+export * from './constants';
+export * from './interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.framework = exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.PiscinaConfiguration; } });
+var framework_1 = require("./framework");
+Object.defineProperty(exports, "framework", { enumerable: true, get: function () { return framework_1.PiscinaWorkerFramework; } });
+__exportStar(require("./manager"), exports);
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,27 @@
+import { IMidwayApplication, IMidwayContext, ServiceFactoryConfigOption } from '@midwayjs/core';
+import type { Piscina } from 'piscina';
+/**
+ * Piscina 构造函数选项类型
+ */
+export type PiscinaOptions = Omit<NonNullable<ConstructorParameters<typeof Piscina>[0]>, 'filename'>;
+/**
+ * 单个线程池配置
+ */
+export interface PiscinaPoolConfig extends PiscinaOptions {
+    /**
+     * Worker 文件路径（相对于 baseDir 或绝对路径）
+     */
+    workerFile: string;
+}
+/**
+ * Piscina 组件配置
+ */
+export type PiscinaConfig = ServiceFactoryConfigOption<PiscinaPoolConfig>;
+export interface Application extends IMidwayApplication<IMidwayContext> {
+}
+export interface Context extends IMidwayContext {
+}
+export interface IPiscinaTask<P = unknown, R = unknown> {
+    execute(payload: P): Promise<R>;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/manager.d.ts

@@ -0,0 +1,34 @@
+import { ServiceFactory, ILogger, MidwayEnvironmentService } from '@midwayjs/core';
+import { Piscina } from 'piscina';
+import { PiscinaConfig, PiscinaPoolConfig } from './interface';
+/**
+ * Midway 扩展的 Piscina 类
+ * 继承了原生 Piscina 的所有功能，并添加了 Midway 容器相关方法
+ */
+export declare class MidwayPiscina extends Piscina {
+    /**
+     * 在 Worker 中的 Midway 容器中执行 @PiscinaTask 装饰器任务
+     * @param handler 任务的 handler 名称（对应 @PiscinaTask 装饰器参数）
+     * @param payload 传递给任务的参数
+     * @param options Piscina 运行选项（transferList, signal 等）
+     */
+    runInContainer<T = any, R = any>(handler: string, payload?: T, options?: Parameters<Piscina['run']>[1]): Promise<R>;
+}
+export declare class PiscinaServiceFactory extends ServiceFactory<MidwayPiscina> {
+    protected config: PiscinaConfig;
+    protected logger: ILogger;
+    protected appDir: any;
+    protected environmentService: MidwayEnvironmentService;
+    protected init(): Promise<void>;
+    protected createClient(config: PiscinaPoolConfig, name: string): Promise<MidwayPiscina>;
+    getName(): string;
+    protected destroyClient(pool: MidwayPiscina, name: string): Promise<void>;
+}
+export declare class PiscinaService implements MidwayPiscina {
+    private serviceFactory;
+    private instance;
+    init(): Promise<void>;
+}
+export interface PiscinaService extends MidwayPiscina {
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/manager.js

@@ -0,0 +1,132 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiscinaService = exports.PiscinaServiceFactory = exports.MidwayPiscina = void 0;
+const core_1 = require("@midwayjs/core");
+const piscina_1 = require("piscina");
+const path_1 = require("path");
+/**
+ * Midway 扩展的 Piscina 类
+ * 继承了原生 Piscina 的所有功能，并添加了 Midway 容器相关方法
+ */
+class MidwayPiscina extends piscina_1.Piscina {
+    /**
+     * 在 Worker 中的 Midway 容器中执行 @PiscinaTask 装饰器任务
+     * @param handler 任务的 handler 名称（对应 @PiscinaTask 装饰器参数）
+     * @param payload 传递给任务的参数
+     * @param options Piscina 运行选项（transferList, signal 等）
+     */
+    runInContainer(handler, payload, options) {
+        return this.run({
+            handler: 'defineConfiguration',
+            payload: {
+                handler,
+                data: payload,
+            },
+        }, options);
+    }
+}
+exports.MidwayPiscina = MidwayPiscina;
+let PiscinaServiceFactory = class PiscinaServiceFactory extends core_1.ServiceFactory {
+    config;
+    logger;
+    appDir;
+    environmentService;
+    async init() {
+        await this.initClients(this.config, {
+            concurrent: true,
+        });
+    }
+    async createClient(config, name) {
+        const { workerFile, ...piscinaOptions } = config;
+        if (!workerFile) {
+            throw new core_1.MidwayCommonError(`[midway:piscina] client(${name}) 'workerFile' is required`);
+        }
+        const pool = new MidwayPiscina({
+            ...piscinaOptions,
+            filename: (0, path_1.join)(__dirname, 'worker-bootstrap.js'),
+            workerData: {
+                _fullPath: workerFile,
+                _mainAppDir: this.appDir,
+                _isDevelopmentEnvironment: this.environmentService.isDevelopmentEnvironment(),
+                ...piscinaOptions.workerData,
+            },
+        });
+        this.logger.info(`[midway:piscina] pool(${name}) created with worker: ${workerFile}`);
+        return pool;
+    }
+    getName() {
+        return 'piscina';
+    }
+    async destroyClient(pool, name) {
+        try {
+            if (pool) {
+                await pool.destroy();
+                this.logger.info(`[midway:piscina] pool(${name}) destroyed`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`[midway:piscina] pool(${name}) destroy failed.`, error);
+        }
+    }
+};
+exports.PiscinaServiceFactory = PiscinaServiceFactory;
+__decorate([
+    (0, core_1.Config)('piscina'),
+    __metadata("design:type", Object)
+], PiscinaServiceFactory.prototype, "config", void 0);
+__decorate([
+    (0, core_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], PiscinaServiceFactory.prototype, "logger", void 0);
+__decorate([
+    (0, core_1.Inject)('appDir'),
+    __metadata("design:type", Object)
+], PiscinaServiceFactory.prototype, "appDir", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayEnvironmentService)
+], PiscinaServiceFactory.prototype, "environmentService", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PiscinaServiceFactory.prototype, "init", null);
+exports.PiscinaServiceFactory = PiscinaServiceFactory = __decorate([
+    (0, core_1.Singleton)()
+], PiscinaServiceFactory);
+let PiscinaService = class PiscinaService {
+    serviceFactory;
+    instance;
+    async init() {
+        this.instance = this.serviceFactory.get(this.serviceFactory.getDefaultClientName?.() || 'default');
+        if (!this.instance) {
+            throw new core_1.MidwayCommonError('piscina default instance not found.');
+        }
+    }
+};
+exports.PiscinaService = PiscinaService;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", PiscinaServiceFactory)
+], PiscinaService.prototype, "serviceFactory", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PiscinaService.prototype, "init", null);
+exports.PiscinaService = PiscinaService = __decorate([
+    (0, core_1.Singleton)()
+], PiscinaService);
+(0, core_1.delegateTargetAllPrototypeMethod)(PiscinaService, MidwayPiscina);
+//# sourceMappingURL=manager.js.map

package/dist/worker-bootstrap.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(message: any): Promise<any>;
+export = _exports;
+//# sourceMappingURL=worker-bootstrap.d.ts.map

package/dist/worker-bootstrap.js

@@ -0,0 +1,128 @@
+'use strict';
+const path = require('path');
+const fs = require('fs');
+const { workerData, threadId } = require('worker_threads');
+const { FunctionalConfiguration } = require('@midwayjs/core/functional');
+const { initializeGlobalApplicationContext, MidwayFrameworkService, } = require('@midwayjs/core');
+const { loggers } = require('@midwayjs/logger');
+/**
+ * 解析 worker 文件路径
+ * 支持 .ts 和 .js，自动查找存在的文件
+ */
+function resolveWorkerFile(workerFile) {
+    // 如果路径已经有扩展名且文件存在，直接返回
+    if (fs.existsSync(workerFile)) {
+        return workerFile;
+    }
+    const ext = path.extname(workerFile);
+    const basePath = ext ? workerFile.slice(0, -ext.length) : workerFile;
+    // 尝试的扩展名顺序：.js -> .ts -> .mjs -> .cjs
+    const extensions = ['.js', '.ts', '.mjs', '.cjs'];
+    for (const tryExt of extensions) {
+        const tryPath = basePath + tryExt;
+        if (fs.existsSync(tryPath)) {
+            return tryPath;
+        }
+    }
+    // 都找不到，返回原路径，让 require 报错
+    return workerFile;
+}
+// 从 workerData 获取 fullpath 并加载模块
+const { _fullPath: fullpath, _mainAppDir: mainAppDir, _isDevelopmentEnvironment: isDevelopmentEnvironment, } = workerData || {};
+let workerModule = null;
+let resolvedFile = null;
+let baseDir = null;
+if (isDevelopmentEnvironment) {
+    process.env['MIDWAY_LOGGER_WRITEABLE_DIR'] =
+        process.env['MIDWAY_LOGGER_WRITEABLE_DIR'] ?? mainAppDir;
+}
+if (fullpath) {
+    resolvedFile = resolveWorkerFile(fullpath);
+    baseDir = path.dirname(resolvedFile);
+    // 如果是 .ts 文件，注册 ts-node 以支持 TypeScript
+    if (resolvedFile.endsWith('.ts')) {
+        try {
+            // 查找 worker 目录中的 tsconfig.json
+            const workerTsConfig = path.join(baseDir, 'tsconfig.json');
+            const hasWorkerTsConfig = fs.existsSync(workerTsConfig);
+            /* eslint-disable-next-line node/no-extraneous-require */
+            require('ts-node').register(hasWorkerTsConfig
+                ? { project: workerTsConfig }
+                : {
+                    transpileOnly: true,
+                    compilerOptions: {
+                        module: 'commonjs',
+                        moduleResolution: 'node',
+                    },
+                });
+        }
+        catch (err) {
+            // ts-node 可能不存在（生产环境），忽略错误
+            // 如果真的需要 ts-node 但没安装，后续 require 会失败并报错
+        }
+    }
+    workerModule = require(resolvedFile);
+}
+let applicationContext = null;
+let framework = null;
+/**
+ * Worker Thread 启动入口
+ */
+module.exports = async function workerEntry(message) {
+    const { handler, payload } = message;
+    if (!workerModule) {
+        throw new Error('workerData.fullpath is required');
+    }
+    // 支持 FunctionalConfiguration 的情况
+    if (applicationContext ||
+        workerModule.default instanceof FunctionalConfiguration) {
+        if (!applicationContext) {
+            applicationContext = await initializeGlobalApplicationContext({
+                baseDir,
+                loggerFactory: loggers,
+            });
+            // 获取 PiscinaWorkerFramework
+            const midwayFrameworkService = await applicationContext.getAsync(MidwayFrameworkService);
+            framework = midwayFrameworkService.getMainFramework();
+            if (!framework) {
+                throw new Error('Framework instance not found in application context');
+            }
+            framework
+                .getLogger()
+                .info(`[piscina:worker:${threadId}]: ApplicationContext initialized in worker`);
+        }
+        framework
+            .getLogger()
+            .info(`[piscina:worker:${threadId}]: Executing task handler "${payload.handler}" with payload`, payload.data);
+        // 执行容器中的任务
+        return await framework.executeTask(payload.handler, payload.data);
+    }
+    // 获取处理函数
+    let fn;
+    // 1. 如果指定了 handler，先查找具名导出
+    if (handler && workerModule[handler]) {
+        fn = workerModule[handler];
+    }
+    // 2. 如果没找到，尝试 default export
+    else if (typeof workerModule.default === 'function') {
+        fn = workerModule.default;
+    }
+    // 3. 如果 workerModule 本身是函数（CommonJS）
+    else if (typeof workerModule === 'function') {
+        fn = workerModule;
+    }
+    // 4. 都找不到，报错
+    else {
+        if (handler) {
+            throw new Error(`Handler "${handler}" not found and no default function in "${resolvedFile}"`);
+        }
+        else {
+            throw new Error(`No handler specified and no default function found in "${resolvedFile}"`);
+        }
+    }
+    if (typeof fn !== 'function') {
+        throw new Error(`Handler is not a function in "${resolvedFile}"`);
+    }
+    return await fn(payload);
+};
+//# sourceMappingURL=worker-bootstrap.js.map

package/index.d.ts

@@ -0,0 +1,8 @@
+import { PiscinaConfig } from './dist/index';
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    piscina?: PiscinaConfig;
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@midwayjs/piscina",
+  "version": "4.0.0-beta.1",
+  "description": "Midway Component for Piscina worker thread pool",
+  "main": "dist/index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand",
+    "cov": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand --coverage --forceExit",
+    "ci": "npm run test"
+  },
+  "keywords": [
+    "midway",
+    "component",
+    "piscina",
+    "worker",
+    "thread"
+  ],
+  "author": "Harry Chen <czy88840616@gmail.com>",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@midwayjs/core": "workspace:^",
+    "@midwayjs/logger": "^4.0.0",
+    "@midwayjs/mock": "workspace:^"
+  },
+  "dependencies": {
+    "piscina": "5.1.4"
+  }
+}