@lingo.dev/_sdk 0.9.6 → 0.10.0

package/build/index.cjs

@@ -30,10 +30,11 @@ var LingoDotDevEngine = class {
    * @param payload - The content to be localized
    * @param params - Localization parameters including source/target locales and fast mode option
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Localized content
    * @internal
    */
-  async _localizeRaw(payload, params, progressCallback) {
+  async _localizeRaw(payload, params, progressCallback, signal) {
     const finalPayload = payloadSchema.parse(payload);
     const finalParams = localizationParamsSchema.parse(params);
     const chunkedPayload = this.extractPayloadChunks(finalPayload);
@@ -49,7 +50,8 @@ var LingoDotDevEngine = class {
         finalParams.targetLocale,
         { data: chunk, reference: params.reference },
         workflowId,
-        params.fast || false
+        params.fast || false,
+        signal
       );
       if (progressCallback) {
         progressCallback(percentageCompleted, chunk, processedPayloadChunk);
@@ -63,9 +65,12 @@ var LingoDotDevEngine = class {
    * @param sourceLocale - Source locale
    * @param targetLocale - Target locale
    * @param payload - Payload containing the chunk to be localized
+   * @param workflowId - Workflow ID for tracking
+   * @param fast - Whether to use fast mode
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Localized chunk
    */
-  async localizeChunk(sourceLocale, targetLocale, payload, workflowId, fast) {
+  async localizeChunk(sourceLocale, targetLocale, payload, workflowId, fast, signal) {
     const res = await fetch(`${this.config.apiUrl}/i18n`, {
       method: "POST",
       headers: {
@@ -84,7 +89,8 @@ var LingoDotDevEngine = class {
         },
         null,
         2
-      )
+      ),
+      signal
     });
     if (!res.ok) {
       if (res.status >= 500 && res.status < 600) {
@@ -158,10 +164,11 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns A new object with the same structure but localized string values
    */
-  async localizeObject(obj, params, progressCallback) {
-    return this._localizeRaw(obj, params, progressCallback);
+  async localizeObject(obj, params, progressCallback, signal) {
+    return this._localizeRaw(obj, params, progressCallback, signal);
   }
   /**
    * Localize a single text string
@@ -171,13 +178,15 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster for bigger batches)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns The localized text string
    */
-  async localizeText(text, params, progressCallback) {
+  async localizeText(text, params, progressCallback, signal) {
     const response = await this._localizeRaw(
       { text },
       params,
-      progressCallback
+      progressCallback,
+      signal
     );
     return response.text || "";
   }
@@ -188,16 +197,22 @@ var LingoDotDevEngine = class {
    *   - sourceLocale: The source language code (e.g., 'en')
    *   - targetLocales: An array of target language codes (e.g., ['es', 'fr'])
    *   - fast: Optional boolean to enable fast mode (for bigger batches)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns An array of localized text strings
    */
-  async batchLocalizeText(text, params) {
+  async batchLocalizeText(text, params, signal) {
     const responses = await Promise.all(
       params.targetLocales.map(
-        (targetLocale) => this.localizeText(text, {
-          sourceLocale: params.sourceLocale,
-          targetLocale,
-          fast: params.fast
-        })
+        (targetLocale) => this.localizeText(
+          text,
+          {
+            sourceLocale: params.sourceLocale,
+            targetLocale,
+            fast: params.fast
+          },
+          void 0,
+          signal
+        )
       )
     );
     return responses;
@@ -210,13 +225,15 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Array of localized chat messages with preserved structure
    */
-  async localizeChat(chat, params, progressCallback) {
+  async localizeChat(chat, params, progressCallback, signal) {
     const localized = await this._localizeRaw(
       { chat },
       params,
-      progressCallback
+      progressCallback,
+      signal
     );
     return Object.entries(localized).map(([key, value]) => ({
       name: chat[parseInt(key.split("_")[1])].name,
@@ -232,9 +249,10 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns The localized HTML document as a string, with updated lang attribute
    */
-  async localizeHtml(html, params, progressCallback) {
+  async localizeHtml(html, params, progressCallback, signal) {
     const jsdomPackage = await Promise.resolve().then(() => _interopRequireWildcard(require("jsdom")));
     const { JSDOM } = jsdomPackage;
     const dom = new JSDOM(html);
@@ -307,7 +325,8 @@ var LingoDotDevEngine = class {
     const localizedContent = await this._localizeRaw(
       extractedContent,
       params,
-      progressCallback
+      progressCallback,
+      signal
     );
     document.documentElement.setAttribute("lang", params.targetLocale);
     Object.entries(localizedContent).forEach(([path, value]) => {
@@ -337,16 +356,18 @@ var LingoDotDevEngine = class {
   /**
    * Detect the language of a given text
    * @param text - The text to analyze
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
    */
-  async recognizeLocale(text) {
+  async recognizeLocale(text, signal) {
     const response = await fetch(`${this.config.apiUrl}/recognize`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json; charset=utf-8",
         Authorization: `Bearer ${this.config.apiKey}`
       },
-      body: JSON.stringify({ text })
+      body: JSON.stringify({ text }),
+      signal
     });
     if (!response.ok) {
       if (response.status >= 500 && response.status < 600) {
@@ -359,14 +380,15 @@ var LingoDotDevEngine = class {
     const jsonResponse = await response.json();
     return jsonResponse.locale;
   }
-  async whoami() {
+  async whoami(signal) {
     try {
       const res = await fetch(`${this.config.apiUrl}/whoami`, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${this.config.apiKey}`,
           ContentType: "application/json"
-        }
+        },
+        signal
       });
       if (res.ok) {
         const payload = await res.json();

package/build/index.d.cts

@@ -51,15 +51,19 @@ declare class LingoDotDevEngine {
      * @param payload - The content to be localized
      * @param params - Localization parameters including source/target locales and fast mode option
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Localized content
      * @internal
      */
-    _localizeRaw(payload: Z.infer<typeof payloadSchema>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void): Promise<Record<string, string>>;
+    _localizeRaw(payload: Z.infer<typeof payloadSchema>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void, signal?: AbortSignal): Promise<Record<string, string>>;
     /**
      * Localize a single chunk of content
      * @param sourceLocale - Source locale
      * @param targetLocale - Target locale
      * @param payload - Payload containing the chunk to be localized
+     * @param workflowId - Workflow ID for tracking
+     * @param fast - Whether to use fast mode
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Localized chunk
      */
     private localizeChunk;
@@ -83,9 +87,10 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns A new object with the same structure but localized string values
      */
-    localizeObject(obj: Record<string, any>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void): Promise<Record<string, any>>;
+    localizeObject(obj: Record<string, any>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void, signal?: AbortSignal): Promise<Record<string, any>>;
     /**
      * Localize a single text string
      * @param text - The text string to be localized
@@ -94,9 +99,10 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster for bigger batches)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns The localized text string
      */
-    localizeText(text: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void): Promise<string>;
+    localizeText(text: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void, signal?: AbortSignal): Promise<string>;
     /**
      * Localize a text string to multiple target locales
      * @param text - The text string to be localized
@@ -104,13 +110,14 @@ declare class LingoDotDevEngine {
      *   - sourceLocale: The source language code (e.g., 'en')
      *   - targetLocales: An array of target language codes (e.g., ['es', 'fr'])
      *   - fast: Optional boolean to enable fast mode (for bigger batches)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns An array of localized text strings
      */
     batchLocalizeText(text: string, params: {
         sourceLocale: LocaleCode;
         targetLocales: LocaleCode[];
         fast?: boolean;
-    }): Promise<string[]>;
+    }, signal?: AbortSignal): Promise<string[]>;
     /**
      * Localize a chat sequence while preserving speaker names
      * @param chat - Array of chat messages, each with 'name' and 'text' properties
@@ -119,12 +126,13 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Array of localized chat messages with preserved structure
      */
     localizeChat(chat: Array<{
         name: string;
         text: string;
-    }>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void): Promise<Array<{
+    }>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void, signal?: AbortSignal): Promise<Array<{
         name: string;
         text: string;
     }>>;
@@ -137,16 +145,18 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns The localized HTML document as a string, with updated lang attribute
      */
-    localizeHtml(html: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void): Promise<string>;
+    localizeHtml(html: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void, signal?: AbortSignal): Promise<string>;
     /**
      * Detect the language of a given text
      * @param text - The text to analyze
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
      */
-    recognizeLocale(text: string): Promise<LocaleCode>;
-    whoami(): Promise<{
+    recognizeLocale(text: string, signal?: AbortSignal): Promise<LocaleCode>;
+    whoami(signal?: AbortSignal): Promise<{
         email: string;
         id: string;
     } | null>;

package/build/index.d.ts

@@ -51,15 +51,19 @@ declare class LingoDotDevEngine {
      * @param payload - The content to be localized
      * @param params - Localization parameters including source/target locales and fast mode option
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Localized content
      * @internal
      */
-    _localizeRaw(payload: Z.infer<typeof payloadSchema>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void): Promise<Record<string, string>>;
+    _localizeRaw(payload: Z.infer<typeof payloadSchema>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void, signal?: AbortSignal): Promise<Record<string, string>>;
     /**
      * Localize a single chunk of content
      * @param sourceLocale - Source locale
      * @param targetLocale - Target locale
      * @param payload - Payload containing the chunk to be localized
+     * @param workflowId - Workflow ID for tracking
+     * @param fast - Whether to use fast mode
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Localized chunk
      */
     private localizeChunk;
@@ -83,9 +87,10 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns A new object with the same structure but localized string values
      */
-    localizeObject(obj: Record<string, any>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void): Promise<Record<string, any>>;
+    localizeObject(obj: Record<string, any>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number, sourceChunk: Record<string, string>, processedChunk: Record<string, string>) => void, signal?: AbortSignal): Promise<Record<string, any>>;
     /**
      * Localize a single text string
      * @param text - The text string to be localized
@@ -94,9 +99,10 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster for bigger batches)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns The localized text string
      */
-    localizeText(text: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void): Promise<string>;
+    localizeText(text: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void, signal?: AbortSignal): Promise<string>;
     /**
      * Localize a text string to multiple target locales
      * @param text - The text string to be localized
@@ -104,13 +110,14 @@ declare class LingoDotDevEngine {
      *   - sourceLocale: The source language code (e.g., 'en')
      *   - targetLocales: An array of target language codes (e.g., ['es', 'fr'])
      *   - fast: Optional boolean to enable fast mode (for bigger batches)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns An array of localized text strings
      */
     batchLocalizeText(text: string, params: {
         sourceLocale: LocaleCode;
         targetLocales: LocaleCode[];
         fast?: boolean;
-    }): Promise<string[]>;
+    }, signal?: AbortSignal): Promise<string[]>;
     /**
      * Localize a chat sequence while preserving speaker names
      * @param chat - Array of chat messages, each with 'name' and 'text' properties
@@ -119,12 +126,13 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Array of localized chat messages with preserved structure
      */
     localizeChat(chat: Array<{
         name: string;
         text: string;
-    }>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void): Promise<Array<{
+    }>, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void, signal?: AbortSignal): Promise<Array<{
         name: string;
         text: string;
     }>>;
@@ -137,16 +145,18 @@ declare class LingoDotDevEngine {
      *   - targetLocale: The target language code (e.g., 'es')
      *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
      * @param progressCallback - Optional callback function to report progress (0-100)
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns The localized HTML document as a string, with updated lang attribute
      */
-    localizeHtml(html: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void): Promise<string>;
+    localizeHtml(html: string, params: Z.infer<typeof localizationParamsSchema>, progressCallback?: (progress: number) => void, signal?: AbortSignal): Promise<string>;
     /**
      * Detect the language of a given text
      * @param text - The text to analyze
+     * @param signal - Optional AbortSignal to cancel the operation
      * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
      */
-    recognizeLocale(text: string): Promise<LocaleCode>;
-    whoami(): Promise<{
+    recognizeLocale(text: string, signal?: AbortSignal): Promise<LocaleCode>;
+    whoami(signal?: AbortSignal): Promise<{
         email: string;
         id: string;
     } | null>;

package/build/index.mjs

@@ -30,10 +30,11 @@ var LingoDotDevEngine = class {
    * @param payload - The content to be localized
    * @param params - Localization parameters including source/target locales and fast mode option
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Localized content
    * @internal
    */
-  async _localizeRaw(payload, params, progressCallback) {
+  async _localizeRaw(payload, params, progressCallback, signal) {
     const finalPayload = payloadSchema.parse(payload);
     const finalParams = localizationParamsSchema.parse(params);
     const chunkedPayload = this.extractPayloadChunks(finalPayload);
@@ -49,7 +50,8 @@ var LingoDotDevEngine = class {
         finalParams.targetLocale,
         { data: chunk, reference: params.reference },
         workflowId,
-        params.fast || false
+        params.fast || false,
+        signal
       );
       if (progressCallback) {
         progressCallback(percentageCompleted, chunk, processedPayloadChunk);
@@ -63,9 +65,12 @@ var LingoDotDevEngine = class {
    * @param sourceLocale - Source locale
    * @param targetLocale - Target locale
    * @param payload - Payload containing the chunk to be localized
+   * @param workflowId - Workflow ID for tracking
+   * @param fast - Whether to use fast mode
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Localized chunk
    */
-  async localizeChunk(sourceLocale, targetLocale, payload, workflowId, fast) {
+  async localizeChunk(sourceLocale, targetLocale, payload, workflowId, fast, signal) {
     const res = await fetch(`${this.config.apiUrl}/i18n`, {
       method: "POST",
       headers: {
@@ -84,7 +89,8 @@ var LingoDotDevEngine = class {
         },
         null,
         2
-      )
+      ),
+      signal
     });
     if (!res.ok) {
       if (res.status >= 500 && res.status < 600) {
@@ -158,10 +164,11 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns A new object with the same structure but localized string values
    */
-  async localizeObject(obj, params, progressCallback) {
-    return this._localizeRaw(obj, params, progressCallback);
+  async localizeObject(obj, params, progressCallback, signal) {
+    return this._localizeRaw(obj, params, progressCallback, signal);
   }
   /**
    * Localize a single text string
@@ -171,13 +178,15 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster for bigger batches)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns The localized text string
    */
-  async localizeText(text, params, progressCallback) {
+  async localizeText(text, params, progressCallback, signal) {
     const response = await this._localizeRaw(
       { text },
       params,
-      progressCallback
+      progressCallback,
+      signal
     );
     return response.text || "";
   }
@@ -188,16 +197,22 @@ var LingoDotDevEngine = class {
    *   - sourceLocale: The source language code (e.g., 'en')
    *   - targetLocales: An array of target language codes (e.g., ['es', 'fr'])
    *   - fast: Optional boolean to enable fast mode (for bigger batches)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns An array of localized text strings
    */
-  async batchLocalizeText(text, params) {
+  async batchLocalizeText(text, params, signal) {
     const responses = await Promise.all(
       params.targetLocales.map(
-        (targetLocale) => this.localizeText(text, {
-          sourceLocale: params.sourceLocale,
-          targetLocale,
-          fast: params.fast
-        })
+        (targetLocale) => this.localizeText(
+          text,
+          {
+            sourceLocale: params.sourceLocale,
+            targetLocale,
+            fast: params.fast
+          },
+          void 0,
+          signal
+        )
       )
     );
     return responses;
@@ -210,13 +225,15 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Array of localized chat messages with preserved structure
    */
-  async localizeChat(chat, params, progressCallback) {
+  async localizeChat(chat, params, progressCallback, signal) {
     const localized = await this._localizeRaw(
       { chat },
       params,
-      progressCallback
+      progressCallback,
+      signal
     );
     return Object.entries(localized).map(([key, value]) => ({
       name: chat[parseInt(key.split("_")[1])].name,
@@ -232,9 +249,10 @@ var LingoDotDevEngine = class {
    *   - targetLocale: The target language code (e.g., 'es')
    *   - fast: Optional boolean to enable fast mode (faster but potentially lower quality)
    * @param progressCallback - Optional callback function to report progress (0-100)
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns The localized HTML document as a string, with updated lang attribute
    */
-  async localizeHtml(html, params, progressCallback) {
+  async localizeHtml(html, params, progressCallback, signal) {
     const jsdomPackage = await import("jsdom");
     const { JSDOM } = jsdomPackage;
     const dom = new JSDOM(html);
@@ -307,7 +325,8 @@ var LingoDotDevEngine = class {
     const localizedContent = await this._localizeRaw(
       extractedContent,
       params,
-      progressCallback
+      progressCallback,
+      signal
     );
     document.documentElement.setAttribute("lang", params.targetLocale);
     Object.entries(localizedContent).forEach(([path, value]) => {
@@ -337,16 +356,18 @@ var LingoDotDevEngine = class {
   /**
    * Detect the language of a given text
    * @param text - The text to analyze
+   * @param signal - Optional AbortSignal to cancel the operation
    * @returns Promise resolving to a locale code (e.g., 'en', 'es', 'fr')
    */
-  async recognizeLocale(text) {
+  async recognizeLocale(text, signal) {
     const response = await fetch(`${this.config.apiUrl}/recognize`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json; charset=utf-8",
         Authorization: `Bearer ${this.config.apiKey}`
       },
-      body: JSON.stringify({ text })
+      body: JSON.stringify({ text }),
+      signal
     });
     if (!response.ok) {
       if (response.status >= 500 && response.status < 600) {
@@ -359,14 +380,15 @@ var LingoDotDevEngine = class {
     const jsonResponse = await response.json();
     return jsonResponse.locale;
   }
-  async whoami() {
+  async whoami(signal) {
     try {
       const res = await fetch(`${this.config.apiUrl}/whoami`, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${this.config.apiKey}`,
           ContentType: "application/json"
-        }
+        },
+        signal
       });
       if (res.ok) {
         const payload = await res.json();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingo.dev/_sdk",
-  "version": "0.9.6",
+  "version": "0.10.0",
   "description": "Lingo.dev JS SDK",
   "private": false,
   "publishConfig": {