@cartesia/cartesia-js 1.3.0 → 2.0.0-alpha

package/wrapper/Client.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesiaClient = void 0;
+const Client_1 = require("../Client");
+const StreamingTTSClient_1 = require("./StreamingTTSClient");
+class CartesiaClient extends Client_1.CartesiaClient {
+    get tts() {
+        var _a;
+        return ((_a = this._tts) !== null && _a !== void 0 ? _a : (this._tts = new StreamingTTSClient_1.StreamingTTSClient(this._options)));
+    }
+}
+exports.CartesiaClient = CartesiaClient;

package/wrapper/StreamingTTSClient.d.ts

@@ -0,0 +1,16 @@
+import { Tts } from "../api/resources/tts/client/Client";
+import Websocket from "./Websocket";
+export declare class StreamingTTSClient extends Tts {
+    constructor(options?: Tts.Options);
+    /**
+     * Get a WebSocket client for streaming TTS.
+     *
+     * @param options - Options for the WebSocket client.
+     * @returns A WebSocket client configured for streaming TTS.
+     */
+    websocket({ sampleRate, container, encoding, }: {
+        sampleRate: number;
+        container?: string;
+        encoding?: string;
+    }): Websocket;
+}

package/wrapper/StreamingTTSClient.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingTTSClient = void 0;
+const Client_1 = require("../api/resources/tts/client/Client");
+const Websocket_1 = __importDefault(require("./Websocket"));
+class StreamingTTSClient extends Client_1.Tts {
+    constructor(options = {}) {
+        super(options);
+    }
+    /**
+     * Get a WebSocket client for streaming TTS.
+     *
+     * @param options - Options for the WebSocket client.
+     * @returns A WebSocket client configured for streaming TTS.
+     */
+    websocket({ sampleRate, container, encoding, }) {
+        return new Websocket_1.default({ sampleRate, container, encoding }, Object.assign({ cartesiaVersion: "2024-06-10" }, this._options));
+    }
+}
+exports.StreamingTTSClient = StreamingTTSClient;

package/{dist/tts/player.d.cts → wrapper/WebPlayer.d.ts}

