@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-HCNMFFG3.js

@@ -0,0 +1,82 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/cli/input-policy.js
+var MAX_BUFFERED_INPUT = 16 * 1024 * 1024;
+var MAX_SECRET_INPUT = 64 * 1024;
+var policies = /* @__PURE__ */ new WeakMap();
+var inputPolicy = /* @__PURE__ */ __name((input) => policies.get(input) ?? {}, "inputPolicy");
+var provideInputPolicy = /* @__PURE__ */ __name((input, policy) => {
+  const previous = policies.get(input);
+  policies.set(input, policy);
+  return () => {
+    if (previous)
+      policies.set(input, previous);
+    else
+      policies.delete(input);
+  };
+}, "provideInputPolicy");
+var bufferedInput = /* @__PURE__ */ __name((input, options = {}) => {
+  const policy = inputPolicy(input);
+  const maxBytes = options.maxBytes ?? policy.maxBytes ?? MAX_BUFFERED_INPUT;
+  const signals = [options.signal, policy.signal].filter((one) => one !== void 0);
+  const signal = signals.length ? AbortSignal.any(signals) : void 0;
+  const state = input;
+  if (state.readableEnded)
+    return Promise.resolve(Buffer.alloc(0));
+  if (state.destroyed)
+    return Promise.reject(new CliError("validation_error", "input closed before EOF", { reason: "input.closed" }));
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    const cleanup = /* @__PURE__ */ __name(() => {
+      input.off("data", data).off("end", end).off("error", error).off("close", closed);
+      signal?.removeEventListener("abort", aborted);
+      input.pause();
+    }, "cleanup");
+    const error = /* @__PURE__ */ __name((cause) => {
+      cleanup();
+      reject(cause);
+    }, "error");
+    const aborted = /* @__PURE__ */ __name(() => error(new CliError("cancelled", "input cancelled", { retryable: false })), "aborted");
+    const closed = /* @__PURE__ */ __name(() => error(new CliError("validation_error", "input closed before EOF", { reason: "input.closed" })), "closed");
+    const end = /* @__PURE__ */ __name(() => {
+      cleanup();
+      resolve(Buffer.concat(chunks, bytes));
+    }, "end");
+    const data = /* @__PURE__ */ __name((chunk) => {
+      const buffer = Buffer.from(chunk);
+      bytes += buffer.length;
+      if (bytes > maxBytes) {
+        error(new CliError("validation_error", `buffered input exceeds ${maxBytes} bytes \u2014 use a smaller input or --max-input-bytes`, {
+          reason: "input.too-large",
+          max_bytes: maxBytes,
+          retryable: false
+        }));
+        return;
+      }
+      chunks.push(buffer);
+    }, "data");
+    if (signal?.aborted) {
+      aborted();
+      return;
+    }
+    input.on("data", data).once("end", end).once("error", error).once("close", closed);
+    signal?.addEventListener("abort", aborted, { once: true });
+    input.resume();
+  });
+}, "bufferedInput");
+
+export {
+  MAX_BUFFERED_INPUT,
+  MAX_SECRET_INPUT,
+  inputPolicy,
+  provideInputPolicy,
+  bufferedInput
+};