@cartesia/cartesia-js 0.0.3 → 1.0.0-alpha.1

package/dist/chunk-NDNN326Q.js

@@ -0,0 +1,207 @@
+import {
+  Source
+} from "./chunk-JOHSCOLW.js";
+import {
+  Client
+} from "./chunk-BCQ63627.js";
+import {
+  constructApiUrl
+} from "./chunk-3GBZUGUD.js";
+import {
+  base64ToArray,
+  createMessageHandlerForContextId,
+  getEmitteryCallbacks,
+  isSentinel
+} from "./chunk-LYPTISWL.js";
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-WIFMLPT5.js";
+
+// src/tts/websocket.ts
+import Emittery from "emittery";
+import { humanId } from "human-id";
+import { WebSocket as PartySocketWebSocket } from "partysocket";
+var _isConnected, _sampleRate, _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) {
+    super(...args);
+    /**
+     * Generate a unique ID suitable for a streaming context.
+     *
+     * Not suitable for security purposes or as a primary key, since
+     * it lacks the amount of entropy required for those use cases.
+     *
+     * @returns A unique ID.
+     */
+    __privateAdd(this, _generateId);
+    __privateAdd(this, _isConnected, false);
+    __privateAdd(this, _sampleRate, void 0);
+    __privateSet(this, _sampleRate, sampleRate);
+  }
+  /**
+   * Send a message over the WebSocket in order to start a stream.
+   *
+   * @param inputs - Stream options.
+   * @param options - Options for the stream.
+   * @param options.timeout - The maximum time to wait for a chunk before cancelling the stream.
+   * If `0`, the stream will not time out.
+   * @returns A Source object that can be passed to a Player to play the audio.
+   */
+  send(inputs, { timeout = 0 } = {}) {
+    var _a, _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, _sampleRate)
+        }
+      }))
+    );
+    const emitter = new Emittery();
+    const source = new Source({
+      sampleRate: __privateGet(this, _sampleRate)
+    });
+    const streamCompleteController = new AbortController();
+    let timeoutId = null;
+    if (timeout > 0) {
+      timeoutId = setTimeout(streamCompleteController.abort, timeout);
+    }
+    const handleMessage = createMessageHandlerForContextId(
+      contextId,
+      (_0) => __async(this, [_0], function* ({ chunk, message }) {
+        emitter.emit("message", message);
+        if (isSentinel(chunk)) {
+          yield source.close();
+          streamCompleteController.abort();
+          return;
+        }
+        yield source.enqueue(base64ToArray([chunk]));
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = setTimeout(streamCompleteController.abort, timeout);
+        }
+      })
+    );
+    (_b = this.socket) == null ? void 0 : _b.addEventListener("message", handleMessage, {
+      signal: streamCompleteController.signal
+    });
+    (_c = this.socket) == null ? void 0 : _c.addEventListener(
+      "close",
+      () => {
+        streamCompleteController.abort();
+      },
+      {
+        once: true
+      }
+    );
+    (_d = this.socket) == null ? void 0 : _d.addEventListener(
+      "error",
+      () => {
+        streamCompleteController.abort();
+      },
+      {
+        once: true
+      }
+    );
+    streamCompleteController.signal.addEventListener("abort", () => {
+      source.close();
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    });
+    return __spreadValues({ source }, getEmitteryCallbacks(emitter));
+  }
+  /**
+   * Authenticate and connect to a Cartesia streaming WebSocket.
+   *
+   * @returns A promise that resolves when the WebSocket is connected.
+   * @throws {Error} If the WebSocket fails to connect.
+   */
+  connect() {
+    const url = constructApiUrl(this.baseUrl, "/tts/websocket", "ws");
+    url.searchParams.set("api_key", this.apiKey);
+    const emitter = new Emittery();
+    this.socket = new PartySocketWebSocket(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.
+   */
+  disconnect() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.close();
+  }
+};
+_isConnected = new WeakMap();
+_sampleRate = new WeakMap();
+_generateId = new WeakSet();
+generateId_fn = function() {
+  return humanId({
+    separator: "-",
+    capitalize: false
+  });
+};
+
+export {
+  WebSocket
+};

package/dist/chunk-WBK6LLXX.js

@@ -0,0 +1,58 @@
+import {
+  Client
+} from "./chunk-BCQ63627.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-WE63M7PJ.js

