@cartesia/cartesia-js 1.0.0 → 1.0.2

package/dist/react/index.cjs

@@ -22,6 +22,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -111,20 +123,25 @@ var constructApiUrl = (baseUrl, path, { websocket = false } = {}) => {
 // src/lib/client.ts
 var Client = class {
   constructor(options = {}) {
-    if (!(options.apiKey || process.env.CARTESIA_API_KEY)) {
+    const apiKey = options.apiKey || process.env.CARTESIA_API_KEY;
+    if (!apiKey) {
       throw new Error("Missing Cartesia API key.");
     }
-    this.apiKey = options.apiKey || process.env.CARTESIA_API_KEY;
+    this.apiKey = typeof apiKey === "function" ? apiKey : () => __async(this, null, function* () {
+      return apiKey;
+    });
     this.baseUrl = options.baseUrl || BASE_URL;
   }
-  fetch(path, options = {}) {
-    const url = constructApiUrl(this.baseUrl, path);
-    return (0, import_cross_fetch.default)(url.toString(), __spreadProps(__spreadValues({}, options), {
-      headers: __spreadValues({
-        "X-API-Key": this.apiKey,
-        "Cartesia-Version": CARTESIA_VERSION
-      }, options.headers)
-    }));
+  _fetch(_0) {
+    return __async(this, arguments, function* (path, options = {}) {
+      const url = constructApiUrl(this.baseUrl, path);
+      const headers = new Headers(options.headers);
+      headers.set("X-API-Key", yield this.apiKey());
+      headers.set("Cartesia-Version", CARTESIA_VERSION);
+      return (0, import_cross_fetch.default)(url.toString(), __spreadProps(__spreadValues({}, options), {
+        headers
+      }));
+    });
   }
 };
 
@@ -135,7 +152,13 @@ var import_partysocket = require("partysocket");
 
 // src/tts/source.ts
 var import_emittery = __toESM(require("emittery"), 1);
-var _emitter, _buffer, _readIndex, _writeIndex, _closed, _sampleRate;
+var ENCODING_MAP = {
+  pcm_f32le: { arrayType: Float32Array, bytesPerElement: 4 },
+  pcm_s16le: { arrayType: Int16Array, bytesPerElement: 2 },
+  pcm_alaw: { arrayType: Uint8Array, bytesPerElement: 1 },
+  pcm_mulaw: { arrayType: Uint8Array, bytesPerElement: 1 }
+};
+var _emitter, _buffer, _readIndex, _writeIndex, _closed, _sampleRate, _encoding, _container, _createBuffer, createBuffer_fn;
 var Source = class {
   /**
    * Create a new Source.
@@ -143,23 +166,44 @@ var Source = class {
    * @param options - Options for the Source.
    * @param options.sampleRate - The sample rate of the audio.
    */
-  constructor({ sampleRate }) {
+  constructor({
+    sampleRate,
+    encoding,
+    container
+  }) {
+    /**
+     * Create a new buffer for the source.
+     *
+     * @param size - The size of the buffer to create.
+     * @returns The new buffer as a TypedArray based on the encoding.
+     */
+    __privateAdd(this, _createBuffer);
     __privateAdd(this, _emitter, new import_emittery.default());
     __privateAdd(this, _buffer, void 0);
     __privateAdd(this, _readIndex, 0);
     __privateAdd(this, _writeIndex, 0);
     __privateAdd(this, _closed, false);
     __privateAdd(this, _sampleRate, void 0);
+    __privateAdd(this, _encoding, void 0);
+    __privateAdd(this, _container, 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));
+    __privateSet(this, _encoding, encoding);
+    __privateSet(this, _container, container);
+    __privateSet(this, _buffer, __privateMethod(this, _createBuffer, createBuffer_fn).call(this, 1024));
   }
   get sampleRate() {
     return __privateGet(this, _sampleRate);
   }
+  get encoding() {
+    return __privateGet(this, _encoding);
+  }
+  get container() {
+    return __privateGet(this, _container);
+  }
   /**
    * Append audio to the buffer.
    *
@@ -173,7 +217,7 @@ var Source = class {
         while (newCapacity < requiredCapacity) {
           newCapacity *= 2;
         }
-        const newBuffer = new Float32Array(newCapacity);
+        const newBuffer = __privateMethod(this, _createBuffer, createBuffer_fn).call(this, newCapacity);
         newBuffer.set(__privateGet(this, _buffer));
         __privateSet(this, _buffer, newBuffer);
       }
@@ -221,6 +265,9 @@ var Source = class {
   get readIndex() {
     return __privateGet(this, _readIndex);
   }
+  get writeIndex() {
+    return __privateGet(this, _writeIndex);
+  }
   /**
    * Close the source. This signals that no more audio will be enqueued.
    *
@@ -242,19 +289,27 @@ _readIndex = new WeakMap();
 _writeIndex = new WeakMap();
 _closed = new WeakMap();
 _sampleRate = new WeakMap();
+_encoding = new WeakMap();
+_container = new WeakMap();
+_createBuffer = new WeakSet();
+createBuffer_fn = function(size) {
+  const { arrayType: ArrayType } = ENCODING_MAP[__privateGet(this, _encoding)];
+  return new ArrayType(size);
+};
 
 // src/tts/utils.ts
 var import_base64_js = __toESM(require("base64-js"), 1);
-function base64ToArray(b64) {
+function base64ToArray(b64, encoding) {
   const byteArrays = filterSentinel(b64).map((b) => import_base64_js.default.toByteArray(b));
+  const { arrayType: ArrayType, bytesPerElement } = ENCODING_MAP[encoding];
   const totalLength = byteArrays.reduce(
-    (acc, arr) => acc + arr.length / Float32Array.BYTES_PER_ELEMENT,
+    (acc, arr) => acc + arr.length / bytesPerElement,
     0
   );
-  const result = new Float32Array(totalLength);
+  const result = new ArrayType(totalLength);
   let offset = 0;
   for (const arr of byteArrays) {
-    const floats = new Float32Array(arr.buffer);
+    const floats = new ArrayType(arr.buffer);
     result.set(floats, offset);
     offset += floats.length;
   }
@@ -285,10 +340,10 @@ function createMessageHandlerForContextId(contextId, handler) {
     let chunk;
     if (message.done) {
       chunk = getSentinel();
-    } else {
+    } else if (message.type === "chunk") {
       chunk = message.data;
     }
-    handler({ chunk, message: event.data });
+    handler({ chunk, message: event.data, data: message });
   };
 }
 function getSentinel() {
@@ -312,14 +367,14 @@ function getEmitteryCallbacks(emitter) {
 }
 
 // src/tts/websocket.ts
-var _isConnected, _sampleRate2, _generateId, generateId_fn;
+var _isConnected, _sampleRate2, _container2, _encoding2, _generateId, generateId_fn;
 var WebSocket = class extends Client {
   /**
    * Create a new WebSocket client.
    *
    * @param args - Arguments to pass to the Client constructor.
    */
-  constructor({ sampleRate }, ...args) {
+  constructor({ sampleRate, container, encoding }, ...args) {
     super(...args);
     /**
      * Generate a unique ID suitable for a streaming context.
@@ -332,12 +387,16 @@ var WebSocket = class extends Client {
     __privateAdd(this, _generateId);
     __privateAdd(this, _isConnected, false);
     __privateAdd(this, _sampleRate2, void 0);
+    __privateAdd(this, _container2, void 0);
+    __privateAdd(this, _encoding2, void 0);
     __privateSet(this, _sampleRate2, sampleRate);
+    __privateSet(this, _container2, container != null ? container : "raw");
+    __privateSet(this, _encoding2, encoding != null ? encoding : "pcm_f32le");
   }
   /**
    * Send a message over the WebSocket to start a stream.
    *
-   * @param inputs - Stream options.
+   * @param inputs - Stream options. Defined in the StreamRequest type.
    * @param options - Options for the stream.
    * @param options.timeout - The maximum time to wait for a chunk before cancelling the stream.
    *                          If set to `0`, the stream will not time out.
@@ -345,26 +404,30 @@ var WebSocket = class extends Client {
    * @returns An Emittery instance that emits messages from the WebSocket.
    * @returns An abort function that can be called to cancel the stream.
    */
-  send(inputs, { timeout = 0 } = {}) {
-    var _a, _b, _c, _d;
+  send(_a, { timeout = 0 } = {}) {
+    var inputs = __objRest(_a, []);
+    var _a2, _b, _c, _d;
     if (!__privateGet(this, _isConnected)) {
       throw new Error("Not connected to WebSocket. Call .connect() first.");
     }
-    const contextId = __privateMethod(this, _generateId, generateId_fn).call(this);
-    (_a = this.socket) == null ? void 0 : _a.send(
-      JSON.stringify(__spreadProps(__spreadValues({
-        context_id: contextId
-      }, inputs), {
-        output_format: {
-          container: "raw",
-          encoding: "pcm_f32le",
-          sample_rate: __privateGet(this, _sampleRate2)
-        }
-      }))
+    if (!inputs.context_id) {
+      inputs.context_id = __privateMethod(this, _generateId, generateId_fn).call(this);
+    }
+    if (!inputs.output_format) {
+      inputs.output_format = {
+        container: __privateGet(this, _container2),
+        encoding: __privateGet(this, _encoding2),
+        sample_rate: __privateGet(this, _sampleRate2)
+      };
+    }
+    (_a2 = this.socket) == null ? void 0 : _a2.send(
+      JSON.stringify(__spreadValues({}, inputs))
     );
     const emitter = new import_emittery2.default();
     const source = new Source({
-      sampleRate: __privateGet(this, _sampleRate2)
+      sampleRate: __privateGet(this, _sampleRate2),
+      encoding: __privateGet(this, _encoding2),
+      container: __privateGet(this, _container2)
     });
     const streamCompleteController = new AbortController();
     let timeoutId = null;
@@ -372,19 +435,26 @@ var WebSocket = class extends Client {
       timeoutId = setTimeout(streamCompleteController.abort, timeout);
     }
     const handleMessage = createMessageHandlerForContextId(
-      contextId,
-      (_0) => __async(this, [_0], function* ({ chunk, message }) {
+      inputs.context_id,
+      (_0) => __async(this, [_0], function* ({ chunk, message, data }) {
         emitter.emit("message", message);
+        if (data.type === "timestamps") {
+          emitter.emit("timestamps", data.word_timestamps);
+          return;
+        }
         if (isSentinel(chunk)) {
           yield source.close();
           streamCompleteController.abort();
           return;
         }
-        yield source.enqueue(base64ToArray([chunk]));
         if (timeoutId) {
           clearTimeout(timeoutId);
           timeoutId = setTimeout(streamCompleteController.abort, timeout);
         }
+        if (!chunk) {
+          return;
+        }
+        yield source.enqueue(base64ToArray([chunk], __privateGet(this, _encoding2)));
       })
     );
     (_b = this.socket) == null ? void 0 : _b.addEventListener("message", handleMessage, {
@@ -427,56 +497,60 @@ var WebSocket = class extends Client {
    * @throws {Error} If the WebSocket fails to connect.
    */
   connect() {
-    const url = constructApiUrl(this.baseUrl, "/tts/websocket", {
-      websocket: true
+    return __async(this, null, function* () {
+      const emitter = new import_emittery2.default();
+      this.socket = new import_partysocket.WebSocket(() => __async(this, null, function* () {
+        const url = constructApiUrl(this.baseUrl, "/tts/websocket", {
+          websocket: true
+        });
+        url.searchParams.set("api_key", yield this.apiKey());
+        url.searchParams.set("cartesia_version", CARTESIA_VERSION);
+        return url.toString();
+      }));
+      this.socket.onopen = () => {
+        __privateSet(this, _isConnected, true);
+        emitter.emit("open");
+      };
+      this.socket.onclose = () => {
+        __privateSet(this, _isConnected, false);
+        emitter.emit("close");
+      };
+      return new Promise(
+        (resolve, reject) => {
+          var _a, _b, _c;
+          (_a = this.socket) == null ? void 0 : _a.addEventListener(
+            "open",
+            () => {
+              resolve(getEmitteryCallbacks(emitter));
+            },
+            {
+              once: true
+            }
+          );
+          const aborter = new AbortController();
+          (_b = this.socket) == null ? void 0 : _b.addEventListener(
+            "error",
+            () => {
+              aborter.abort();
+              reject(new Error("WebSocket failed to connect."));
+            },
+            {
+              signal: aborter.signal
+            }
+          );
+          (_c = this.socket) == null ? void 0 : _c.addEventListener(
+            "close",
+            () => {
+              aborter.abort();
+              reject(new Error("WebSocket closed before it could connect."));
+            },
+            {
+              signal: aborter.signal
+            }
+          );
+        }
+      );
     });
-    url.searchParams.set("api_key", this.apiKey);
-    url.searchParams.set("cartesia_version", CARTESIA_VERSION);
-    const emitter = new import_emittery2.default();
-    this.socket = new import_partysocket.WebSocket(url.toString());
-    this.socket.onopen = () => {
-      __privateSet(this, _isConnected, true);
-      emitter.emit("open");
-    };
-    this.socket.onclose = () => {
-      __privateSet(this, _isConnected, false);
-      emitter.emit("close");
-    };
-    return new Promise(
-      (resolve, reject) => {
-        var _a, _b, _c;
-        (_a = this.socket) == null ? void 0 : _a.addEventListener(
-          "open",
-          () => {
-            resolve(getEmitteryCallbacks(emitter));
-          },
-          {
-            once: true
-          }
-        );
-        const aborter = new AbortController();
-        (_b = this.socket) == null ? void 0 : _b.addEventListener(
-          "error",
-          () => {
-            aborter.abort();
-            reject(new Error("WebSocket failed to connect."));
-          },
-          {
-            signal: aborter.signal
-          }
-        );
-        (_c = this.socket) == null ? void 0 : _c.addEventListener(
-          "close",
-          () => {
-            aborter.abort();
-            reject(new Error("WebSocket closed before it could connect."));
-          },
-          {
-            signal: aborter.signal
-          }
-        );
-      }
-    );
   }
   /**
    * Disconnect from the Cartesia streaming WebSocket.
@@ -488,6 +562,8 @@ var WebSocket = class extends Client {
 };
 _isConnected = new WeakMap();
 _sampleRate2 = new WeakMap();
+_container2 = new WeakMap();
+_encoding2 = new WeakMap();
 _generateId = new WeakSet();
 generateId_fn = function() {
   return (0, import_human_id.humanId)({
@@ -515,40 +591,43 @@ var TTS = class extends Client {
 var Voices = class extends Client {
   list() {
     return __async(this, null, function* () {
-      const response = yield this.fetch("/voices");
+      const response = yield this._fetch("/voices");
       return response.json();
     });
   }
   get(voiceId) {
     return __async(this, null, function* () {
-      const response = yield this.fetch(`/voices/${voiceId}`);
+      const response = yield this._fetch(`/voices/${voiceId}`);
       return response.json();
     });
   }
   create(voice) {
     return __async(this, null, function* () {
-      const response = yield this.fetch("/voices", {
+      const response = yield this._fetch("/voices", {
         method: "POST",
         body: JSON.stringify(voice)
       });
       return response.json();
     });
   }
+  update(id, voice) {
+    return __async(this, null, function* () {
+      const response = yield this._fetch(`/voices/${id}`, {
+        method: "PATCH",
+        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", {
+        if (options.enhance !== void 0) {
+          formData.append("enhance", options.enhance.toString());
+        }
+        const response = yield this._fetch("/voices/clone/clip", {
           method: "POST",
           body: formData
         });
@@ -702,7 +781,8 @@ var DEFAULT_BUFFER_DURATION = 0.01;
 function useTTS({
   apiKey,
   baseUrl,
-  sampleRate
+  sampleRate,
+  onError
 }) {
   var _a, _b;
   if (typeof window === "undefined") {
@@ -733,7 +813,11 @@ function useTTS({
     }
     const cartesia = new Cartesia({ apiKey, baseUrl });
     baseUrl = baseUrl != null ? baseUrl : cartesia.baseUrl;
-    return cartesia.tts.websocket({ sampleRate });
+    return cartesia.tts.websocket({
+      container: "raw",
+      encoding: "pcm_f32le",
+      sampleRate
+    });
   }, [apiKey, baseUrl, sampleRate]);
   const websocketReturn = (0, import_react.useRef)(null);
   const player = (0, import_react.useRef)(null);
@@ -747,20 +831,32 @@ function useTTS({
     (options) => __async(this, null, function* () {
       var _a2, _b2;
       (_a2 = websocketReturn.current) == null ? void 0 : _a2.stop();
-      setMessages([]);
-      setBufferStatus("buffering");
-      websocketReturn.current = (_b2 = websocket == null ? void 0 : websocket.send(options)) != null ? _b2 : null;
-      if (!websocketReturn.current) {
-        return;
+      try {
+        setMessages([]);
+        setBufferStatus("buffering");
+        websocketReturn.current = (_b2 = websocket == null ? void 0 : websocket.send(options)) != null ? _b2 : null;
+        if (!websocketReturn.current) {
+          return;
+        }
+        const unsubscribe = websocketReturn.current.on("message", (message) => {
+          const parsedMessage = JSON.parse(message);
+          setMessages((messages2) => [...messages2, parsedMessage]);
+          if (parsedMessage.error) {
+            onError == null ? void 0 : onError(new Error(parsedMessage.error));
+          }
+        });
+        yield websocketReturn.current.source.once("close");
+        setBufferStatus("buffered");
+        unsubscribe();
+      } catch (error) {
+        if (error instanceof Error) {
+          onError == null ? void 0 : onError(error);
+        } else {
+          console.error(error);
+        }
       }
-      const unsubscribe = websocketReturn.current.on("message", (message) => {
-        setMessages((messages2) => [...messages2, JSON.parse(message)]);
-      });
-      yield websocketReturn.current.source.once("close");
-      setBufferStatus("buffered");
-      unsubscribe();
     }),
-    [websocket]
+    [websocket, onError]
   );
   const metrics = (0, import_react.useMemo)(() => {
     var _a2;
@@ -829,56 +925,88 @@ function useTTS({
     return () => cleanup == null ? void 0 : cleanup();
   }, [websocket, baseUrl]);
   const play = (0, import_react.useCallback)(() => __async(this, null, function* () {
-    if (playbackStatus === "playing" || !websocketReturn.current) {
-      return;
-    }
-    if (player.current) {
-      yield player.current.stop();
-    }
-    setPlaybackStatus("playing");
-    const unsubscribes = [];
-    unsubscribes.push(
-      websocketReturn.current.source.on("wait", () => {
-        setIsWaiting(true);
-      })
-    );
-    unsubscribes.push(
-      websocketReturn.current.source.on("read", () => {
-        setIsWaiting(false);
-      })
-    );
-    player.current = new Player({
-      bufferDuration: bufferDuration != null ? bufferDuration : DEFAULT_BUFFER_DURATION
-    });
-    yield player.current.play(websocketReturn.current.source);
-    for (const unsubscribe of unsubscribes) {
-      unsubscribe();
+    try {
+      if (playbackStatus === "playing" || !websocketReturn.current) {
+        return;
+      }
+      if (player.current) {
+        yield player.current.stop();
+      }
+      setPlaybackStatus("playing");
+      const unsubscribes = [];
+      unsubscribes.push(
+        websocketReturn.current.source.on("wait", () => {
+          setIsWaiting(true);
+        })
+      );
+      unsubscribes.push(
+        websocketReturn.current.source.on("read", () => {
+          setIsWaiting(false);
+        })
+      );
+      player.current = new Player({
+        bufferDuration: bufferDuration != null ? bufferDuration : DEFAULT_BUFFER_DURATION
+      });
+      yield player.current.play(websocketReturn.current.source);
+      for (const unsubscribe of unsubscribes) {
+        unsubscribe();
+      }
+      setPlaybackStatus("finished");
+    } catch (error) {
+      if (error instanceof Error) {
+        onError == null ? void 0 : onError(error);
+      } else {
+        console.error(error);
+      }
     }
-    setPlaybackStatus("finished");
-  }), [playbackStatus, bufferDuration]);
+  }), [playbackStatus, bufferDuration, onError]);
   const pause = (0, import_react.useCallback)(() => __async(this, null, function* () {
     var _a2;
-    yield (_a2 = player.current) == null ? void 0 : _a2.pause();
-    setPlaybackStatus("paused");
-  }), []);
+    try {
+      yield (_a2 = player.current) == null ? void 0 : _a2.pause();
+      setPlaybackStatus("paused");
+    } catch (error) {
+      if (error instanceof Error) {
+        onError == null ? void 0 : onError(error);
+      } else {
+        console.error(error);
+      }
+    }
+  }), [onError]);
   const resume = (0, import_react.useCallback)(() => __async(this, null, function* () {
     var _a2;
-    yield (_a2 = player.current) == null ? void 0 : _a2.resume();
-    setPlaybackStatus("playing");
-  }), []);
+    try {
+      yield (_a2 = player.current) == null ? void 0 : _a2.resume();
+      setPlaybackStatus("playing");
+    } catch (error) {
+      if (error instanceof Error) {
+        onError == null ? void 0 : onError(error);
+      } else {
+        console.error(error);
+      }
+    }
+  }), [onError]);
   const toggle = (0, import_react.useCallback)(() => __async(this, null, function* () {
     var _a2;
-    yield (_a2 = player.current) == null ? void 0 : _a2.toggle();
-    setPlaybackStatus((status) => {
-      if (status === "playing") {
-        return "paused";
-      }
-      if (status === "paused") {
-        return "playing";
+    try {
+      yield (_a2 = player.current) == null ? void 0 : _a2.toggle();
+      setPlaybackStatus((status) => {
+        if (status === "playing") {
+          return "paused";
+        }
+        if (status === "paused") {
+          return "playing";
+        }
+        return status;
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        onError == null ? void 0 : onError(error);
+      } else {
+        console.error(error);
       }
-      return status;
-    });
-  }), []);
+    }
+  }), [onError]);
   return {
     buffer,
     play,