assemblyai 4.0.0-beta.1 → 4.0.0-beta.2

package/dist/{index.node.cjs → node.cjs}

@@ -3,50 +3,7 @@
 var isomorphicStreams = require('@swimburger/isomorphic-streams');
 var WebSocket = require('isomorphic-ws');
 var fs = require('fs');
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __awaiter(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());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
+var stream = require('stream');
 
 /**
  * Base class for services that communicate with the API.
@@ -59,39 +16,38 @@ class BaseService {
     constructor(params) {
         this.params = params;
     }
-    fetch(input, init) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            init = init !== null && init !== void 0 ? init : {};
-            init.headers = (_a = init.headers) !== null && _a !== void 0 ? _a : {};
-            init.headers = Object.assign({ Authorization: this.params.apiKey, "Content-Type": "application/json" }, init.headers);
-            if (!input.startsWith("http"))
-                input = this.params.baseUrl + input;
-            const response = yield fetch(input, init);
-            if (response.status >= 400) {
-                let json;
-                const text = yield response.text();
-                if (text) {
-                    try {
-                        json = JSON.parse(text);
-                    }
-                    catch (_b) {
-                        /* empty */
-                    }
-                    if (json === null || json === void 0 ? void 0 : json.error)
-                        throw new Error(json.error);
-                    throw new Error(text);
+    async fetch(input, init) {
+        init = init ?? {};
+        init.headers = init.headers ?? {};
+        init.headers = {
+            Authorization: this.params.apiKey,
+            "Content-Type": "application/json",
+            ...init.headers,
+        };
+        if (!input.startsWith("http"))
+            input = this.params.baseUrl + input;
+        const response = await fetch(input, init);
+        if (response.status >= 400) {
+            let json;
+            const text = await response.text();
+            if (text) {
+                try {
+                    json = JSON.parse(text);
+                }
+                catch {
+                    /* empty */
                 }
-                throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+                if (json?.error)
+                    throw new Error(json.error);
+                throw new Error(text);
             }
-            return response;
-        });
+            throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+        }
+        return response;
     }
-    fetchJson(input, init) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.fetch(input, init);
-            return response.json();
-        });
+    async fetchJson(input, init) {
+        const response = await this.fetch(input, init);
+        return response.json();
     }
 }
 
@@ -175,10 +131,9 @@ class RealtimeError extends Error {
 const defaultRealtimeUrl = "wss://api.assemblyai.com/v2/realtime/ws";
 class RealtimeService {
     constructor(params) {
-        var _a, _b;
         this.listeners = {};
-        this.realtimeUrl = (_a = params.realtimeUrl) !== null && _a !== void 0 ? _a : defaultRealtimeUrl;
-        this.sampleRate = (_b = params.sampleRate) !== null && _b !== void 0 ? _b : 16000;
+        this.realtimeUrl = params.realtimeUrl ?? defaultRealtimeUrl;
+        this.sampleRate = params.sampleRate ?? 16000;
         this.wordBoost = params.wordBoost;
         if ("apiKey" in params && params.apiKey)
             this.apiKey = params.apiKey;
@@ -223,26 +178,23 @@ class RealtimeService {
                 });
             }
             this.socket.onclose = ({ code, reason }) => {
-                var _a, _b;
                 if (!reason) {
                     if (code in RealtimeErrorType) {
                         reason = RealtimeErrorMessages[code];
                     }
                 }
-                (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason);
+                this.listeners.close?.(code, reason);
             };
             this.socket.onerror = (event) => {
-                var _a, _b, _c, _d;
                 if (event.error)
-                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, event.error);
+                    this.listeners.error?.(event.error);
                 else
-                    (_d = (_c = this.listeners).error) === null || _d === void 0 ? void 0 : _d.call(_c, new Error(event.message));
+                    this.listeners.error?.(new Error(event.message));
             };
             this.socket.onmessage = ({ data }) => {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
                 const message = JSON.parse(data.toString());
                 if ("error" in message) {
-                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, new RealtimeError(message.error));
+                    this.listeners.error?.(new RealtimeError(message.error));
                     return;
                 }
                 switch (message.message_type) {
@@ -252,25 +204,25 @@ class RealtimeService {
                             expiresAt: new Date(message.expires_at),
                         };
                         resolve(openObject);
-                        (_d = (_c = this.listeners).open) === null || _d === void 0 ? void 0 : _d.call(_c, openObject);
+                        this.listeners.open?.(openObject);
                         break;
                     }
                     case "PartialTranscript": {
                         // message.created is actually a string when coming from the socket
                         message.created = new Date(message.created);
-                        (_f = (_e = this.listeners).transcript) === null || _f === void 0 ? void 0 : _f.call(_e, message);
-                        (_h = (_g = this.listeners)["transcript.partial"]) === null || _h === void 0 ? void 0 : _h.call(_g, message);
+                        this.listeners.transcript?.(message);
+                        this.listeners["transcript.partial"]?.(message);
                         break;
                     }
                     case "FinalTranscript": {
                         // message.created is actually a string when coming from the socket
                         message.created = new Date(message.created);
-                        (_k = (_j = this.listeners).transcript) === null || _k === void 0 ? void 0 : _k.call(_j, message);
-                        (_m = (_l = this.listeners)["transcript.final"]) === null || _m === void 0 ? void 0 : _m.call(_l, message);
+                        this.listeners.transcript?.(message);
+                        this.listeners["transcript.final"]?.(message);
                         break;
                     }
                     case "SessionTerminated": {
-                        (_o = this.sessionTerminatedResolve) === null || _o === void 0 ? void 0 : _o.call(this);
+                        this.sessionTerminatedResolve?.();
                         break;
                     }
                 }
