@elevenlabs/elevenlabs-js 2.3.0 → 2.4.1

package/dist/wrapper/stream.js

@@ -1,4 +1,37 @@
 "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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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) {
@@ -8,56 +41,50 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stream = stream;
-const command_exists_1 = __importDefault(require("command-exists"));
+const utils_1 = require("./utils");
 const ElevenLabsError_1 = require("../errors/ElevenLabsError");
-const runtime_1 = require("../core/runtime/runtime");
-const execa_1 = __importDefault(require("execa"));
 function stream(audio) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, audio_1, audio_1_1;
-        var _b, e_1, _c, _d;
-        var _e, _f;
-        if (runtime_1.RUNTIME.type !== "node") {
+        if (!(0, utils_1.isNode)()) {
             throw new ElevenLabsError_1.ElevenLabsError({
-                message: `This function is only supported in node environments. ${runtime_1.RUNTIME.type} is not supported`,
+                message: "The stream function is only available in a Node.js environment.",
             });
         }
-        if (!(0, command_exists_1.default)("mpv")) {
+        const { spawn } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+        const { Readable } = yield Promise.resolve().then(() => __importStar(require("node:stream")));
+        const commandExists = (yield Promise.resolve().then(() => __importStar(require("command-exists")))).default;
+        if (!commandExists.sync("mpv")) {
             throw new ElevenLabsError_1.ElevenLabsError({
                 message: `mpv not found, necessary to stream audio."
             On mac you can install it with 'brew install mpv'.
             On linux and windows you can install it from https://mpv.io/`,
             });
         }
-        const mpv = (0, execa_1.default)("mpv", ["--no-cache", "--no-terminal", "--", "fd://0"]);
-        try {
-            for (_a = true, audio_1 = __asyncValues(audio); audio_1_1 = yield audio_1.next(), _b = audio_1_1.done, !_b; _a = true) {
-                _d = audio_1_1.value;
-                _a = false;
-                const data = _d;
-                (_e = mpv.stdin) === null || _e === void 0 ? void 0 : _e.write(data);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_a && !_b && (_c = audio_1.return)) yield _c.call(audio_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        (_f = mpv.stdin) === null || _f === void 0 ? void 0 : _f.end();
-        yield mpv;
+        const mpv = spawn("mpv", ["--no-cache", "--no-terminal", "--", "fd://0"], {
+            stdio: ["pipe", "ignore", "pipe"],
+        });
+        Readable.from((0, utils_1.toAsyncIterable)(audio)).pipe(mpv.stdin);
+        const errorChunks = [];
+        mpv.stderr.on("data", (chunk) => {
+            errorChunks.push(chunk);
+        });
+        return new Promise((resolve, reject) => {
+            mpv.on("close", (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    const error = Buffer.concat(errorChunks).toString();
+                    reject(new ElevenLabsError_1.ElevenLabsError({
+                        message: `mpv exited with code ${code}. Stderr: ${error}`,
+                    }));
+                }
+            });
+            mpv.on("error", (err) => {
+                reject(new ElevenLabsError_1.ElevenLabsError({ message: `Failed to start mpv: ${err.message}` }));
+            });
+        });
     });
 }

package/dist/wrapper/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isNode(): boolean;
+export declare function toAsyncIterable(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;

package/dist/wrapper/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNode = isNode;
+exports.toAsyncIterable = toAsyncIterable;
+function isNode() {
+    var _a;
+    return (typeof process !== "undefined" &&
+        process.versions != null &&
+        process.versions.node != null &&
+        ((_a = process.release) === null || _a === void 0 ? void 0 : _a.name) === "node");
+}
+function toAsyncIterable(stream) {
+    return __asyncGenerator(this, arguments, function* toAsyncIterable_1() {
+        const reader = stream.getReader();
+        try {
+            while (true) {
+                const { done, value } = yield __await(reader.read());
+                if (done) {
+                    return yield __await(void 0);
+                }
+                yield yield __await(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@elevenlabs/elevenlabs-js",
-    "version": "v2.3.0",
+    "version": "v2.4.1",
     "private": false,
     "repository": "https://github.com/elevenlabs/elevenlabs-js",
     "license": "MIT",
@@ -21,8 +21,7 @@
         "node-fetch": "^2.7.0",
         "qs": "^6.13.1",
         "form-data-encoder": "^4.0.2",
-        "command-exists": "^1.2.9",
-        "execa": "^5.1.1"
+        "command-exists": "^1.2.9"
     },
     "devDependencies": {
         "@types/url-join": "4.0.1",