@qimen-lab/core 0.1.1

package/dist/task/hash-task/chunk/FileChunkProvider.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileChunkProvider = void 0;
+const fs_1 = require("fs");
+/**
+ * FileChunkProvider 是一个用于将文件分块处理的提供者
+ * 它实现了 ChunkProvider 接口，可以在 Node.js 环境中将大文件切分为小块进行处理
+ */
+class FileChunkProvider {
+    /**
+     * 创建一个 FileChunkProvider 实例
+     * @param filePath - 要分块的文件路径
+     * @param chunkSize - 每个块的大小，默认为 1MB (1024 * 1024 字节)
+     */
+    constructor(filePath, chunkSize = 1024 * 1024) {
+        this.filePath = filePath;
+        this.chunkSize = chunkSize;
+        this.offset = 0;
+        this.chunkIndex = 0;
+        this.fileSize = 0; // ✨ 记录总大小
+    }
+    /**
+     * 确保文件已打开，如果尚未打开则打开文件并获取文件大小
+     * @returns 一个 Promise，当文件打开完成时解析
+     */
+    // ✨ 必须提前获取文件信息
+    async ensureOpened() {
+        if (!this.fd) {
+            this.fd = await fs_1.promises.open(this.filePath, 'r');
+            const stat = await this.fd.stat();
+            this.fileSize = stat.size;
+        }
+    }
+    /**
+     * 检查是否还有剩余的数据未被分块
+     * @returns 如果还有未处理的数据则返回 true，否则返回 false
+     */
+    hasNext() {
+        // 如果还没打开，假设有数据；如果打开了，看 offset
+        return !this.fd || this.offset < this.fileSize;
+    }
+    /**
+     * 获取当前分块的大小
+     * @returns 分块大小（字节数）
+     */
+    getChunkSize() {
+        return this.chunkSize;
+    }
+    /**
+     * 获取文件总大小
+     * @returns 文件总大小（字节数）
+     */
+    getTotalSize() {
+        return this.fileSize;
+    }
+    /**
+     * 获取下一个数据块
+     * @returns 一个 Promise，解析为 Chunk 对象或 null（如果没有更多数据块）
+     */
+    async next() {
+        await this.ensureOpened();
+        if (!this.fd) {
+            this.fd = await fs_1.promises.open(this.filePath, 'r');
+        }
+        const buffer = Buffer.allocUnsafe(this.chunkSize);
+        const { bytesRead } = await this.fd.read(buffer, 0, this.chunkSize, this.offset);
+        if (bytesRead === 0) {
+            await this.fd.close();
+            this.fd = undefined;
+            return null;
+        }
+        const data = buffer.subarray(0, bytesRead);
+        this.offset += bytesRead;
+        return {
+            id: `chunk-${this.chunkIndex++}`,
+            data: data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength),
+        };
+    }
+    /**
+     * 重置分块提供者到初始状态
+     * 将偏移量和块索引重置为 0，以便重新开始分块
+     */
+    reset() {
+        this.offset = 0;
+        this.chunkIndex = 0;
+    }
+}
+exports.FileChunkProvider = FileChunkProvider;
+//# sourceMappingURL=FileChunkProvider.js.map