@@ -1,9 +1,5 @@
-import Source from './source.cjs';
-import 'emittery';
-import '../types/index.cjs';
-import 'partysocket/ws';
-
-declare class Player {
+import type Source from "./source";
+export declare class WebPlayer {
     #private;
     /**
      * Create a new Player.
@@ -46,5 +42,3 @@ declare class Player {
      */
     stop(): Promise<void>;
 }
-
-export { Player as default };

package/wrapper/WebPlayer.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WebPlayer_instances, _WebPlayer_context, _WebPlayer_startNextPlaybackAt, _WebPlayer_bufferDuration, _WebPlayer_playBuffer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebPlayer = void 0;
+const utils_1 = require("./utils");
+class WebPlayer {
+    /**
+     * Create a new Player.
+     *
+     * @param options - Options for the Player.
+     * @param options.bufferDuration - The duration of the audio buffer to play.
+     */
+    constructor({ bufferDuration }) {
+        _WebPlayer_instances.add(this);
+        _WebPlayer_context.set(this, null);
+        _WebPlayer_startNextPlaybackAt.set(this, 0);
+        _WebPlayer_bufferDuration.set(this, void 0);
+        __classPrivateFieldSet(this, _WebPlayer_bufferDuration, bufferDuration, "f");
+    }
+    /**
+     * 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 __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _WebPlayer_startNextPlaybackAt, 0, "f");
+            __classPrivateFieldSet(this, _WebPlayer_context, new AudioContext({ sampleRate: source.sampleRate }), "f");
+            const buffer = new Float32Array(source.durationToSampleCount(__classPrivateFieldGet(this, _WebPlayer_bufferDuration, "f")));
+            const plays = [];
+            while (true) {
+                const read = yield source.read(buffer);
+                // If we've reached the end of the source, then read < buffer.length.
+                // In that case, we don't want to play the entire buffer, as that
+                // will cause repeated audio.
+                // So we set the buffer to the correct length.
+                const playableAudio = buffer.subarray(0, read);
+                plays.push(__classPrivateFieldGet(this, _WebPlayer_instances, "m", _WebPlayer_playBuffer).call(this, playableAudio, source.sampleRate));
+                if (read < buffer.length) {
+                    // No more audio to read.
+                    break;
+                }
+            }
+            yield Promise.all(plays);
+        });
+    }
+    /**
+     * Pause the audio.
+     *
+     * @returns A promise that resolves when the audio has been paused.
+     */
+    pause() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _WebPlayer_context, "f")) {
+                throw new Error("AudioContext not initialized.");
+            }
+            yield __classPrivateFieldGet(this, _WebPlayer_context, "f").suspend();
+        });
+    }
+    /**
+     * Resume the audio.
+     *
+     * @returns A promise that resolves when the audio has been resumed.
+     */
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _WebPlayer_context, "f")) {
+                throw new Error("AudioContext not initialized.");
+            }
+            yield __classPrivateFieldGet(this, _WebPlayer_context, "f").resume();
+        });
+    }
+    /**
+     * Toggle the audio.
+     *
+     * @returns A promise that resolves when the audio has been toggled.
+     */
+    toggle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _WebPlayer_context, "f")) {
+                throw new Error("AudioContext not initialized.");
+            }
+            if (__classPrivateFieldGet(this, _WebPlayer_context, "f").state === "running") {
+                yield this.pause();
+            }
+            else {
+                yield this.resume();
+            }
+        });
+    }
+    /**
+     * Stop the audio.
+     *
+     * @returns A promise that resolves when the audio has been stopped.
+     */
+    stop() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _WebPlayer_context, "f")) {
+                throw new Error("AudioContext not initialized.");
+            }
+            yield ((_a = __classPrivateFieldGet(this, _WebPlayer_context, "f")) === null || _a === void 0 ? void 0 : _a.close());
+        });
+    }
+}
+exports.WebPlayer = WebPlayer;
+_WebPlayer_context = new WeakMap(), _WebPlayer_startNextPlaybackAt = new WeakMap(), _WebPlayer_bufferDuration = new WeakMap(), _WebPlayer_instances = new WeakSet(), _WebPlayer_playBuffer = function _WebPlayer_playBuffer(buf, sampleRate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!__classPrivateFieldGet(this, _WebPlayer_context, "f")) {
+            throw new Error("AudioContext not initialized.");
+        }
+        if (buf.length === 0) {
+            return;
+        }
+        const startAt = __classPrivateFieldGet(this, _WebPlayer_startNextPlaybackAt, "f");
+        const duration = buf.length / sampleRate;
+        __classPrivateFieldSet(this, _WebPlayer_startNextPlaybackAt, duration + Math.max(__classPrivateFieldGet(this, _WebPlayer_context, "f").currentTime, __classPrivateFieldGet(this, _WebPlayer_startNextPlaybackAt, "f")), "f");
+        yield (0, utils_1.playAudioBuffer)(buf, __classPrivateFieldGet(this, _WebPlayer_context, "f"), startAt, sampleRate);
+    });
+};

package/wrapper/Websocket.d.ts

