@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/bun-sqlite-PEJM6CS4.js

@@ -0,0 +1,69 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loadVectorExtension,
+  vectorExtension
+} from "./chunk-YIFIY7ZE.js";
+import "./chunk-YIMI6O7R.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/store/drivers/bun-sqlite.js
+var customised = false;
+var ownLibrary = /* @__PURE__ */ __name(async () => {
+  try {
+    const { libraryFor } = await importFrom(new URL("store/drivers/bun-sqlite.js", import.meta.resolve("@wirecat/cli-core")).href, "@wirecat/cli-core-sqlite");
+    return libraryFor();
+  } catch {
+    return void 0;
+  }
+}, "ownLibrary");
+var bunDatabase = /* @__PURE__ */ __name(async () => {
+  const specifier = "bun:sqlite";
+  const { Database } = await importFrom(new URL("store/drivers/bun-sqlite.js", import.meta.resolve("@wirecat/cli-core")).href, specifier);
+  if (process.platform === "darwin" && !customised) {
+    customised = true;
+    const library = await ownLibrary();
+    if (library)
+      Database.setCustomSQLite(library);
+  }
+  return Database;
+}, "bunDatabase");
+var openWithBunSqlite = /* @__PURE__ */ __name(async (path) => cacheOverBunSqlite(await bunClient(path)), "openWithBunSqlite");
+var bunClient = /* @__PURE__ */ __name(async (path, options) => {
+  const Database = await bunDatabase();
+  const extension = await vectorExtension();
+  const client = options ? new Database(path, options) : new Database(path);
+  try {
+    loadVectorExtension(client, extension);
+    return client;
+  } catch (error) {
+    client.close();
+    throw error;
+  }
+}, "bunClient");
+var cacheOverBunSqlite = /* @__PURE__ */ __name((database) => {
+  return {
+    exec: /* @__PURE__ */ __name((sql) => database.exec(sql), "exec"),
+    prepare: /* @__PURE__ */ __name((sql) => {
+      const statement = database.query(sql);
+      return {
+        run: /* @__PURE__ */ __name((...parameters) => ({ changes: Number(statement.run(...parameters).changes) }), "run"),
+        // Bun answers null for no row; the seam promises undefined, and `!== undefined` checks rely on it.
+        get: /* @__PURE__ */ __name((...parameters) => statement.get(...parameters) ?? void 0, "get"),
+        all: /* @__PURE__ */ __name((...parameters) => statement.all(...parameters), "all")
+      };
+    }, "prepare"),
+    close: /* @__PURE__ */ __name(() => database.close(), "close")
+  };
+}, "cacheOverBunSqlite");
+export {
+  bunClient,
+  bunDatabase,
+  cacheOverBunSqlite,
+  openWithBunSqlite
+};

package/dist/bundle/chunk-24DLFGES.js

@@ -0,0 +1,97 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  checkCancelled
+} from "./chunk-VYUSEJE4.js";
+import {
+  CliError,
+  createOutputBuffer
+} from "./chunk-YIMI6O7R.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/streaming.js
+var writeStream = /* @__PURE__ */ __name((stream, text, signal) => {
+  checkCancelled(signal);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let returned = false;
+    let callbackDone = false;
+    let needsDrain = false;
+    let drained = false;
+    let callbackFailed = false;
+    let errorObserved = false;
+    const outputError = /* @__PURE__ */ __name(() => new CliError("configuration_error", "could not write command output"), "outputError");
+    const removeGuard = /* @__PURE__ */ __name(() => stream.removeListener("error", failed), "removeGuard");
+    const done = /* @__PURE__ */ __name((error) => {
+      if (settled)
+        return;
+      settled = true;
+      stream.removeListener("drain", onDrain);
+      signal.removeEventListener("abort", aborted);
+      if (callbackDone && (!callbackFailed || errorObserved))
+        removeGuard();
+      if (error)
+        reject(error);
+      else
+        resolve();
+    }, "done");
+    const finish = /* @__PURE__ */ __name(() => {
+      if (returned && callbackDone && (!needsDrain || drained))
+        done();
+    }, "finish");
+    const onDrain = /* @__PURE__ */ __name(() => {
+      drained = true;
+      finish();
+    }, "onDrain");
+    const failed = /* @__PURE__ */ __name(() => {
+      errorObserved = true;
+      done(outputError());
+      if (callbackDone)
+        removeGuard();
+    }, "failed");
+    const aborted = /* @__PURE__ */ __name(() => {
+      try {
+        checkCancelled(signal);
+      } catch (error) {
+        done(error);
+      }
+    }, "aborted");
+    signal.addEventListener("abort", aborted, { once: true });
+    stream.on("error", failed);
+    stream.on("drain", onDrain);
+    try {
+      needsDrain = !stream.write(text, (error) => {
+        callbackDone = true;
+        callbackFailed = Boolean(error);
+        if (error)
+          done(outputError());
+        else
+          finish();
+        if (settled && (!callbackFailed || errorObserved))
+          removeGuard();
+      });
+      returned = true;
+      finish();
+    } catch {
+      callbackDone = true;
+      errorObserved = true;
+      done(outputError());
+    }
+  });
+}, "writeStream");
+var emitReceipt = /* @__PURE__ */ __name(async (text, maxOutputBytes, write) => {
+  const output = createOutputBuffer({ maxOutputBytes });
+  output.data(text);
+  let serialized = "";
+  output.flush((chunk) => {
+    serialized += chunk;
+  });
+  await write(serialized);
+}, "emitReceipt");
+
+export {
+  writeStream,
+  emitReceipt
+};