package/dist/task/hash-task/chunk/FileChunkProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileChunkProvider.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/chunk/FileChunkProvider.ts"],"names":[],"mappings":";;;AACA,2BAAoC;AACpC;;;GAGG;AACH,MAAa,iBAAiB;IAM1B;;;;OAIG;IACH,YACqB,QAAgB,EAChB,YAAoB,IAAI,GAAG,IAAI;QAD/B,aAAQ,GAAR,QAAQ,CAAQ;QAChB,cAAS,GAAT,SAAS,CAAsB;QAX5C,WAAM,GAAG,CAAC,CAAC;QACX,eAAU,GAAG,CAAC,CAAC;QACf,aAAQ,GAAW,CAAC,CAAC,CAAC,UAAU;IAUrC,CAAC;IAEJ;;;OAGG;IACH,eAAe;IACP,KAAK,CAAC,YAAY;QACtB,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YACX,IAAI,CAAC,EAAE,GAAG,MAAM,aAAE,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC5C,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;YAClC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC;QAC9B,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,OAAO;QACH,8BAA8B;QAC9B,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC;IACnD,CAAC;IAED;;;OAGG;IACH,YAAY;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,YAAY;QACR,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI;QACN,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAE1B,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YACX,IAAI,CAAC,EAAE,GAAG,MAAM,aAAE,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAClD,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAEjF,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;YAClB,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;YACtB,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC;YACpB,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,IAAI,SAAS,CAAC;QAEzB,OAAO;YACH,EAAE,EAAE,SAAS,IAAI,CAAC,UAAU,EAAE,EAAE;YAChC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;SAC9E,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,KAAK;QACD,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;IACxB,CAAC;CACJ;AA3FD,8CA2FC"}

package/dist/task/hash-task/chunk/StreamChunkProvider.d.ts

@@ -0,0 +1,43 @@
+/**
+ * StreamChunkProvider 是一个实现 ChunkProvider 接口的类，
+ * 用于从 ReadableStream<Uint8Array> 中读取数据并将其分割成块进行处理。
+ * 主要用于处理流数据，例如文件上传或下载时的数据块处理。
+ */
+import { Chunk, ChunkProvider } from '../types';
+/**
+ * StreamChunkProvider 类实现了 ChunkProvider 接口
+ * 用于从 ReadableStream 中读取数据块
+ */
+export declare class StreamChunkProvider implements ChunkProvider {
+    private readonly estimatedChunkSize;
+    private reader;
+    private chunkIndex;
+    private lastDone;
+    /**
+     * 构造函数
+     * @param stream - 需要处理的 ReadableStream<Uint8Array> 流
+     * @param estimatedChunkSize - 估计的块大小，默认为 1MB
+     */
+    constructor(stream: ReadableStream<Uint8Array>, estimatedChunkSize?: number);
+    /**
+     * 检查是否还有下一个数据块
+     * @returns 如果还有数据块则返回 true，否则返回 false
+     */
+    hasNext(): boolean;
+    /**
+     * 获取估计的块大小
+     * @returns 估计的块大小
+     */
+    getChunkSize(): number;
+    /**
+     * 获取总大小
+     * @returns 对于流来说，总大小通常是未知的，所以返回 undefined
+     */
+    getTotalSize(): undefined;
+    /**
+     * 读取下一个数据块
+     * @returns 返回一个 Promise，解析为下一个数据块或 null（如果流已结束）
+     */
+    next(): Promise<Chunk | null>;
+}
+//# sourceMappingURL=StreamChunkProvider.d.ts.map

package/dist/task/hash-task/chunk/StreamChunkProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamChunkProvider.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/chunk/StreamChunkProvider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEhD;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IAYjD,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAXvC,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;OAIG;gBAEC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EACjB,kBAAkB,GAAE,MAAoB;IAK7D;;;OAGG;IACH,OAAO,IAAI,OAAO;IAIlB;;;OAGG;IACH,YAAY,IAAI,MAAM;IAItB;;;OAGG;IACH,YAAY,IAAI,SAAS;IAIzB;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAgBtC"}

