thread-tasks/dist/index.js

Thread Tasks: Offload your CPU-intensive tasks to separate threads.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/index.ts
var src_exports = {};
__export(src_exports, {
  threadTasks: () => threadTasks,
  threadTasksAdvanced: () => threadTasksAdvanced
});
module.exports = __toCommonJS(src_exports);

// src/thread-tasks.ts
var import_worker_threads = require("worker_threads");
var import_os = require("os");
var import_path = require("path");
var import_typescript = require("typescript");
var workersDirectory = (0, import_path.join)((0, import_os.tmpdir)(), "parallel-workers");
function transpileWorkerFile(wokerCode) {
  return (0, import_typescript.transpile)(wokerCode, {
    allowJs: true,
    target: import_typescript.ScriptTarget.ES2015
  });
}
function createWorkerFile(task, n) {
  return __async(this, null, function* () {
    const fs = yield import("fs");
    const taskStr = task.fn.toString();
    if (!fs.existsSync(workersDirectory)) {
      fs.mkdirSync(workersDirectory, { recursive: true });
    }
    const workerStr = `
  const { workerData, parentPort } = require('worker_threads');

  const runTask = (data) => {
    return new Promise(async function (resolve, reject) {
      try {
        const fn = ${taskStr};
        const result = await fn({ ...data });
        resolve(result);
      } catch (error) {
        reject(error);
      }
    });
  };

  runTask(workerData.data)
    .then(result => parentPort && parentPort.postMessage(result))
    .catch(err => {
      throw err;
    });
  `;
    const workerCode = transpileWorkerFile(workerStr);
    fs.writeFileSync(`${workersDirectory}/worker${n}.js`, workerCode);
  });
}
function deleteWorkerFile(n) {
  return __async(this, null, function* () {
    const filePath = `${workersDirectory}/worker${n}.js`;
    const fs = yield import("fs");
    if (fs.existsSync(filePath)) {
      fs.unlinkSync(filePath);
    }
  });
}
function threadTasks(tasks) {
  return tasks.map((task) => __async(this, null, function* () {
    const randomIdWithTimestamp = Date.now() + Math.floor(Math.random() * 1e3);
    yield createWorkerFile(task, randomIdWithTimestamp);
    const worker = new import_worker_threads.Worker(
      (0, import_path.join)(workersDirectory, `worker${randomIdWithTimestamp}.js`),
      {
        workerData: {
          data: task.args ? __spreadValues({}, task.args) : {}
        }
      }
    );
    worker.on("message", (msg) => __async(this, null, function* () {
      task.onSuccess && (yield task.onSuccess(msg));
      worker.terminate();
      deleteWorkerFile(randomIdWithTimestamp);
    }));
    worker.on("error", (err) => __async(this, null, function* () {
      task.onError && (yield task.onError(err));
      worker.terminate();
      deleteWorkerFile(randomIdWithTimestamp);
    }));
    return worker;
  }));
}
function threadTasksAdvanced({
  tasks,
  getMaxThreads,
  afterAll
}) {
  return new Promise((resolve, reject) => {
    let counter = 0;
    let activeWorkers = 0;
    let maxCpus = null;
    let getThreadCount = getMaxThreads != null ? getMaxThreads : () => {
      if (maxCpus === null) {
        const os = require("os");
        const cpuCount = os.cpus().length;
        maxCpus = cpuCount;
        return cpuCount;
      }
      return maxCpus;
    };
    let threadCount = getThreadCount();
    const interval = setInterval(() => __async(this, null, function* () {
      const maxThreadCount = getThreadCount();
      if (threadCount !== maxThreadCount) {
      }
      threadCount = maxThreadCount;
      if (activeWorkers < maxThreadCount && counter < tasks.length) {
        const task = tasks[counter];
        const randomIdWithTimestamp = Date.now() + Math.floor(Math.random() * 1e3);
        yield createWorkerFile(task, randomIdWithTimestamp);
        const worker = new import_worker_threads.Worker(
          (0, import_path.join)(workersDirectory, `worker${randomIdWithTimestamp}.js`),
          {
            workerData: {
              data: task.args ? __spreadValues({}, task.args) : {}
            }
          }
        );
        counter++;
        activeWorkers++;
        worker.on("message", (msg) => __async(this, null, function* () {
          task.onSuccess && (yield task.onSuccess(msg));
          worker.terminate();
          activeWorkers--;
          deleteWorkerFile(randomIdWithTimestamp);
        }));
        worker.on("error", (err) => __async(this, null, function* () {
          task.onError && (yield task.onError(err));
          worker.terminate();
          activeWorkers--;
          deleteWorkerFile(randomIdWithTimestamp);
        }));
      }
      if (counter === tasks.length && activeWorkers === 0) {
        afterAll && (yield afterAll());
        clearInterval(interval);
        resolve(true);
      }
    }), 1);
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  threadTasks,
  threadTasksAdvanced
});