@cartesia/cartesia-js 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,47 @@
+
+$ tsup src/ --format cjs,esm --dts --clean
+CLI Building entry: src/audio/index.ts, src/audio/utils.ts, src/types/index.ts, src/lib/client.ts, src/lib/constants.ts, src/lib/index.ts, src/react/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.0.2
+CLI Target: es6
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+CJS dist/types/index.js   764.00 B
+CJS dist/lib/index.js     11.67 KB
+CJS dist/lib/constants.js 1.33 KB
+CJS dist/audio/utils.js   3.71 KB
+CJS dist/lib/client.js    1.40 KB
+CJS dist/react/index.js   13.52 KB
+CJS dist/audio/index.js   11.41 KB
+CJS ⚡️ Build success in 44ms
+ESM dist/types/index.mjs    0 B
+ESM dist/audio/utils.mjs    391.00 B
+ESM dist/lib/client.mjs     103.00 B
+ESM dist/lib/constants.mjs  155.00 B
+ESM dist/lib/index.mjs      355.00 B
+ESM dist/chunk-5RMUZJV7.mjs 7.01 KB
+ESM dist/chunk-BTFHUVNH.mjs 1.79 KB
+ESM dist/react/index.mjs    2.08 KB
+ESM dist/audio/index.mjs    192.00 B
+ESM dist/chunk-ERFCRIWU.mjs 386.00 B
+ESM dist/chunk-35HX6ML3.mjs 1.32 KB
+ESM ⚡️ Build success in 44ms
+DTS Build start
+DTS ⚡️ Build success in 3158ms
+DTS dist/lib/constants.d.ts   211.00 B
+DTS dist/lib/index.d.ts       302.00 B
+DTS dist/react/index.d.ts     587.00 B
+DTS dist/lib/client.d.ts      180.00 B
+DTS dist/types/index.d.ts     103.00 B
+DTS dist/audio/utils.d.ts     306.00 B
+DTS dist/audio/index.d.ts     161.00 B
+DTS dist/index-Ds4LDkmk.d.ts  5.28 KB
+DTS dist/lib/constants.d.mts  211.00 B
+DTS dist/lib/index.d.mts      305.00 B
+DTS dist/react/index.d.mts    590.00 B
+DTS dist/lib/client.d.mts     181.00 B
+DTS dist/types/index.d.mts    103.00 B
+DTS dist/audio/utils.d.mts    309.00 B
+DTS dist/audio/index.d.mts    164.00 B
+DTS dist/index-Dt9A_pEb.d.mts 5.29 KB

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @cartesia/cartesia-js
+
+## 0.0.1
+
+### Patch Changes
+
+- 0ea132f: Publish Cartesia JS client

package/README.md

@@ -0,0 +1,38 @@
+# JavaScript Client for Cartesia
+
+Usage:
+
+```javascript
+import Cartesia from "@cartesia/cartesia-js";
+
+const cartesia = new Cartesia();
+
+try {
+	await cartesia.audio.connect();
+} catch (error) {
+	console.error(`Failed to connect to Cartesia: ${error}`);
+}
+
+const stream = await cartesia.audio.stream({
+	model: "echo_tts_v0.0.6",
+	options: {
+		transcript: "Hello, world!",
+		chunk_time: 0.1,
+	},
+});
+
+console.log(`Created stream ${stream.id}.`);
+
+stream.on("chunk", ({ chunk, chunks }) => {
+	console.log("Received chunk:", chunk);
+});
+
+stream.on("message", ({ message }) => {
+	// Raw message.
+	console.log("Received message:", message);
+});
+
+console.log("Playing stream...");
+await stream.play();
+console.log("Done playing.");
+```

package/dist/audio/index.d.mts

@@ -0,0 +1,4 @@
+import 'emittery';
+import '../lib/client.mjs';
+export { C as Chunk, S as StreamEventData, e as default } from '../index-Dt9A_pEb.mjs';
+import '../types/index.mjs';

package/dist/audio/index.d.ts

@@ -0,0 +1,4 @@
+import 'emittery';
+import '../lib/client.js';
+export { C as Chunk, S as StreamEventData, e as default } from '../index-Ds4LDkmk.js';
+import '../types/index.js';

package/dist/audio/index.js

