assemblyai 4.0.0-beta.0 → 4.0.0-beta.2

package/dist/{index.browser.js → bun.mjs}

@@ -1,46 +1,5 @@
-/******************************************************************************
-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;
-};
+import { WritableStream } from '@swimburger/isomorphic-streams';
+import WebSocket from 'isomorphic-ws';
 
 /**
  * Base class for services that communicate with the API.
@@ -53,39 +12,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();
     }
 }
 
@@ -125,66 +83,6 @@ class LemurService extends BaseService {
     }
 }
 
-const {
-  ReadableStream,
-  ReadableStreamDefaultReader,
-  ReadableStreamBYOBReader,
-  ReadableStreamBYOBRequest,
-  ReadableByteStreamController,
-  ReadableStreamDefaultController,
-  TransformStream,
-  TransformStreamDefaultController,
-  WritableStream,
-  WritableStreamDefaultWriter,
-  WritableStreamDefaultController,
-  ByteLengthQueuingStrategy,
-  CountQueuingStrategy,
-  TextEncoderStream,
-  TextDecoderStream,
-} = window;
-
-// Polyfill to make ReadableStream async-iterable with for-await
-// https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate
-if (!ReadableStream.prototype[Symbol.asyncIterator]) {
-  async function* streamAsyncIterator() {
-    // Get a lock on the stream
-    const reader = this.getReader();
-
-    try {
-      while (true) {
-        // Read from the stream
-        const { done, value } = await reader.read();
-        // Exit if we're done
-        if (done) return;
-        // Else yield the chunk
-        yield value;
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-
-  ReadableStream.prototype[Symbol.asyncIterator] = streamAsyncIterator;
-}
-
-// https://github.com/maxogden/websocket-stream/blob/48dc3ddf943e5ada668c31ccd94e9186f02fafbd/ws-fallback.js
-
-var ws = null;
-
-if (typeof WebSocket !== 'undefined') {
-  ws = WebSocket;
-} else if (typeof MozWebSocket !== 'undefined') {
-  ws = MozWebSocket;
-} else if (typeof global !== 'undefined') {
-  ws = global.WebSocket || global.MozWebSocket;
-} else if (typeof window !== 'undefined') {
-  ws = window.WebSocket || window.MozWebSocket;
-} else if (typeof self !== 'undefined') {
-  ws = self.WebSocket || self.MozWebSocket;
-}
-
-var WebSocket$1 = ws;
-
 var RealtimeErrorType;
 (function (RealtimeErrorType) {
     RealtimeErrorType[RealtimeErrorType["BadSampleRate"] = 4000] = "BadSampleRate";
@@ -229,14 +127,13 @@ 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)
+        if ("apiKey" in params && params.apiKey)
             this.apiKey = params.apiKey;
-        if ("token" in params)
+        if ("token" in params && params.token)
             this.token = params.token;
         if (!(this.apiKey || this.token)) {
             throw new Error("API key or temporary token is required.");
@@ -269,34 +166,31 @@ class RealtimeService {
             }
             const url = this.connectionUrl();
             if (this.token) {
-                this.socket = new WebSocket$1(url.toString());
+                this.socket = new WebSocket(url.toString());
             }
             else {
-                this.socket = new WebSocket$1(url.toString(), {
+                this.socket = new WebSocket(url.toString(), {
                     headers: { Authorization: this.apiKey },
                 });
             }
             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) {
@@ -306,25 +200,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;
                     }
                 }
@@ -332,7 +226,7 @@ class RealtimeService {
         });
     }
     sendAudio(audio) {
-        if (!this.socket || this.socket.readyState !== WebSocket$1.OPEN) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
             throw new Error("Socket is not open for communication");
         }
         let audioData;
@@ -356,29 +250,27 @@ class RealtimeService {
             },
         });
     }
-    close(waitForSessionTermination = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.socket) {
-                if (this.socket.readyState === WebSocket$1.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;
     }
 }
 
@@ -395,14 +287,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;
     }
 }
 
@@ -417,42 +307,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.
@@ -461,23 +347,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".
@@ -485,27 +368,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.
@@ -519,30 +399,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
@@ -586,17 +461,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.
@@ -616,19 +489,12 @@ function getPath(path) {
         else
             return null;
     }
-    catch (_a) {
+    catch {
         return path;
     }
 }
 
-function throwError() {
-  throw new Error("Function is not supported in this environment.");
-}
-
-const createReadStream = throwError;
-var fs = {
-  createReadStream,
-};
+const readFile = async (path) => Bun.file(path).stream();
 
 class FileService extends BaseService {
     /**
@@ -636,23 +502,21 @@ class FileService extends BaseService {
      * @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;
     }
 }