opik 0.0.1

package/dist/Node18UniversalStreamWrapper-5PLK6H2I.js

@@ -0,0 +1,216 @@
+import "./chunk-MLKGABMK.js";
+
+// src/opik/rest_api/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.ts
+var Node18UniversalStreamWrapper = class _Node18UniversalStreamWrapper {
+  constructor(readableStream) {
+    this.readableStream = readableStream;
+    this.reader = this.readableStream.getReader();
+    this.events = {
+      data: [],
+      end: [],
+      error: [],
+      readable: [],
+      close: [],
+      pause: [],
+      resume: []
+    };
+    this.paused = false;
+    this.resumeCallback = null;
+    this.encoding = null;
+  }
+  on(event, callback) {
+    var _a;
+    (_a = this.events[event]) == null ? void 0 : _a.push(callback);
+  }
+  off(event, callback) {
+    var _a;
+    this.events[event] = (_a = this.events[event]) == null ? void 0 : _a.filter((cb) => cb !== callback);
+  }
+  pipe(dest) {
+    this.on("data", async (chunk) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._write(chunk);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      } else {
+        dest.write(chunk);
+      }
+    });
+    this.on("end", async () => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._end();
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.close();
+      } else {
+        dest.end();
+      }
+    });
+    this.on("error", async (error) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._error(error);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      } else {
+        dest.destroy(error);
+      }
+    });
+    this._startReading();
+    return dest;
+  }
+  pipeTo(dest) {
+    return this.pipe(dest);
+  }
+  unpipe(dest) {
+    this.off("data", async (chunk) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._write(chunk);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      } else {
+        dest.write(chunk);
+      }
+    });
+    this.off("end", async () => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._end();
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.close();
+      } else {
+        dest.end();
+      }
+    });
+    this.off("error", async (error) => {
+      if (dest instanceof _Node18UniversalStreamWrapper) {
+        dest._error(error);
+      } else if (dest instanceof WritableStream) {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      } else {
+        dest.destroy(error);
+      }
+    });
+  }
+  destroy(error) {
+    this.reader.cancel(error).then(() => {
+      this._emit("close");
+    }).catch((err) => {
+      this._emit("error", err);
+    });
+  }
+  pause() {
+    this.paused = true;
+    this._emit("pause");
+  }
+  resume() {
+    if (this.paused) {
+      this.paused = false;
+      this._emit("resume");
+      if (this.resumeCallback) {
+        this.resumeCallback();
+        this.resumeCallback = null;
+      }
+    }
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  async read() {
+    if (this.paused) {
+      await new Promise((resolve) => {
+        this.resumeCallback = resolve;
+      });
+    }
+    const { done, value } = await this.reader.read();
+    if (done) {
+      return void 0;
+    }
+    return value;
+  }
+  setEncoding(encoding) {
+    this.encoding = encoding;
+  }
+  async text() {
+    const chunks = [];
+    while (true) {
+      const { done, value } = await this.reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        chunks.push(value);
+      }
+    }
+    const decoder = new TextDecoder(this.encoding || "utf-8");
+    return decoder.decode(await new Blob(chunks).arrayBuffer());
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  _write(chunk) {
+    this._emit("data", chunk);
+  }
+  _end() {
+    this._emit("end");
+  }
+  _error(error) {
+    this._emit("error", error);
+  }
+  _emit(event, data) {
+    if (this.events[event]) {
+      for (const callback of this.events[event] || []) {
+        callback(data);
+      }
+    }
+  }
+  async _startReading() {
+    try {
+      this._emit("readable");
+      while (true) {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          this._emit("end");
+          this._emit("close");
+          break;
+        }
+        if (value) {
+          this._emit("data", value);
+        }
+      }
+    } catch (error) {
+      this._emit("error", error);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+};
+export {
+  Node18UniversalStreamWrapper
+};

package/dist/NodePre18StreamWrapper-PJE27LW2.js

@@ -0,0 +1,88 @@
+import "./chunk-MLKGABMK.js";
+
+// src/opik/rest_api/core/fetcher/stream-wrappers/NodePre18StreamWrapper.ts
+var NodePre18StreamWrapper = class {
+  constructor(readableStream) {
+    this.readableStream = readableStream;
+  }
+  on(event, callback) {
+    this.readableStream.on(event, callback);
+  }
+  off(event, callback) {
+    this.readableStream.off(event, callback);
+  }
+  pipe(dest) {
+    this.readableStream.pipe(dest);
+    return dest;
+  }
+  pipeTo(dest) {
+    return this.pipe(dest);
+  }
+  unpipe(dest) {
+    if (dest) {
+      this.readableStream.unpipe(dest);
+    } else {
+      this.readableStream.unpipe();
+    }
+  }
+  destroy(error) {
+    this.readableStream.destroy(error);
+  }
+  pause() {
+    this.readableStream.pause();
+  }
+  resume() {
+    this.readableStream.resume();
+  }
+  get isPaused() {
+    return this.readableStream.isPaused();
+  }
+  async read() {
+    return new Promise((resolve, reject) => {
+      const chunk = this.readableStream.read();
+      if (chunk) {
+        resolve(chunk);
+      } else {
+        this.readableStream.once("readable", () => {
+          const chunk2 = this.readableStream.read();
+          resolve(chunk2);
+        });
+        this.readableStream.once("error", reject);
+      }
+    });
+  }
+  setEncoding(encoding) {
+    this.readableStream.setEncoding(encoding);
+    this.encoding = encoding;
+  }
+  async text() {
+    const chunks = [];
+    const encoder = new TextEncoder();
+    this.readableStream.setEncoding(this.encoding || "utf-8");
+    for await (const chunk of this.readableStream) {
+      chunks.push(encoder.encode(chunk));
+    }
+    const decoder = new TextDecoder(this.encoding || "utf-8");
+    return decoder.decode(Buffer.concat(chunks));
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  [Symbol.asyncIterator]() {
+    const readableStream = this.readableStream;
+    const iterator = readableStream[Symbol.asyncIterator]();
+    return {
+      async next() {
+        const { value, done } = await iterator.next();
+        return { value, done };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+};
+export {
+  NodePre18StreamWrapper
+};

package/dist/UndiciStreamWrapper-M2WUKUR4.js

@@ -0,0 +1,204 @@
+import "./chunk-MLKGABMK.js";
+
+// src/opik/rest_api/core/fetcher/stream-wrappers/UndiciStreamWrapper.ts
+var UndiciStreamWrapper = class _UndiciStreamWrapper {
+  constructor(readableStream) {
+    this.readableStream = readableStream;
+    this.reader = this.readableStream.getReader();
+    this.events = {
+      data: [],
+      end: [],
+      error: [],
+      readable: [],
+      close: [],
+      pause: [],
+      resume: []
+    };
+    this.paused = false;
+    this.resumeCallback = null;
+    this.encoding = null;
+  }
+  on(event, callback) {
+    var _a;
+    (_a = this.events[event]) == null ? void 0 : _a.push(callback);
+  }
+  off(event, callback) {
+    var _a;
+    this.events[event] = (_a = this.events[event]) == null ? void 0 : _a.filter((cb) => cb !== callback);
+  }
+  pipe(dest) {
+    this.on("data", (chunk) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._write(chunk);
+      } else {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      }
+    });
+    this.on("end", () => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._end();
+      } else {
+        const writer = dest.getWriter();
+        writer.close();
+      }
+    });
+    this.on("error", (error) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._error(error);
+      } else {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      }
+    });
+    this._startReading();
+    return dest;
+  }
+  pipeTo(dest) {
+    return this.pipe(dest);
+  }
+  unpipe(dest) {
+    this.off("data", (chunk) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._write(chunk);
+      } else {
+        const writer = dest.getWriter();
+        writer.write(chunk).then(() => writer.releaseLock());
+      }
+    });
+    this.off("end", () => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._end();
+      } else {
+        const writer = dest.getWriter();
+        writer.close();
+      }
+    });
+    this.off("error", (error) => {
+      if (dest instanceof _UndiciStreamWrapper) {
+        dest._error(error);
+      } else {
+        const writer = dest.getWriter();
+        writer.abort(error);
+      }
+    });
+  }
+  destroy(error) {
+    this.reader.cancel(error).then(() => {
+      this._emit("close");
+    }).catch((err) => {
+      this._emit("error", err);
+    });
+  }
+  pause() {
+    this.paused = true;
+    this._emit("pause");
+  }
+  resume() {
+    if (this.paused) {
+      this.paused = false;
+      this._emit("resume");
+      if (this.resumeCallback) {
+        this.resumeCallback();
+        this.resumeCallback = null;
+      }
+    }
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  async read() {
+    if (this.paused) {
+      await new Promise((resolve) => {
+        this.resumeCallback = resolve;
+      });
+    }
+    const { done, value } = await this.reader.read();
+    if (done) {
+      return void 0;
+    }
+    return value;
+  }
+  setEncoding(encoding) {
+    this.encoding = encoding;
+  }
+  async text() {
+    const chunks = [];
+    while (true) {
+      const { done, value } = await this.reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        chunks.push(value);
+      }
+    }
+    const decoder = new TextDecoder(this.encoding || "utf-8");
+    return decoder.decode(await new Blob(chunks).arrayBuffer());
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  _write(chunk) {
+    this._emit("data", chunk);
+  }
+  _end() {
+    this._emit("end");
+  }
+  _error(error) {
+    this._emit("error", error);
+  }
+  _emit(event, data) {
+    if (this.events[event]) {
+      for (const callback of this.events[event] || []) {
+        callback(data);
+      }
+    }
+  }
+  async _startReading() {
+    try {
+      this._emit("readable");
+      while (true) {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          this._emit("end");
+          this._emit("close");
+          break;
+        }
+        if (value) {
+          this._emit("data", value);
+        }
+      }
+    } catch (error) {
+      this._emit("error", error);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.paused) {
+          await new Promise((resolve) => {
+            this.resumeCallback = resolve;
+          });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+};
+export {
+  UndiciStreamWrapper
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};