package/dist/task/hash-task/chunk/StreamChunkProvider.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamChunkProvider = void 0;
+/**
+ * StreamChunkProvider 类实现了 ChunkProvider 接口
+ * 用于从 ReadableStream 中读取数据块
+ */
+class StreamChunkProvider {
+    /**
+     * 构造函数
+     * @param stream - 需要处理的 ReadableStream<Uint8Array> 流
+     * @param estimatedChunkSize - 估计的块大小，默认为 1MB
+     */
+    constructor(stream, estimatedChunkSize = 1024 * 1024 // 流通常没有固定 chunk，需指定估值
+    ) {
+        this.estimatedChunkSize = estimatedChunkSize;
+        this.chunkIndex = 0;
+        this.lastDone = false; // 记录流是否结束
+        this.reader = stream.getReader();
+    }
+    /**
+     * 检查是否还有下一个数据块
+     * @returns 如果还有数据块则返回 true，否则返回 false
+     */
+    hasNext() {
+        return !this.lastDone;
+    }
+    /**
+     * 获取估计的块大小
+     * @returns 估计的块大小
+     */
+    getChunkSize() {
+        return this.estimatedChunkSize;
+    }
+    /**
+     * 获取总大小
+     * @returns 对于流来说，总大小通常是未知的，所以返回 undefined
+     */
+    getTotalSize() {
+        return undefined; // 流的大小通常是未知的
+    }
+    /**
+     * 读取下一个数据块
+     * @returns 返回一个 Promise，解析为下一个数据块或 null（如果流已结束）
+     */
+    async next() {
+        const { value, done } = await this.reader.read();
+        if (done || !value) {
+            this.lastDone = true;
+            return null;
+        }
+        return {
+            id: `chunk-${this.chunkIndex++}`,
+            data: value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength),
+        };
+    }
+}
+exports.StreamChunkProvider = StreamChunkProvider;
+//# sourceMappingURL=StreamChunkProvider.js.map

package/dist/task/hash-task/chunk/StreamChunkProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamChunkProvider.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/chunk/StreamChunkProvider.ts"],"names":[],"mappings":";;;AAOA;;;GAGG;AACH,MAAa,mBAAmB;IAK5B;;;;OAIG;IACH,YACI,MAAkC,EACjB,qBAA6B,IAAI,GAAG,IAAI,CAAC,sBAAsB;;QAA/D,uBAAkB,GAAlB,kBAAkB,CAAsB;QAVrD,eAAU,GAAG,CAAC,CAAC;QACf,aAAQ,GAAG,KAAK,CAAC,CAAC,UAAU;QAWhC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,OAAO;QACH,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,YAAY;QACR,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,YAAY;QACR,OAAO,SAAS,CAAC,CAAC,aAAa;IACnC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI;QACN,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAEjD,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,OAAO;YACH,EAAE,EAAE,SAAS,IAAI,CAAC,UAAU,EAAE,EAAE;YAChC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CACpB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CACvB;SACnB,CAAC;IACN,CAAC;CACJ;AA7DD,kDA6DC"}

package/dist/task/hash-task/chunk/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BrowserFileChunkProvider';
+export * from './StreamChunkProvider';
+export * from './FileChunkProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/task/hash-task/chunk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/chunk/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC"}

package/dist/task/hash-task/chunk/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./BrowserFileChunkProvider"), exports);
+__exportStar(require("./StreamChunkProvider"), exports);
+__exportStar(require("./FileChunkProvider"), exports);
+//# sourceMappingURL=index.js.map

package/dist/task/hash-task/chunk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/chunk/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6DAA2C;AAC3C,wDAAsC;AACtC,sDAAoC"}

package/dist/task/hash-task/errors/ResourceNotAcquiredError.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ResourceNotAcquiredError 是一个自定义错误类，
+ * 用于在尝试访问尚未获取的资源时抛出错误。
+ * 这种情况通常发生在资源管理或任务处理过程中，
+ * 当尝试使用尚未正确初始化或获取的资源时会触发此错误。
+ */
+import { ErrorBase } from '@qimenjs/error';
+/**
+ * 资源未获取错误类
+ * 当尝试访问尚未获取的资源时抛出此错误
+ */
+export declare class ResourceNotAcquiredError extends ErrorBase {
+    /**
+     * 构造函数
+     * 创建一个 ResourceNotAcquiredError 实例
+     */
+    constructor();
+}
+//# sourceMappingURL=ResourceNotAcquiredError.d.ts.map

package/dist/task/hash-task/errors/ResourceNotAcquiredError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceNotAcquiredError.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/ResourceNotAcquiredError.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;IACnD;;;OAGG;;CAIN"}