@@ -302,29 +254,27 @@ class RealtimeService {
             },
         });
     }
-    close(waitForSessionTermination = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.socket) {
-                if (this.socket.readyState === WebSocket.OPEN) {
-                    const terminateSessionMessage = `{"terminate_session": true}`;
-                    if (waitForSessionTermination) {
-                        const sessionTerminatedPromise = new Promise((resolve) => {
-                            this.sessionTerminatedResolve = resolve;
-                        });
-                        this.socket.send(terminateSessionMessage);
-                        yield sessionTerminatedPromise;
-                    }
-                    else {
-                        this.socket.send(terminateSessionMessage);
-                    }
+    async close(waitForSessionTermination = true) {
+        if (this.socket) {
+            if (this.socket.readyState === WebSocket.OPEN) {
+                const terminateSessionMessage = `{"terminate_session": true}`;
+                if (waitForSessionTermination) {
+                    const sessionTerminatedPromise = new Promise((resolve) => {
+                        this.sessionTerminatedResolve = resolve;
+                    });
+                    this.socket.send(terminateSessionMessage);
+                    await sessionTerminatedPromise;
+                }
+                else {
+                    this.socket.send(terminateSessionMessage);
                 }
-                if ("removeAllListeners" in this.socket)
-                    this.socket.removeAllListeners();
-                this.socket.close();
             }
-            this.listeners = {};
-            this.socket = undefined;
-        });
+            if ("removeAllListeners" in this.socket)
+                this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        this.listeners = {};
+        this.socket = undefined;
     }
 }
 
@@ -341,14 +291,12 @@ class RealtimeServiceFactory extends BaseService {
         }
         return new RealtimeService(params);
     }
-    createTemporaryToken(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.fetchJson("/v2/realtime/token", {
-                method: "POST",
-                body: JSON.stringify(params),
-            });
-            return data.token;
+    async createTemporaryToken(params) {
+        const data = await this.fetchJson("/v2/realtime/token", {
+            method: "POST",
+            body: JSON.stringify(params),
         });
+        return data.token;
     }
 }
 
@@ -363,42 +311,38 @@ class TranscriptService extends BaseService {
      * @param options The options to transcribe an audio file.
      * @returns A promise that resolves to the transcript. The transcript status is "completed" or "error".
      */
-    transcribe(params, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transcript = yield this.submit(params);
-            return yield this.waitUntilReady(transcript.id, options);
-        });
+    async transcribe(params, options) {
+        const transcript = await this.submit(params);
+        return await this.waitUntilReady(transcript.id, options);
     }
     /**
      * Submits a transcription job for an audio file. This will not wait until the transcript status is "completed" or "error".
      * @param params The parameters to start the transcription of an audio file.
      * @returns A promise that resolves to the queued transcript.
      */