@@ -0,0 +1,57 @@
+import { ReconnectingWebSocket, Options } from "../core/websocket";
+import type { WebSocketStreamOptions, WebSocketTtsRequest, WordTimestamps } from "../api";
+import { ConnectionEventData, WebSocketOptions, EmitteryCallbacks } from "./utils";
+import { Tts } from "api/resources/tts/client/Client";
+import Source from "./source";
+export default class Websocket {
+    #private;
+    private readonly options;
+    socket?: ReconnectingWebSocket;
+    constructor({ sampleRate, container, encoding }: WebSocketOptions, options: Tts.Options);
+    /**
+     * Send a message over the WebSocket to start a stream.
+     *
+     * @param inputs - Generation parameters. 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.
+     * @returns A Source object that can be passed to a Player to play the audio.
+     * @returns An Emittery instance that emits messages from the WebSocket.
+     * @returns An abort function that can be called to cancel the stream.
+     */
+    send(inputs: WebSocketTtsRequest, { timeout }?: WebSocketStreamOptions): {
+        stop: {
+            (reason?: any): void;
+            (): void;
+        };
+        on: <Name extends "timestamps" | "message" | keyof import("emittery").OmnipresentEventData>(eventName: Name | readonly Name[], listener: (eventData: ({
+            message: string;
+            timestamps: WordTimestamps;
+        } & import("emittery").OmnipresentEventData)[Name]) => void | Promise<void>) => import("emittery").UnsubscribeFunction;
+        off: <Name_1 extends "timestamps" | "message" | keyof import("emittery").OmnipresentEventData>(eventName: Name_1 | readonly Name_1[], listener: (eventData: ({
+            message: string;
+            timestamps: WordTimestamps;
+        } & import("emittery").OmnipresentEventData)[Name_1]) => void | Promise<void>) => void;
+        once: <Name_2 extends "timestamps" | "message" | keyof import("emittery").OmnipresentEventData>(eventName: Name_2 | readonly Name_2[]) => import("emittery").EmitteryOncePromise<({
+            message: string;
+            timestamps: WordTimestamps;
+        } & import("emittery").OmnipresentEventData)[Name_2]>;
+        events: <Name_3 extends "timestamps" | "message">(eventName: Name_3 | readonly Name_3[]) => AsyncIterableIterator<{
+            message: string;
+            timestamps: WordTimestamps;
+        }[Name_3]>;
+        source: Source;
+    };
+    continue(inputs: WebSocketTtsRequest): void;
+    /**
+     * 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(options?: Options): Promise<EmitteryCallbacks<ConnectionEventData>>;
+    /**
+     * Disconnect from the Cartesia streaming WebSocket.
+     */
+    disconnect(): void;
+}

package/wrapper/Websocket.js