package/dist/task/hash-task/errors/ResourceNotAcquiredError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceNotAcquiredError = void 0;
+/**
+ * ResourceNotAcquiredError 是一个自定义错误类，
+ * 用于在尝试访问尚未获取的资源时抛出错误。
+ * 这种情况通常发生在资源管理或任务处理过程中，
+ * 当尝试使用尚未正确初始化或获取的资源时会触发此错误。
+ */
+const error_1 = require("@qimenjs/error");
+/**
+ * 资源未获取错误类
+ * 当尝试访问尚未获取的资源时抛出此错误
+ */
+class ResourceNotAcquiredError extends error_1.ErrorBase {
+    /**
+     * 构造函数
+     * 创建一个 ResourceNotAcquiredError 实例
+     */
+    constructor() {
+        super('Attempted to access resources before acquisition', 'RESOURCE_NOT_ACQUIRED');
+    }
+}
+exports.ResourceNotAcquiredError = ResourceNotAcquiredError;
+//# sourceMappingURL=ResourceNotAcquiredError.js.map

package/dist/task/hash-task/errors/ResourceNotAcquiredError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceNotAcquiredError.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/ResourceNotAcquiredError.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,MAAa,wBAAyB,SAAQ,iBAAS;IACnD;;;OAGG;IACH;QACI,KAAK,CAAC,kDAAkD,EAAE,uBAAuB,CAAC,CAAC;IACvF,CAAC;CACJ;AARD,4DAQC"}

package/dist/task/hash-task/errors/ResourceUnavailableError.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ResourceUnavailableError 是一个自定义错误类，
+ * 用于在系统资源不可用时抛出错误。
+ * 该错误通常在任务执行过程中检测到关键资源（如内存或工作线程）不足时触发。
+ */
+import { ErrorBase } from '@qimenjs/error';
+/**
+ * 资源不可用错误类
+ * 当指定类型的资源不可用时抛出此错误
+ */
+export declare class ResourceUnavailableError extends ErrorBase {
+    /**
+     * 构造函数
+     * @param resource - 不可用的资源类型，可以是 'memory'（内存）、'worker'（工作线程）或 'all'（全部资源）
+     * @param context - 可选的上下文信息，包含与错误相关的额外数据
+     */
+    constructor(resource: 'memory' | 'worker' | 'all', context?: Record<string, any>);
+}
+//# sourceMappingURL=ResourceUnavailableError.d.ts.map

package/dist/task/hash-task/errors/ResourceUnavailableError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceUnavailableError.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/ResourceUnavailableError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;IACnD;;;;OAIG;gBACS,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAGnF"}

package/dist/task/hash-task/errors/ResourceUnavailableError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceUnavailableError = void 0;
+/**
+ * ResourceUnavailableError 是一个自定义错误类，
+ * 用于在系统资源不可用时抛出错误。
+ * 该错误通常在任务执行过程中检测到关键资源（如内存或工作线程）不足时触发。
+ */
+const error_1 = require("@qimenjs/error");
+/**
+ * 资源不可用错误类
+ * 当指定类型的资源不可用时抛出此错误
+ */
+class ResourceUnavailableError extends error_1.ErrorBase {
+    /**
+     * 构造函数
+     * @param resource - 不可用的资源类型，可以是 'memory'（内存）、'worker'（工作线程）或 'all'（全部资源）
+     * @param context - 可选的上下文信息，包含与错误相关的额外数据
+     */
+    constructor(resource, context) {
+        super(`${resource} unavailable`, 'RESOURCE_UNAVAILABLE', { resource, ...context });
+    }
+}
+exports.ResourceUnavailableError = ResourceUnavailableError;
+//# sourceMappingURL=ResourceUnavailableError.js.map

package/dist/task/hash-task/errors/ResourceUnavailableError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceUnavailableError.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/ResourceUnavailableError.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,MAAa,wBAAyB,SAAQ,iBAAS;IACnD;;;;OAIG;IACH,YAAY,QAAqC,EAAE,OAA6B;QAC5E,KAAK,CAAC,GAAG,QAAQ,cAAc,EAAE,sBAAsB,EAAE,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACvF,CAAC;CACJ;AATD,4DASC"}