@@ -0,0 +1,354 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => {
+  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    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/audio/index.ts
+var audio_exports = {};
+__export(audio_exports, {
+  default: () => audio_default
+});
+module.exports = __toCommonJS(audio_exports);
+var import_emittery = __toESM(require("emittery"));
+var import_human_id = require("human-id");
+
+// 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")}/ws`);
+};
+
+// src/lib/client.ts
+var Client = class {
+  constructor(options = {}) {
+    if (!(options.apiKey || process.env.CARTESIA_API_KEY)) {
+      throw new Error("Missing Cartesia API key.");
+    }
+    this.apiKey = options.apiKey || process.env.CARTESIA_API_KEY;
+    this.baseUrl = options.baseUrl || BASE_URL;
+  }
+};
+
+// src/audio/utils.ts
+var import_base64_js = __toESM(require("base64-js"));
+function getBufferDuration(b64) {
+  const floats = base64ToArray(b64);
+  return floats.length / SAMPLE_RATE;
+}
+function base64ToArray(b64) {
+  return filterSentinel(b64).reduce((acc, b) => {
+    const floats = new Float32Array(import_base64_js.default.toByteArray(b).buffer);
+    const newAcc = new Float32Array(acc.length + floats.length);
+    newAcc.set(acc, 0);
+    newAcc.set(floats, acc.length);
+    return newAcc;
+  }, new Float32Array(0));
+}
+function playAudioBuffer(b64, context, maybeStartAt = null, onEnded = null) {
+  const startAt = maybeStartAt != null ? maybeStartAt : context.currentTime;
+  const floats = base64ToArray(b64);
+  const source = context.createBufferSource();
+  const buffer = context.createBuffer(1, floats.length, SAMPLE_RATE);
+  buffer.getChannelData(0).set(floats);
+  source.buffer = buffer;
+  source.connect(context.destination);
+  source.start(startAt);
+  source.onended = onEnded;
+  return buffer.duration;
+}
+function createMessageHandlerForContextId(contextId, handler) {
+  return (event) => {
+    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 });
+  };
+}
+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]);
+}
+
+// src/audio/index.ts
+var audio_default = class extends Client {
+  constructor() {
+    super(...arguments);
+    this.isConnected = false;
+  }
+  /**
+   * Stream audio from a model.
+   *
+   * @param inputs - Stream options. Includes a `model` key and some `parameters`, which
+   * are model-specific and can be found in the model's documentation.
+   * @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 An object with a method `play` of type `(bufferDuration: number) => Promise<void>`
+   * that plays the audio as it arrives, with `bufferDuration` seconds of audio buffered before
+   * starting playback.
+   */
+  stream(inputs, { timeout = 0 } = {}) {
+    var _a, _b, _c, _d;
+    if (!this.isConnected) {
+      throw new Error("Not connected to WebSocket. Call .connect() first.");
+    }
+    const contextId = this.generateId();
+    (_a = this.socket) == null ? void 0 : _a.send(
+      JSON.stringify({
+        data: inputs,
+        context_id: contextId
+      })
+    );
+    const streamCompleteController = new AbortController();
+    let timeoutId = null;
+    if (timeout > 0) {
+      timeoutId = setTimeout(streamCompleteController.abort, timeout);
+    }
+    const chunks = [];
+    const emitter = new import_emittery.default();
+    const handleMessage = createMessageHandlerForContextId(
+      contextId,
+      (_0) => __async(this, [_0], function* ({ chunk, message }) {
+        chunks.push(chunk);
+        yield emitter.emit("chunk", {
+          chunk,
+          chunks
+        });
+        yield emitter.emit("message", message);
+        if (isSentinel(chunk)) {
+          streamCompleteController.abort();
+        } else 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", () => {
+      emitter.clearListeners();
+    });
+    const play = (_0) => __async(this, [_0], function* ({ bufferDuration }) {
+      const context = new AudioContext({
+        sampleRate: SAMPLE_RATE
+      });
+      let startNextPlaybackAt = 0;
+      const playLatestChunk = (chunk) => {
+        if (isSentinel(chunk)) {
+          return true;
+        }
+        startNextPlaybackAt = playAudioBuffer([chunk], context, startNextPlaybackAt) + Math.max(context.currentTime, startNextPlaybackAt);
+        return false;
+      };
+      const playChunks = (chunks2) => {
+        startNextPlaybackAt += playAudioBuffer(
+          chunks2,
+          context,
+          startNextPlaybackAt
+        );
+        if (isComplete(chunks2)) {
+          return;
+        }
+      };
+      const tryStart = (chunks2) => __async(this, null, function* () {
+        startNextPlaybackAt = context.currentTime;
+        if (isComplete(chunks2) || streamCompleteController.signal.aborted) {
+          playChunks(chunks2);
+          return true;
+        }
+        if (getBufferDuration(chunks2) > bufferDuration) {
+          playChunks(chunks2);
+          try {
+            for (var iter2 = __forAwait(emitter.events("chunk")), more2, temp2, error2; more2 = !(temp2 = yield iter2.next()).done; more2 = false) {
+              const { chunk } = temp2.value;
+              if (playLatestChunk(chunk)) {
+                break;
+              }
+            }
+          } catch (temp2) {
+            error2 = [temp2];
+          } finally {
+            try {
+              more2 && (temp2 = iter2.return) && (yield temp2.call(iter2));
+            } finally {
+              if (error2)
+                throw error2[0];
+            }
+          }
+          return true;
+        }
+        return false;
+      });
+      if (!(yield tryStart(chunks))) {
+        try {
+          for (var iter = __forAwait(emitter.events("chunk")), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+            const { chunks: chunks2 } = temp.value;
+            if (yield tryStart(chunks2)) {
+              break;
+            }
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield temp.call(iter));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+      }
+    });
+    return {
+      play,
+      on: emitter.on.bind(emitter),
+      off: emitter.off.bind(emitter),
+      once: emitter.once.bind(emitter),
+      events: emitter.events.bind(emitter)
+    };
+  }
+  /**
+   * 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.
+   */
+  generateId() {
+    return (0, import_human_id.humanId)({
+      separator: "-",
+      capitalize: false
+    });
+  }
+  /**
+   * 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 = constructWebsocketUrl(this.baseUrl);
+    url.searchParams.set("api_key", this.apiKey);
+    this.socket = new WebSocket(url);
+    this.socket.onopen = () => {
+      this.isConnected = true;
+    };
+    this.socket.onclose = () => {
+      this.isConnected = false;
+    };
+    return new Promise((resolve, reject) => {
+      var _a, _b, _c;
+      (_a = this.socket) == null ? void 0 : _a.addEventListener(
+        "open",
+        () => {
+          resolve();
+        },
+        {
+          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();
+  }
+};

package/dist/audio/index.mjs

@@ -0,0 +1,9 @@
+import {
+  audio_default
+} from "../chunk-5RMUZJV7.mjs";
+import "../chunk-BTFHUVNH.mjs";
+import "../chunk-ERFCRIWU.mjs";
+import "../chunk-35HX6ML3.mjs";
+export {
+  audio_default as default
+};

package/dist/audio/utils.d.mts

@@ -0,0 +1,4 @@
+export { a as Sentinel, b as base64ToArray, c as createMessageHandlerForContextId, f as filterSentinel, g as getBufferDuration, d as getSentinel, h as isComplete, i as isSentinel, p as playAudioBuffer } from '../index-Dt9A_pEb.mjs';
+import 'emittery';
+import '../lib/client.mjs';
+import '../types/index.mjs';

package/dist/audio/utils.d.ts

@@ -0,0 +1,4 @@
+export { a as Sentinel, b as base64ToArray, c as createMessageHandlerForContextId, f as filterSentinel, g as getBufferDuration, d as getSentinel, h as isComplete, i as isSentinel, p as playAudioBuffer } from '../index-Ds4LDkmk.js';
+import 'emittery';
+import '../lib/client.js';
+import '../types/index.js';

package/dist/audio/utils.js

@@ -0,0 +1,113 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/audio/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  base64ToArray: () => base64ToArray,
+  createMessageHandlerForContextId: () => createMessageHandlerForContextId,
+  filterSentinel: () => filterSentinel,
+  getBufferDuration: () => getBufferDuration,
+  getSentinel: () => getSentinel,
+  isComplete: () => isComplete,
+  isSentinel: () => isSentinel,
+  playAudioBuffer: () => playAudioBuffer
+});
+module.exports = __toCommonJS(utils_exports);
+var import_base64_js = __toESM(require("base64-js"));
+
+// src/lib/constants.ts
+var SAMPLE_RATE = 44100;
+
+// src/audio/utils.ts
+function getBufferDuration(b64) {
+  const floats = base64ToArray(b64);
+  return floats.length / SAMPLE_RATE;
+}
+function base64ToArray(b64) {
+  return filterSentinel(b64).reduce((acc, b) => {
+    const floats = new Float32Array(import_base64_js.default.toByteArray(b).buffer);
+    const newAcc = new Float32Array(acc.length + floats.length);
+    newAcc.set(acc, 0);
+    newAcc.set(floats, acc.length);
+    return newAcc;
+  }, new Float32Array(0));
+}
+function playAudioBuffer(b64, context, maybeStartAt = null, onEnded = null) {
+  const startAt = maybeStartAt != null ? maybeStartAt : context.currentTime;
+  const floats = base64ToArray(b64);
+  const source = context.createBufferSource();
+  const buffer = context.createBuffer(1, floats.length, SAMPLE_RATE);
+  buffer.getChannelData(0).set(floats);
+  source.buffer = buffer;
+  source.connect(context.destination);
+  source.start(startAt);
+  source.onended = onEnded;
+  return buffer.duration;
+}
+function createMessageHandlerForContextId(contextId, handler) {
+  return (event) => {
+    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 });
+  };
+}
+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]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64ToArray,
+  createMessageHandlerForContextId,
+  filterSentinel,
+  getBufferDuration,
+  getSentinel,
+  isComplete,
+  isSentinel,
+  playAudioBuffer
+});

package/dist/audio/utils.mjs

@@ -0,0 +1,21 @@
+import {
+  base64ToArray,
+  createMessageHandlerForContextId,
+  filterSentinel,
+  getBufferDuration,
+  getSentinel,
+  isComplete,
+  isSentinel,
+  playAudioBuffer
+} from "../chunk-BTFHUVNH.mjs";
+import "../chunk-35HX6ML3.mjs";
+export {
+  base64ToArray,
+  createMessageHandlerForContextId,
+  filterSentinel,
+  getBufferDuration,
+  getSentinel,
+  isComplete,
+  isSentinel,
+  playAudioBuffer
+};

package/dist/chunk-35HX6ML3.mjs

@@ -0,0 +1,39 @@
+var __knownSymbol = (name, symbol) => {
+  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    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")}/ws`);
+};
+
+export {
+  __async,
+  __forAwait,
+  BASE_URL,
+  SAMPLE_RATE,
+  constructWebsocketUrl
+};