@@ -0,0 +1,218 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Websocket_instances, _Websocket_isConnected, _Websocket_sampleRate, _Websocket_container, _Websocket_encoding, _Websocket_generateId;
+Object.defineProperty(exports, "__esModule", { value: true });
+const core = __importStar(require("../core"));
+const environments = __importStar(require("../environments"));
+const serializers = __importStar(require("../serialization"));
+const emittery_1 = __importDefault(require("emittery"));
+const human_id_1 = require("human-id");
+const websocket_1 = require("../core/websocket");
+const utils_1 = require("./utils");
+const source_1 = __importDefault(require("./source"));
+const qs_1 = __importDefault(require("qs"));
+class Websocket {
+    constructor({ sampleRate, container, encoding }, options) {
+        this.options = options;
+        _Websocket_instances.add(this);
+        _Websocket_isConnected.set(this, false);
+        _Websocket_sampleRate.set(this, void 0);
+        _Websocket_container.set(this, void 0);
+        _Websocket_encoding.set(this, void 0);
+        __classPrivateFieldSet(this, _Websocket_sampleRate, sampleRate, "f");
+        __classPrivateFieldSet(this, _Websocket_container, container !== null && container !== void 0 ? container : "raw", "f");
+        __classPrivateFieldSet(this, _Websocket_encoding, encoding !== null && encoding !== void 0 ? encoding : "pcm_f32le", "f");
+    }
+    /**
+     * Send a message over the WebSocket to start a stream.
+     *
+     * @param inputs - Generation parameters. 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.
+     * @returns A Source object that can be passed to a Player to play the audio.
+     * @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;
+        if (!__classPrivateFieldGet(this, _Websocket_isConnected, "f")) {
+            throw new Error("Not connected to WebSocket. Call .connect() first.");
+        }
+        if (!inputs.contextId) {
+            inputs.contextId = __classPrivateFieldGet(this, _Websocket_instances, "m", _Websocket_generateId).call(this);
+        }
+        if (!inputs.outputFormat) {
+            inputs.outputFormat = (0, utils_1.resolveOutputFormat)(__classPrivateFieldGet(this, _Websocket_container, "f"), __classPrivateFieldGet(this, _Websocket_encoding, "f"), __classPrivateFieldGet(this, _Websocket_sampleRate, "f"));
+        }
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(serializers.WebSocketTtsRequest.jsonOrThrow(inputs, { unrecognizedObjectKeys: "strip" })));
+        const emitter = new emittery_1.default();
+        const source = new source_1.default({
+            sampleRate: __classPrivateFieldGet(this, _Websocket_sampleRate, "f"),
+            encoding: __classPrivateFieldGet(this, _Websocket_encoding, "f"),
+            container: __classPrivateFieldGet(this, _Websocket_container, "f"),
+        });
+        // Used to signal that the stream is complete, either because the
+        // WebSocket has closed, or because the stream has finished.
+        const streamCompleteController = new AbortController();
+        // Set a timeout.
+        let timeoutId = null;
+        if (timeout > 0) {
+            timeoutId = setTimeout(streamCompleteController.abort, timeout);
+        }
+        const handleMessage = (0, utils_1.createMessageHandlerForContextId)(inputs.contextId, ({ chunk, message, data }) => __awaiter(this, void 0, void 0, function* () {
+            emitter.emit("message", message);
+            if (data.type === "timestamps" && data.wordTimestamps) {
+                emitter.emit("timestamps", data.wordTimestamps);
+                return;
+            }
+            if ((0, utils_1.isSentinel)(chunk)) {
+                yield source.close();
+                streamCompleteController.abort();
+                return;
+            }
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = setTimeout(streamCompleteController.abort, timeout);
+            }
+            if (!chunk) {
+                return;
+            }
+            yield source.enqueue((0, utils_1.base64ToArray)([chunk], __classPrivateFieldGet(this, _Websocket_encoding, "f")));
+        }));
+        (_b = this.socket) === null || _b === void 0 ? void 0 : _b.addEventListener("message", handleMessage);
+        (_c = this.socket) === null || _c === void 0 ? void 0 : _c.addEventListener("close", () => {
+            streamCompleteController.abort();
+        });
+        (_d = this.socket) === null || _d === void 0 ? void 0 : _d.addEventListener("error", () => {
+            streamCompleteController.abort();
+        });
+        streamCompleteController.signal.addEventListener("abort", () => {
+            source.close();
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            emitter.clearListeners();
+        });
+        return Object.assign(Object.assign({ source }, (0, utils_1.getEmitteryCallbacks)(emitter)), { stop: streamCompleteController.abort.bind(streamCompleteController) });
+    }
+    continue(inputs) {
+        var _a;
+        if (!__classPrivateFieldGet(this, _Websocket_isConnected, "f")) {
+            throw new Error("Not connected to WebSocket. Call .connect() first.");
+        }
+        if (!inputs.contextId) {
+            throw new Error("context_id is required to continue a context.");
+        }
+        if (!inputs.outputFormat) {
+            inputs.outputFormat = (0, utils_1.resolveOutputFormat)(__classPrivateFieldGet(this, _Websocket_container, "f"), __classPrivateFieldGet(this, _Websocket_encoding, "f"), __classPrivateFieldGet(this, _Websocket_sampleRate, "f"));
+        }
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(Object.assign({ continue: true }, serializers.WebSocketTtsRequest.jsonOrThrow(inputs, { unrecognizedObjectKeys: "strip" }))));
+    }
+    /**
+     * 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(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _Websocket_isConnected, "f")) {
+                throw new Error("WebSocket is already connected.");
+            }
+            const emitter = new emittery_1.default();
+            this.socket = new websocket_1.ReconnectingWebSocket(() => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const baseUrl = ((_a = (yield core.Supplier.get(this.options.environment))) !== null && _a !== void 0 ? _a : environments.CartesiaEnvironment.Production).replace(/^https?:\/\//, "");
+                const params = {
+                    api_key: this.options.apiKeyHeader,
+                    cartesia_version: this.options.cartesiaVersion,
+                };
+                return `wss://${baseUrl}/tts/websocket${qs_1.default.stringify(params, { addQueryPrefix: true })}`;
+            }), undefined, options);
+            this.socket.reconnect();
+            this.socket.onopen = () => {
+                __classPrivateFieldSet(this, _Websocket_isConnected, true, "f");
+                emitter.emit("open");
+            };
+            this.socket.onclose = () => {
+                __classPrivateFieldSet(this, _Websocket_isConnected, false, "f");
+                emitter.emit("close");
+            };
+            return new Promise((resolve, reject) => {
+                var _a, _b, _c;
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.addEventListener("open", () => {
+                    resolve((0, utils_1.getEmitteryCallbacks)(emitter));
+                });
+                const aborter = new AbortController();
+                (_b = this.socket) === null || _b === void 0 ? void 0 : _b.addEventListener("error", () => {
+                    aborter.abort();
+                    reject(new Error("WebSocket failed to connect."));
+                });
+                (_c = this.socket) === null || _c === void 0 ? void 0 : _c.addEventListener("close", () => {
+                    aborter.abort();
+                    reject(new Error("WebSocket closed before it could connect."));
+                });
+            });
+        });
+    }
+    /**
+     * Disconnect from the Cartesia streaming WebSocket.
+     */
+    disconnect() {
+        var _a;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close();
+    }
+}
+exports.default = Websocket;
+_Websocket_isConnected = new WeakMap(), _Websocket_sampleRate = new WeakMap(), _Websocket_container = new WeakMap(), _Websocket_encoding = new WeakMap(), _Websocket_instances = new WeakSet(), _Websocket_generateId = function _Websocket_generateId() {
+    return (0, human_id_1.humanId)({
+        separator: "-",
+        capitalize: false,
+    });
+};