-    submit(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { audio } = params, createParams = __rest(params, ["audio"]);
-            let audioUrl;
-            if (typeof audio === "string") {
-                const path = getPath(audio);
-                if (path !== null) {
-                    // audio is local path, upload local file
-                    audioUrl = yield this.files.upload(path);
-                }
-                else {
-                    // audio is not a local path, assume it's a URL
-                    audioUrl = audio;
-                }
+    async submit(params) {
+        const { audio, ...createParams } = params;
+        let audioUrl;
+        if (typeof audio === "string") {
+            const path = getPath(audio);
+            if (path !== null) {
+                // audio is local path, upload local file
+                audioUrl = await this.files.upload(path);
             }
             else {
-                // audio is of uploadable type
-                audioUrl = yield this.files.upload(audio);
+                // audio is not a local path, assume it's a URL
+                audioUrl = audio;
             }
-            const data = yield this.fetchJson("/v2/transcript", {
-                method: "POST",
-                body: JSON.stringify(Object.assign(Object.assign({}, createParams), { audio_url: audioUrl })),
-            });
-            return data;
+        }
+        else {
+            // audio is of uploadable type
+            audioUrl = await this.files.upload(audio);
+        }
+        const data = await this.fetchJson("/v2/transcript", {
+            method: "POST",
+            body: JSON.stringify({ ...createParams, audio_url: audioUrl }),
         });
+        return data;
     }
     /**
      * Create a transcript.
@@ -407,23 +351,20 @@ class TranscriptService extends BaseService {
      * @returns A promise that resolves to the transcript.
      * @deprecated Use `transcribe` instead to transcribe a audio file that includes polling, or `submit` to transcribe a audio file without polling.
      */
-    create(params, options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = getPath(params.audio_url);
-            if (path !== null) {
-                const uploadUrl = yield this.files.upload(path);
-                params.audio_url = uploadUrl;
-            }
-            const data = yield this.fetchJson("/v2/transcript", {
-                method: "POST",
-                body: JSON.stringify(params),
-            });
-            if ((_a = options === null || options === void 0 ? void 0 : options.poll) !== null && _a !== void 0 ? _a : true) {
-                return yield this.waitUntilReady(data.id, options);
-            }
-            return data;
+    async create(params, options) {
+        const path = getPath(params.audio_url);
+        if (path !== null) {
+            const uploadUrl = await this.files.upload(path);
+            params.audio_url = uploadUrl;
+        }
+        const data = await this.fetchJson("/v2/transcript", {
+            method: "POST",
+            body: JSON.stringify(params),
         });
+        if (options?.poll ?? true) {
+            return await this.waitUntilReady(data.id, options);
+        }
+        return data;
     }
     /**
      * Wait until the transcript ready, either the status is "completed" or "error".
@@ -431,27 +372,24 @@ class TranscriptService extends BaseService {
      * @param options The options to wait until the transcript is ready.
      * @returns A promise that resolves to the transcript. The transcript status is "completed" or "error".
      */
-    waitUntilReady(transcriptId, options) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const pollingInterval = (_a = options === null || options === void 0 ? void 0 : options.pollingInterval) !== null && _a !== void 0 ? _a : 3000;
-            const pollingTimeout = (_b = options === null || options === void 0 ? void 0 : options.pollingTimeout) !== null && _b !== void 0 ? _b : -1;
-            const startTime = Date.now();
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const transcript = yield this.get(transcriptId);
-                if (transcript.status === "completed" || transcript.status === "error") {
-                    return transcript;
-                }
-                else if (pollingTimeout > 0 &&
-                    Date.now() - startTime > pollingTimeout) {
-                    throw new Error("Polling timeout");
-                }
-                else {
-                    yield new Promise((resolve) => setTimeout(resolve, pollingInterval));
-                }
+    async waitUntilReady(transcriptId, options) {
+        const pollingInterval = options?.pollingInterval ?? 3000;
+        const pollingTimeout = options?.pollingTimeout ?? -1;
+        const startTime = Date.now();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const transcript = await this.get(transcriptId);
+            if (transcript.status === "completed" || transcript.status === "error") {
+                return transcript;
             }
-        });
+            else if (pollingTimeout > 0 &&
+                Date.now() - startTime > pollingTimeout) {
+                throw new Error("Polling timeout");
+            }
+            else {
+                await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            }
+        }
     }
     /**
      * Retrieve a transcript.
@@ -465,30 +403,25 @@ class TranscriptService extends BaseService {
      * Retrieves a page of transcript listings.
      * @param parameters The parameters to filter the transcript list by, or the URL to retrieve the transcript list from.
      */