package/dist/task/hash-task/errors/TaskStateError.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TaskStateError 是一个自定义错误类，
+ * 用于在任务状态不正确或不一致时抛出错误。
+ * 这种错误通常发生在任务执行过程中，当尝试对任务执行不适当的操作时触发，
+ * 例如尝试取消已完成的任务，或在任务未初始化时开始执行。
+ */
+import { ErrorBase } from '@qimenjs/error';
+/**
+ * 任务状态错误类
+ * 当任务状态不正确或不一致时抛出此错误
+ */
+export declare class TaskStateError extends ErrorBase {
+    /**
+     * 构造函数
+     * @param message - 错误消息，描述导致错误的具体情况
+     * @param context - 可选的上下文信息，包含与错误相关的额外数据
+     */
+    constructor(message: string, context?: Record<string, any>);
+}
+//# sourceMappingURL=TaskStateError.d.ts.map

package/dist/task/hash-task/errors/TaskStateError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskStateError.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/TaskStateError.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS;IACzC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAG7D"}

package/dist/task/hash-task/errors/TaskStateError.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStateError = void 0;
+/**
+ * TaskStateError 是一个自定义错误类，
+ * 用于在任务状态不正确或不一致时抛出错误。
+ * 这种错误通常发生在任务执行过程中，当尝试对任务执行不适当的操作时触发，
+ * 例如尝试取消已完成的任务，或在任务未初始化时开始执行。
+ */
+const error_1 = require("@qimenjs/error");
+/**
+ * 任务状态错误类
+ * 当任务状态不正确或不一致时抛出此错误
+ */
+class TaskStateError extends error_1.ErrorBase {
+    /**
+     * 构造函数
+     * @param message - 错误消息，描述导致错误的具体情况
+     * @param context - 可选的上下文信息，包含与错误相关的额外数据
+     */
+    constructor(message, context) {
+        super(message, 'TASK_STATE_ERROR', context);
+    }
+}
+exports.TaskStateError = TaskStateError;
+//# sourceMappingURL=TaskStateError.js.map

package/dist/task/hash-task/errors/TaskStateError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskStateError.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/TaskStateError.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,MAAa,cAAe,SAAQ,iBAAS;IACzC;;;;OAIG;IACH,YAAY,OAAe,EAAE,OAA6B;QACtD,KAAK,CAAC,OAAO,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;CACJ;AATD,wCASC"}

package/dist/task/hash-task/errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ResourceUnavailableError';
+export * from './ResourceNotAcquiredError';
+export * from './TaskStateError';
+//# sourceMappingURL=index.d.ts.map

package/dist/task/hash-task/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC"}

package/dist/task/hash-task/errors/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./ResourceUnavailableError"), exports);
+__exportStar(require("./ResourceNotAcquiredError"), exports);
+__exportStar(require("./TaskStateError"), exports);
+//# sourceMappingURL=index.js.map

package/dist/task/hash-task/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/task/hash-task/errors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6DAA2C;AAC3C,6DAA2C;AAC3C,mDAAiC"}

package/dist/task/hash-task/factory.d.ts

@@ -0,0 +1,21 @@
+import { HashTask } from './hash';
+/**
+ * 创建哈希任务的工厂函数
+ *
+ * 根据输入类型（File、string或ReadableStream）创建相应的哈希任务
+ *
+ * @param input - 输入数据，可以是File对象、文件路径字符串或ReadableStream
+ * @param algorithm - 哈希算法，可以是字符串（如'sha256'）或自定义哈希函数
+ * @returns 返回配置好的HashTask实例
+ *
+ * @example
+ * ```ts
+ * // 使用内置算法
+ * const task = createHashTask(file, 'sha256');
+ *
+ * // 使用自定义哈希函数
+ * const task = createHashTask(data, (data: ArrayBuffer) => customHashFunction(data));
+ * ```
+ */
+export declare function createHashTask(input: File | string | ReadableStream<Uint8Array>, algorithm: string | ((data: ArrayBuffer) => any)): HashTask;
+//# sourceMappingURL=factory.d.ts.map

