@cartesia/cartesia-js 0.0.4-alpha.0 → 1.0.0-alpha.2

package/dist/chunk-KWBSQZTY.js

@@ -0,0 +1,25 @@
+import {
+  WebSocket
+} from "./chunk-3F5E46FT.js";
+import {
+  Client
+} from "./chunk-JGP5BIUV.js";
+
+// src/tts/index.ts
+var TTS = class extends Client {
+  /**
+   * Get a WebSocket client for streaming audio from the TTS API.
+   *
+   * @returns {WebSocket} A Cartesia WebSocket client.
+   */
+  websocket(options) {
+    return new WebSocket(options, {
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl
+    });
+  }
+};
+
+export {
+  TTS
+};

package/dist/chunk-PQ6CIPFW.js

@@ -0,0 +1,120 @@
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-WIFMLPT5.js";
+
+// src/tts/source.ts
+import Emittery from "emittery";
+var _emitter, _buffer, _readIndex, _writeIndex, _closed, _sampleRate;
+var Source = class {
+  /**
+   * Create a new Source.
+   *
+   * @param options - Options for the Source.
+   * @param options.sampleRate - The sample rate of the audio.
+   */
+  constructor({ sampleRate }) {
+    __privateAdd(this, _emitter, new Emittery());
+    __privateAdd(this, _buffer, void 0);
+    __privateAdd(this, _readIndex, 0);
+    __privateAdd(this, _writeIndex, 0);
+    __privateAdd(this, _closed, false);
+    __privateAdd(this, _sampleRate, void 0);
+    this.on = __privateGet(this, _emitter).on.bind(__privateGet(this, _emitter));
+    this.once = __privateGet(this, _emitter).once.bind(__privateGet(this, _emitter));
+    this.events = __privateGet(this, _emitter).events.bind(__privateGet(this, _emitter));
+    this.off = __privateGet(this, _emitter).off.bind(__privateGet(this, _emitter));
+    __privateSet(this, _sampleRate, sampleRate);
+    __privateSet(this, _buffer, new Float32Array(1024));
+  }
+  get sampleRate() {
+    return __privateGet(this, _sampleRate);
+  }
+  /**
+   * Append audio to the buffer.
+   *
+   * @param src The audio to append.
+   */
+  enqueue(src) {
+    return __async(this, null, function* () {
+      const requiredCapacity = __privateGet(this, _writeIndex) + src.length;
+      if (requiredCapacity > __privateGet(this, _buffer).length) {
+        let newCapacity = __privateGet(this, _buffer).length;
+        while (newCapacity < requiredCapacity) {
+          newCapacity *= 2;
+        }
+        const newBuffer = new Float32Array(newCapacity);
+        newBuffer.set(__privateGet(this, _buffer));
+        __privateSet(this, _buffer, newBuffer);
+      }
+      __privateGet(this, _buffer).set(src, __privateGet(this, _writeIndex));
+      __privateSet(this, _writeIndex, __privateGet(this, _writeIndex) + src.length);
+      yield __privateGet(this, _emitter).emit("enqueue");
+    });
+  }
+  /**
+   * Read audio from the buffer.
+   *
+   * @param dst The buffer to read the audio into.
+   * @returns The number of samples read. If the source is closed, this will be
+   * less than the length of the provided buffer.
+   */
+  read(dst) {
+    return __async(this, null, function* () {
+      const targetReadIndex = __privateGet(this, _readIndex) + dst.length;
+      while (!__privateGet(this, _closed) && targetReadIndex > __privateGet(this, _writeIndex)) {
+        yield __privateGet(this, _emitter).emit("wait");
+        yield Promise.race([
+          __privateGet(this, _emitter).once("enqueue"),
+          __privateGet(this, _emitter).once("close")
+        ]);
+        yield __privateGet(this, _emitter).emit("read");
+      }
+      const read = Math.min(dst.length, __privateGet(this, _writeIndex) - __privateGet(this, _readIndex));
+      dst.set(__privateGet(this, _buffer).subarray(__privateGet(this, _readIndex), __privateGet(this, _readIndex) + read));
+      __privateSet(this, _readIndex, __privateGet(this, _readIndex) + read);
+      return read;
+    });
+  }
+  /**
+   * Get the number of samples in a given duration.
+   *
+   * @param durationSecs The duration in seconds.
+   * @returns The number of samples.
+   */
+  durationToSampleCount(durationSecs) {
+    return Math.trunc(durationSecs * __privateGet(this, _sampleRate));
+  }
+  get buffer() {
+    return __privateGet(this, _buffer);
+  }
+  get readIndex() {
+    return __privateGet(this, _readIndex);
+  }
+  /**
+   * Close the source. This signals that no more audio will be enqueued.
+   *
+   * This will emit a "close" event.
+   *
+   * @returns A promise that resolves when the source is closed.
+   */
+  close() {
+    return __async(this, null, function* () {
+      __privateSet(this, _closed, true);
+      yield __privateGet(this, _emitter).emit("close");
+      __privateGet(this, _emitter).clearListeners();
+    });
+  }
+};
+_emitter = new WeakMap();
+_buffer = new WeakMap();
+_readIndex = new WeakMap();
+_writeIndex = new WeakMap();
+_closed = new WeakMap();
+_sampleRate = new WeakMap();
+
+export {
+  Source
+};

package/dist/chunk-RO7TY474.js