package/{dist/tts/source.d.cts → wrapper/source.d.ts}

@@ -1,31 +1,24 @@
-import * as emittery from 'emittery';
-import { Encoding, SourceEventData, TypedArray } from '../types/index.cjs';
-import 'partysocket/ws';
-
-type EncodingInfo = {
-    arrayType: Float32ArrayConstructor | Int16ArrayConstructor | Uint8ArrayConstructor;
-    bytesPerElement: number;
-};
-declare const ENCODING_MAP: Record<Encoding, EncodingInfo>;
-declare class Source {
+import { RawEncoding } from "../api";
+import { SourceEventData, TypedArray } from "./utils";
+export default class Source {
     #private;
-    on: <Name extends keyof SourceEventData | keyof emittery.OmnipresentEventData>(eventName: Name | readonly Name[], listener: (eventData: (SourceEventData & emittery.OmnipresentEventData)[Name]) => void | Promise<void>) => emittery.UnsubscribeFunction;
-    once: <Name extends keyof SourceEventData | keyof emittery.OmnipresentEventData>(eventName: Name | readonly Name[]) => emittery.EmitteryOncePromise<(SourceEventData & emittery.OmnipresentEventData)[Name]>;
+    on: <Name extends keyof import("emittery").OmnipresentEventData | keyof SourceEventData>(eventName: Name | readonly Name[], listener: (eventData: (SourceEventData & import("emittery").OmnipresentEventData)[Name]) => void | Promise<void>) => import("emittery").UnsubscribeFunction;
+    once: <Name extends keyof import("emittery").OmnipresentEventData | keyof SourceEventData>(eventName: Name | readonly Name[]) => import("emittery").EmitteryOncePromise<(SourceEventData & import("emittery").OmnipresentEventData)[Name]>;
     events: <Name extends keyof SourceEventData>(eventName: Name | readonly Name[]) => AsyncIterableIterator<SourceEventData[Name]>;
-    off: <Name extends keyof SourceEventData | keyof emittery.OmnipresentEventData>(eventName: Name | readonly Name[], listener: (eventData: (SourceEventData & emittery.OmnipresentEventData)[Name]) => void | Promise<void>) => void;
+    off: <Name extends keyof import("emittery").OmnipresentEventData | keyof SourceEventData>(eventName: Name | readonly Name[], listener: (eventData: (SourceEventData & import("emittery").OmnipresentEventData)[Name]) => void | Promise<void>) => void;
     /**
      * Create a new Source.
      *
      * @param options - Options for the Source.
      * @param options.sampleRate - The sample rate of the audio.
      */
-    constructor({ sampleRate, encoding, container, }: {
+    constructor({ sampleRate, encoding, container }: {
         sampleRate: number;
         encoding: string;
         container: string;
     });
     get sampleRate(): number;
-    get encoding(): Encoding;
+    get encoding(): RawEncoding;
     get container(): string;
     /**
      * Append audio to the buffer.
@@ -69,5 +62,3 @@ declare class Source {
      */
     close(): Promise<void>;
 }
-
-export { ENCODING_MAP, Source as default };