package/dist/task/hash-task/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/task/hash-task/factory.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC,EACjD,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,WAAW,KAAK,GAAG,CAAC,YA6BnD"}

package/dist/task/hash-task/factory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHashTask = createHashTask;
+const runtime_1 = require("@/runtime");
+const worker_1 = require("./worker");
+const chunk_1 = require("./chunk");
+const hash_1 = require("./hash");
+/**
+ * 创建哈希任务的工厂函数
+ *
+ * 根据输入类型（File、string或ReadableStream）创建相应的哈希任务
+ *
+ * @param input - 输入数据，可以是File对象、文件路径字符串或ReadableStream
+ * @param algorithm - 哈希算法，可以是字符串（如'sha256'）或自定义哈希函数
+ * @returns 返回配置好的HashTask实例
+ *
+ * @example
+ * ```ts
+ * // 使用内置算法
+ * const task = createHashTask(file, 'sha256');
+ *
+ * // 使用自定义哈希函数
+ * const task = createHashTask(data, (data: ArrayBuffer) => customHashFunction(data));
+ * ```
+ */
+function createHashTask(input, algorithm) {
+    // 1. 初始化工作池和内存管理器
+    const pool = new worker_1.BrowserWorkerPool();
+    const mem = new runtime_1.MemoryManager({ maxBytes: 100 * 1024 * 1024 });
+    // 2. 根据输入类型选择合适的块提供者
+    let provider;
+    if (typeof input === 'string') {
+        // Node.js 环境下的文件路径
+        provider = new chunk_1.FileChunkProvider(input);
+    }
+    else if (input instanceof File || input instanceof Blob) {
+        // 浏览器环境下的文件对象
+        provider = new chunk_1.BrowserFileChunkProvider(input);
+    }
+    else {
+        // 流式输入
+        provider = new chunk_1.StreamChunkProvider(input);
+    }
+    // 3. 实例化哈希任务
+    const task = new hash_1.HashTask({
+        algorithm,
+        workerPool: pool,
+        memoryManager: mem,
+        chunkProvider: provider,
+    });
+    return task;
+}
+//# sourceMappingURL=factory.js.map

package/dist/task/hash-task/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../../src/task/hash-task/factory.ts"],"names":[],"mappings":";;AAwBA,wCA+BC;AAvDD,uCAA0C;AAC1C,qCAA6C;AAC7C,mCAA2F;AAE3F,iCAAkC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,cAAc,CAC1B,KAAiD,EACjD,SAAgD;IAEhD,kBAAkB;IAClB,MAAM,IAAI,GAAG,IAAI,0BAAiB,EAAE,CAAC;IACrC,MAAM,GAAG,GAAG,IAAI,uBAAa,CAAC,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC,CAAC;IAE/D,qBAAqB;IACrB,IAAI,QAAuB,CAAC;IAE5B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,mBAAmB;QACnB,QAAQ,GAAG,IAAI,yBAAiB,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;SAAM,IAAI,KAAK,YAAY,IAAI,IAAI,KAAK,YAAY,IAAI,EAAE,CAAC;QACxD,cAAc;QACd,QAAQ,GAAG,IAAI,gCAAwB,CAAC,KAAK,CAAC,CAAC;IACnD,CAAC;SAAM,CAAC;QACJ,OAAO;QACP,QAAQ,GAAG,IAAI,2BAAmB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,aAAa;IACb,MAAM,IAAI,GAAG,IAAI,eAAQ,CAAC;QACtB,SAAS;QACT,UAAU,EAAE,IAAI;QAChB,aAAa,EAAE,GAAG;QAClB,aAAa,EAAE,QAAQ;KAC1B,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/dist/task/hash-task/hash/HashTask.d.ts