@@ -0,0 +1,81 @@
+// src/tts/utils.ts
+import base64 from "base64-js";
+function base64ToArray(b64) {
+  const byteArrays = filterSentinel(b64).map((b) => base64.toByteArray(b));
+  const totalLength = byteArrays.reduce(
+    (acc, arr) => acc + arr.length / Float32Array.BYTES_PER_ELEMENT,
+    0
+  );
+  const result = new Float32Array(totalLength);
+  let offset = 0;
+  for (const arr of byteArrays) {
+    const floats = new Float32Array(arr.buffer);
+    result.set(floats, offset);
+    offset += floats.length;
+  }
+  return result;
+}
+function playAudioBuffer(floats, context, startAt, sampleRate) {
+  const source = context.createBufferSource();
+  const buffer = context.createBuffer(1, floats.length, sampleRate);
+  buffer.getChannelData(0).set(floats);
+  source.buffer = buffer;
+  source.connect(context.destination);
+  source.start(startAt);
+  return new Promise((resolve) => {
+    source.onended = () => {
+      resolve();
+    };
+  });
+}
+function createMessageHandlerForContextId(contextId, handler) {
+  return (event) => {
+    if (typeof event.data !== "string") {
+      return;
+    }
+    const message = JSON.parse(event.data);
+    if (message.context_id !== contextId) {
+      return;
+    }
+    let chunk;
+    if (message.done) {
+      chunk = getSentinel();
+    } else {
+      chunk = message.data;
+    }
+    handler({ chunk, message: event.data });
+  };
+}
+function getSentinel() {
+  return null;
+}
+function isSentinel(x) {
+  return x === getSentinel();
+}
+function filterSentinel(collection) {
+  return collection.filter(
+    (x) => !isSentinel(x)
+  );
+}
+function isComplete(chunks) {
+  return isSentinel(chunks[chunks.length - 1]);
+}
+function getEmitteryCallbacks(emitter) {
+  return {
+    on: emitter.on.bind(emitter),
+    off: emitter.off.bind(emitter),
+    once: emitter.once.bind(emitter),
+    events: emitter.events.bind(emitter)
+  };
+}
+
+export {
+  base64ToArray,
+  playAudioBuffer,
+  createMessageHandlerForContextId,
+  getSentinel,
+  isSentinel,
+  filterSentinel,
+  isComplete,
+  getEmitteryCallbacks
+};

package/dist/chunk-T3RG6WV4.js

@@ -0,0 +1,22 @@
+import {
+  Voices
+} from "./chunk-WVTITUXX.js";
+import {
+  TTS
+} from "./chunk-KWBSQZTY.js";
+import {
+  Client
+} from "./chunk-JGP5BIUV.js";
+
+// src/lib/index.ts
+var Cartesia = class extends Client {
+  constructor(options = {}) {
+    super(options);
+    this.tts = new TTS(options);
+    this.voices = new Voices(options);
+  }
+};
+
+export {
+  Cartesia
+};

package/dist/{chunk-R4P7LWVZ.js → chunk-WIFMLPT5.js}

@@ -1,10 +1,9 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => {
-  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-};
 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 = {}))
@@ -17,6 +16,29 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -37,10 +59,13 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 
 export {
   __spreadValues,
-  __async,
-  __forAwait
+  __spreadProps,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __async
 };

package/dist/chunk-WVTITUXX.js

@@ -0,0 +1,58 @@
+import {
+  Client
+} from "./chunk-JGP5BIUV.js";
+import {
+  __async
+} from "./chunk-WIFMLPT5.js";
+
+// src/voices/index.ts
+var Voices = class extends Client {
+  list() {
+    return __async(this, null, function* () {
+      const response = yield this.fetch("/voices");
+      return response.json();
+    });
+  }
+  get(voiceId) {
+    return __async(this, null, function* () {
+      const response = yield this.fetch(`/voices/${voiceId}`);
+      return response.json();
+    });
+  }
+  create(voice) {
+    return __async(this, null, function* () {
+      const response = yield this.fetch("/voices", {
+        method: "POST",
+        body: JSON.stringify(voice)
+      });
+      return response.json();
+    });
+  }
+  clone(options) {
+    return __async(this, null, function* () {
+      if (options.mode === "url") {
+        const response = yield this.fetch(
+          `/voices/clone/url?link=${options.link}`,
+          {
+            method: "POST"
+          }
+        );
+        return response.json();
+      }
+      if (options.mode === "clip") {
+        const formData = new FormData();
+        formData.append("clip", options.clip);
+        const response = yield this.fetch("/voices/clone/clip", {
+          method: "POST",
+          body: formData
+        });
+        return response.json();
+      }
+      throw new Error("Invalid mode for clone()");
+    });
+  }
+};
+
+export {
+  Voices
+};

package/dist/chunk-XHTDPLFR.js

@@ -0,0 +1,19 @@
+// src/lib/constants.ts
+var BASE_URL = "https://api.cartesia.ai/";
+var CARTESIA_VERSION = "2024-06-10";
+var constructApiUrl = (baseUrl, path, protocol) => {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  if (!protocol) {
+    return new URL(`${baseUrl}${normalizedPath}`);
+  }
+  if (!["http", "ws"].includes(protocol)) {
+    throw new Error(`Invalid protocol: ${protocol}`);
+  }
+  return new URL(`${baseUrl.replace(/^http/, protocol)}${normalizedPath}`);
+};
+
+export {
+  BASE_URL,
+  CARTESIA_VERSION,
+  constructApiUrl
+};