-    list(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let url = "/v2/transcript";
-            if (typeof parameters === "string") {
-                url = parameters;
-            }
-            else if (parameters) {
-                url = `${url}?${new URLSearchParams(Object.keys(parameters).map((key) => {
-                    var _a;
-                    return [
-                        key,
-                        ((_a = parameters[key]) === null || _a === void 0 ? void 0 : _a.toString()) || "",
-                    ];
-                }))}`;
-            }
-            const data = yield this.fetchJson(url);
-            for (const transcriptListItem of data.transcripts) {
-                transcriptListItem.created = new Date(transcriptListItem.created);
-                if (transcriptListItem.completed) {
-                    transcriptListItem.completed = new Date(transcriptListItem.completed);
-                }
+    async list(parameters) {
+        let url = "/v2/transcript";
+        if (typeof parameters === "string") {
+            url = parameters;
+        }
+        else if (parameters) {
+            url = `${url}?${new URLSearchParams(Object.keys(parameters).map((key) => [
+                key,
+                parameters[key]?.toString() || "",
+            ]))}`;
+        }
+        const data = await this.fetchJson(url);
+        for (const transcriptListItem of data.transcripts) {
+            transcriptListItem.created = new Date(transcriptListItem.created);
+            if (transcriptListItem.completed) {
+                transcriptListItem.completed = new Date(transcriptListItem.completed);
             }
-            return data;
-        });
+        }
+        return data;
     }
     /**
      * Delete a transcript
@@ -532,17 +465,15 @@ class TranscriptService extends BaseService {
      * @param chars_per_caption The maximum number of characters per caption.
      * @return A promise that resolves to the subtitles text.
      */
-    subtitles(id, format = "srt", chars_per_caption) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let url = `/v2/transcript/${id}/${format}`;
-            if (chars_per_caption) {
-                const params = new URLSearchParams();
-                params.set("chars_per_caption", chars_per_caption.toString());
-                url += `?${params.toString()}`;
-            }
-            const response = yield this.fetch(url);
-            return yield response.text();
-        });
+    async subtitles(id, format = "srt", chars_per_caption) {
+        let url = `/v2/transcript/${id}/${format}`;
+        if (chars_per_caption) {
+            const params = new URLSearchParams();
+            params.set("chars_per_caption", chars_per_caption.toString());
+            url += `?${params.toString()}`;
+        }
+        const response = await this.fetch(url);
+        return await response.text();
     }
     /**
      * Retrieve redactions of a transcript.
@@ -562,34 +493,34 @@ function getPath(path) {
         else
             return null;
     }
-    catch (_a) {
+    catch {
         return path;
     }
 }
 
+const readFile = async (path) => stream.Readable.toWeb(fs.createReadStream(path));
+
 class FileService extends BaseService {
     /**
      * Upload a local file to AssemblyAI.
      * @param input The local file path to upload, or a stream or buffer of the file to upload.
      * @return A promise that resolves to the uploaded file URL.
      */
-    upload(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let fileData;
-            if (typeof input === "string")
-                fileData = fs.createReadStream(input);
-            else
-                fileData = input;
-            const data = yield this.fetchJson("/v2/upload", {
-                method: "POST",
-                body: fileData,
-                headers: {
-                    "Content-Type": "application/octet-stream",
-                },
-                duplex: "half",
-            });
-            return data.upload_url;
+    async upload(input) {
+        let fileData;
+        if (typeof input === "string")
+            fileData = await readFile(input);
+        else
+            fileData = input;
+        const data = await this.fetchJson("/v2/upload", {
+            method: "POST",
+            body: fileData,
+            headers: {
+                "Content-Type": "application/octet-stream",
+            },
+            duplex: "half",
         });
+        return data.upload_url;
     }
 }