@@ -0,0 +1,129 @@
+import { MemoryManager } from '@/runtime';
+import { ChunkProvider } from '../types';
+import { TaskProgressSnapshot } from './HashTaskProgress';
+import { WorkerPool } from '../worker';
+/**
+ * 进度监听器类型
+ *
+ * 定义了接收进度快照的回调函数类型
+ */
+type ProgressListener = (snapshot: TaskProgressSnapshot) => void;
+/**
+ * 哈希任务选项接口
+ *
+ * 定义了创建哈希任务所需的配置参数
+ */
+export interface HashTaskOptions {
+    /** 哈希算法，可以是字符串（如'sha256'）或自定义哈希函数 */
+    algorithm: ((data: ArrayBuffer) => string | Promise<string>) | string;
+    /** 数据块提供者，用于获取待处理的数据块 */
+    chunkProvider: ChunkProvider;
+    /** 内存管理器，用于管理任务执行过程中的内存使用 */
+    memoryManager: MemoryManager;
+    /** Worker池，用于并行执行哈希计算 */
+    workerPool: WorkerPool;
+    /** 总字节数（可选） */
+    totalBytes?: number;
+}
+/**
+ * 哈希任务类
+ *
+ * 用于处理大文件或数据流的哈希计算任务，支持进度监控、暂停/恢复/取消操作
+ *
+ * 设计原则：
+ * - 仅负责任务的生命周期管理
+ * - 串联各个组件（State, Progress, Resources, Runner）
+ * - 提供统一的外部接口
+ *
+ * 明确不负责：
+ * - 不执行具体的哈希计算（由Runner和Worker负责）
+ * - 不管理内存（由MemoryManager负责）
+ * - 不调度Worker（由WorkerPool负责）
+ *
+ * @example
+ * ```ts
+ * const task = new HashTask({
+ *   algorithm: 'sha256',
+ *   chunkProvider: new FileChunkProvider(file),
+ *   memoryManager: new MemoryManager(),
+ *   workerPool: new BrowserWorkerPool(),
+ * });
+ *
+ * task.onProgress((snapshot) => {
+ *   console.log(`Progress: ${snapshot.percentage}%`);
+ * });
+ *
+ * task.start();
+ * const result = await task.result();
+ * ```
+ */
+export declare class HashTask {
+    private readonly options;
+    private readonly state;
+    private readonly progress;
+    private readonly resources;
+    private readonly runner;
+    private progressListeners;
+    private resultPromise;
+    private resolveResult;
+    private rejectResult;
+    /**
+     * 构造函数
+     *
+     * 初始化哈希任务的各项组件和状态
+     *
+     * @param options 哈希任务配置选项
+     */
+    constructor(options: HashTaskOptions);
+    /**
+     * 启动任务
+     *
+     * 开始执行哈希计算任务，并启动进度轮询机制
+     */
+    start(): Promise<void>;
+    /**
+     * 暂停任务
+     *
+     * 暂停当前正在执行的哈希计算任务
+     */
+    pause(): void;
+    /**
+     * 恢复任务
+     *
+     * 恢复之前暂停的哈希计算任务
+     */
+    resume(): void;
+    /**
+     * 取消任务
+     *
+     * 取消当前正在执行的哈希计算任务
+     */
+    cancel(): void;
+    /**
+     * 获取最终 hash 结果
+     *
+     * 返回一个Promise，当任务完成时包含哈希计算结果
+     *
+     * @returns 包含哈希结果的Promise
+     */
+    result(): Promise<ArrayBuffer>;
+    /**
+     * 订阅进度
+     *
+     * 添加进度监听器，当任务进度更新时会调用监听器
+     *
+     * @param listener 进度监听器函数
+     * @returns 用于取消监听的函数
+     */
+    onProgress(listener: ProgressListener): () => void;
+    /**
+     * 轮询推送进度（简单稳定）
+     *
+     * 启动一个定时器，定期向所有进度监听器发送进度更新
+     *
+     * @private
+     */
+    private startProgressPolling;
+}
+export {};
+//# sourceMappingURL=HashTask.d.ts.map