@@ -0,0 +1,119 @@
+import {
+  playAudioBuffer
+} from "./chunk-LYPTISWL.js";
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk-WIFMLPT5.js";
+
+// src/tts/player.ts
+import Emittery from "emittery";
+var _context, _startNextPlaybackAt, _bufferDuration, _emitter, _playBuffer, playBuffer_fn;
+var Player = class {
+  /**
+   * Create a new Player.
+   *
+   * @param options - Options for the Player.
+   * @param options.bufferDuration - The duration of the audio buffer to play.
+   */
+  constructor({ bufferDuration }) {
+    __privateAdd(this, _playBuffer);
+    __privateAdd(this, _context, null);
+    __privateAdd(this, _startNextPlaybackAt, 0);
+    __privateAdd(this, _bufferDuration, void 0);
+    __privateAdd(this, _emitter, new Emittery());
+    __privateSet(this, _bufferDuration, bufferDuration);
+  }
+  /**
+   * Play audio from a source.
+   *
+   * @param source The source to play audio from.
+   * @returns A promise that resolves when the audio has finished playing.
+   */
+  play(source) {
+    return __async(this, null, function* () {
+      __privateSet(this, _startNextPlaybackAt, 0);
+      __privateSet(this, _context, new AudioContext({ sampleRate: source.sampleRate }));
+      const buffer = new Float32Array(
+        source.durationToSampleCount(__privateGet(this, _bufferDuration))
+      );
+      const plays = [];
+      while (true) {
+        const read = yield source.read(buffer);
+        const playableAudio = buffer.slice(0, read);
+        plays.push(__privateMethod(this, _playBuffer, playBuffer_fn).call(this, playableAudio, source.sampleRate));
+        if (read < buffer.length) {
+          yield __privateGet(this, _emitter).emit("finish");
+          break;
+        }
+      }
+      yield Promise.all(plays);
+    });
+  }
+  /**
+   * Pause the audio.
+   *
+   * @returns A promise that resolves when the audio has been paused.
+   */
+  pause() {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _context)) {
+        throw new Error("AudioContext not initialized.");
+      }
+      yield __privateGet(this, _context).suspend();
+    });
+  }
+  /**
+   * Resume the audio.
+   *
+   * @returns A promise that resolves when the audio has been resumed.
+   */
+  resume() {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _context)) {
+        throw new Error("AudioContext not initialized.");
+      }
+      yield __privateGet(this, _context).resume();
+    });
+  }
+  /**
+   * Toggle the audio.
+   *
+   * @returns A promise that resolves when the audio has been toggled.
+   */
+  toggle() {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _context)) {
+        throw new Error("AudioContext not initialized.");
+      }
+      if (__privateGet(this, _context).state === "running") {
+        yield this.pause();
+      } else {
+        yield this.resume();
+      }
+    });
+  }
+};
+_context = new WeakMap();
+_startNextPlaybackAt = new WeakMap();
+_bufferDuration = new WeakMap();
+_emitter = new WeakMap();
+_playBuffer = new WeakSet();
+playBuffer_fn = function(buf, sampleRate) {
+  return __async(this, null, function* () {
+    if (!__privateGet(this, _context)) {
+      throw new Error("AudioContext not initialized.");
+    }
+    const startAt = __privateGet(this, _startNextPlaybackAt);
+    const duration = buf.length / sampleRate;
+    __privateSet(this, _startNextPlaybackAt, duration + Math.max(__privateGet(this, _context).currentTime, __privateGet(this, _startNextPlaybackAt)));
+    yield playAudioBuffer(buf, __privateGet(this, _context), startAt, sampleRate);
+  });
+};
+
+export {
+  Player
+};

package/dist/{chunk-HNLIBHEN.mjs → 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,20 +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);
-
-// src/lib/constants.ts
-var BASE_URL = "https://api.cartesia.ai/v0";
-var SAMPLE_RATE = 44100;
-var constructWebsocketUrl = (baseUrl) => {
-  return new URL(`${baseUrl.replace(/^http/, "ws")}/audio/websocket`);
-};
 
 export {
   __spreadValues,
-  __async,
-  __forAwait,
-  BASE_URL,
-  SAMPLE_RATE,
-  constructWebsocketUrl
+  __spreadProps,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __async
 };

package/dist/chunk-X7SJMF2R.js

@@ -0,0 +1,22 @@
+import {
+  Voices
+} from "./chunk-WBK6LLXX.js";
+import {
+  TTS
+} from "./chunk-4RMSIQLG.js";
+import {
+  Client
+} from "./chunk-BCQ63627.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
+};