@polka-codes/cli 0.3.2 → 0.3.4

package/dist/thread-stream-worker.js

@@ -0,0 +1,211 @@
+// @bun
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// node_modules/real-require/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var realImport = new Function("modulePath", "return import(modulePath)");
+  function realRequire(modulePath) {
+    if (typeof __non_webpack__require__ === "function") {
+      return __non_webpack__require__(modulePath);
+    }
+    return __require(modulePath);
+  }
+  module.exports = { realImport, realRequire };
+});
+
+// node_modules/thread-stream/lib/indexes.js
+var require_indexes = __commonJS((exports, module) => {
+  var WRITE_INDEX = 4;
+  var READ_INDEX = 8;
+  module.exports = {
+    WRITE_INDEX,
+    READ_INDEX
+  };
+});
+
+// node_modules/thread-stream/lib/wait.js
+var require_wait = __commonJS((exports, module) => {
+  var MAX_TIMEOUT = 1000;
+  function wait(state, index, expected, timeout, done) {
+    const max = Date.now() + timeout;
+    let current = Atomics.load(state, index);
+    if (current === expected) {
+      done(null, "ok");
+      return;
+    }
+    let prior = current;
+    const check = (backoff) => {
+      if (Date.now() > max) {
+        done(null, "timed-out");
+      } else {
+        setTimeout(() => {
+          prior = current;
+          current = Atomics.load(state, index);
+          if (current === prior) {
+            check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : backoff * 2);
+          } else {
+            if (current === expected)
+              done(null, "ok");
+            else
+              done(null, "not-equal");
+          }
+        }, backoff);
+      }
+    };
+    check(1);
+  }
+  function waitDiff(state, index, expected, timeout, done) {
+    const max = Date.now() + timeout;
+    let current = Atomics.load(state, index);
+    if (current !== expected) {
+      done(null, "ok");
+      return;
+    }
+    const check = (backoff) => {
+      if (Date.now() > max) {
+        done(null, "timed-out");
+      } else {
+        setTimeout(() => {
+          current = Atomics.load(state, index);
+          if (current !== expected) {
+            done(null, "ok");
+          } else {
+            check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : backoff * 2);
+          }
+        }, backoff);
+      }
+    };
+    check(1);
+  }
+  module.exports = { wait, waitDiff };
+});
+
+// node_modules/thread-stream/lib/worker.js
+var require_worker = __commonJS(() => {
+  var { realImport, realRequire } = require_src();
+  var { workerData, parentPort } = __require("worker_threads");
+  var { WRITE_INDEX, READ_INDEX } = require_indexes();
+  var { waitDiff } = require_wait();
+  var {
+    dataBuf,
+    filename,
+    stateBuf
+  } = workerData;
+  var destination;
+  var state = new Int32Array(stateBuf);
+  var data = Buffer.from(dataBuf);
+  async function start() {
+    let worker;
+    try {
+      if (filename.endsWith(".ts") || filename.endsWith(".cts")) {
+        if (!process[Symbol.for("ts-node.register.instance")]) {
+          realRequire("ts-node/register");
+        } else if (process.env.TS_NODE_DEV) {
+          realRequire("ts-node-dev");
+        }
+        worker = realRequire(decodeURIComponent(filename.replace(process.platform === "win32" ? "file:///" : "file://", "")));
+      } else {
+        worker = await realImport(filename);
+      }
+    } catch (error) {
+      if ((error.code === "ENOTDIR" || error.code === "ERR_MODULE_NOT_FOUND") && filename.startsWith("file://")) {
+        worker = realRequire(decodeURIComponent(filename.replace("file://", "")));
+      } else if (error.code === undefined || error.code === "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING") {
+        try {
+          worker = realRequire(decodeURIComponent(filename.replace(process.platform === "win32" ? "file:///" : "file://", "")));
+        } catch {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+    if (typeof worker === "object")
+      worker = worker.default;
+    if (typeof worker === "object")
+      worker = worker.default;
+    destination = await worker(workerData.workerData);
+    destination.on("error", function(err) {
+      Atomics.store(state, WRITE_INDEX, -2);
+      Atomics.notify(state, WRITE_INDEX);
+      Atomics.store(state, READ_INDEX, -2);
+      Atomics.notify(state, READ_INDEX);
+      parentPort.postMessage({
+        code: "ERROR",
+        err
+      });
+    });
+    destination.on("close", function() {
+      const end = Atomics.load(state, WRITE_INDEX);
+      Atomics.store(state, READ_INDEX, end);
+      Atomics.notify(state, READ_INDEX);
+      setImmediate(() => {
+        process.exit(0);
+      });
+    });
+  }
+  start().then(function() {
+    parentPort.postMessage({
+      code: "READY"
+    });
+    process.nextTick(run);
+  });
+  function run() {
+    const current = Atomics.load(state, READ_INDEX);
+    const end = Atomics.load(state, WRITE_INDEX);
+    if (end === current) {
+      if (end === data.length) {
+        waitDiff(state, READ_INDEX, end, Infinity, run);
+      } else {
+        waitDiff(state, WRITE_INDEX, end, Infinity, run);
+      }
+      return;
+    }
+    if (end === -1) {
+      destination.end();
+      return;
+    }
+    const toWrite = data.toString("utf8", current, end);
+    const res = destination.write(toWrite);
+    if (res) {
+      Atomics.store(state, READ_INDEX, end);
+      Atomics.notify(state, READ_INDEX);
+      setImmediate(run);
+    } else {
+      destination.once("drain", function() {
+        Atomics.store(state, READ_INDEX, end);
+        Atomics.notify(state, READ_INDEX);
+        run();
+      });
+    }
+  }
+  process.on("unhandledRejection", function(err) {
+    parentPort.postMessage({
+      code: "ERROR",
+      err
+    });
+    process.exit(1);
+  });
+  process.on("uncaughtException", function(err) {
+    parentPort.postMessage({
+      code: "ERROR",
+      err
+    });
+    process.exit(1);
+  });
+  process.once("exit", (exitCode) => {
+    if (exitCode !== 0) {
+      process.exit(exitCode);
+      return;
+    }
+    if (destination?.writableNeedDrain && !destination?.writableEnded) {
+      parentPort.postMessage({
+        code: "WARNING",
+        err: new Error("ThreadStream: process exited before destination stream was drained. this may indicate that the destination stream try to write to a another missing stream")
+      });
+    }
+    process.exit(0);
+  });
+});
+export default require_worker();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "license": "AGPL-3.0",
   "type": "module",
   "bin": {
@@ -12,12 +12,9 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node"
-  },
   "dependencies": {
     "@inquirer/prompts": "^7.2.3",
-    "@polka-codes/core": "0.3.0",
+    "@polka-codes/core": "0.3.3",
     "commander": "^13.0.0",
     "dotenv": "^16.4.7",
     "ignore": "^7.0.3",
@@ -26,7 +23,7 @@
     "yaml": "^2.7.0",
     "zod": "^3.24.1"
   },
-  "files": ["dist", "cli.cjs"],
+  "files": ["dist", "cli.mjs"],
   "devDependencies": {
     "@types/lodash": "^4.17.14"
   }