@translated/lara 1.7.0 → 1.7.2

package/lib/net/node-client.js

@@ -12,10 +12,10 @@ const form_data_1 = __importDefault(require("form-data"));
 const client_1 = require("./client");
 /** @internal */
 class NodeLaraClient extends client_1.LaraClient {
-    constructor(baseUrl, accessKeyId, accessKeySecret) {
+    constructor(baseUrl, accessKeyId, accessKeySecret, keepAlive = true) {
         super(accessKeyId, accessKeySecret);
         this.baseUrl = baseUrl;
-        this.agent = baseUrl.secure ? new node_https_1.default.Agent({ keepAlive: true }) : new node_http_1.default.Agent({ keepAlive: true });
+        this.agent = baseUrl.secure ? new node_https_1.default.Agent({ keepAlive }) : new node_http_1.default.Agent({ keepAlive });
     }
     async send(path, headers, body) {
         let requestBody;
@@ -71,15 +71,24 @@ class NodeLaraClient extends client_1.LaraClient {
                         json = JSON.parse(data);
                     }
                     catch (_e) {
-                        reject(new SyntaxError("Invalid JSON response"));
+                        return reject(new SyntaxError("Invalid JSON response"));
                     }
                     resolve({
                         statusCode: res.statusCode,
                         body: json
                     });
                 });
+                // close connection on error
+                res.on("error", (err) => {
+                    req.destroy();
+                    return reject(err);
+                });
+            });
+            // close connection on error
+            req.on("error", (err) => {
+                req.destroy();
+                return reject(err);
             });
-            req.on("error", reject);
             if (requestBody instanceof form_data_1.default) {
                 requestBody.pipe(req);
             }
@@ -92,6 +101,137 @@ class NodeLaraClient extends client_1.LaraClient {
             }
         });
     }
+    async *sendAndGetStream(path, headers, body) {
+        let requestBody;
+        if (body) {
+            if (headers["Content-Type"] === "multipart/form-data") {
+                const formBody = new form_data_1.default();
+                for (const [key, value] of Object.entries(body)) {
+                    if (!value)
+                        continue;
+                    if (Array.isArray(value)) {
+                        for (const v of value)
+                            formBody.append(key, v);
+                    }
+                    else {
+                        formBody.append(key, value);
+                    }
+                }
+                headers = {
+                    ...headers,
+                    ...formBody.getHeaders()
+                };
+                requestBody = formBody;
+            }
+            else {
+                requestBody = JSON.stringify(body, undefined, 0);
+            }
+        }
+        const options = {
+            host: this.baseUrl.hostname,
+            port: this.baseUrl.port,
+            path: path,
+            method: "POST",
+            headers: headers,
+            agent: this.agent
+        };
+        // Create async iterator from the stream
+        const chunks = [];
+        let resolveChunk = null;
+        let streamEnded = false;
+        let streamError = null;
+        const req = (this.baseUrl.secure ? node_https_1.default : node_http_1.default).request(options, (res) => {
+            let buffer = "";
+            res.on("data", (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split("\n");
+                // {a}\n{b}\n{c}\n --> [{a}, {b}, {c}, ""]
+                // {a}\n{b}\n{c} --> [{a}, {b}, {c}]
+                buffer = lines.pop() || ""; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    if (line.trim()) {
+                        try {
+                            const json = JSON.parse(line);
+                            chunks.push({
+                                statusCode: json.status || res.statusCode,
+                                body: json.data || json
+                            });
+                            if (resolveChunk) {
+                                resolveChunk();
+                                resolveChunk = null;
+                            }
+                        }
+                        catch (_e) {
+                            // Skip invalid JSON lines
+                        }
+                    }
+                }
+            });
+            res.on("end", () => {
+                // Process any remaining data in buffer
+                if (buffer.trim()) {
+                    try {
+                        const json = JSON.parse(buffer);
+                        chunks.push({
+                            statusCode: json.status || res.statusCode,
+                            body: json.data || json
+                        });
+                    }
+                    catch (_e) {
+                        // Skip invalid JSON
+                    }
+                }
+                streamEnded = true;
+                if (resolveChunk) {
+                    resolveChunk();
+                    resolveChunk = null;
+                }
+            });
+            res.on("error", (err) => {
+                req.destroy();
+                streamError = err;
+                if (resolveChunk) {
+                    resolveChunk();
+                    resolveChunk = null;
+                }
+            });
+        });
+        req.on("error", (err) => {
+            streamError = err;
+            if (resolveChunk) {
+                resolveChunk();
+                resolveChunk = null;
+            }
+        });
+        if (requestBody instanceof form_data_1.default) {
+            requestBody.pipe(req);
+        }
+        else if (requestBody) {
+            req.write(requestBody);
+            req.end();
+        }
+        else {
+            req.end();
+        }
+        // Yield chunks as they arrive
+        while (true) {
+            if (streamError) {
+                throw streamError;
+            }
+            if (chunks.length > 0) {
+                yield chunks.shift();
+            }
+            else if (streamEnded) {
+                break;
+            }
+            else {
+                // Wait for next chunk
+                await new Promise((resolve) => {
+                    resolveChunk = resolve;
+                });
+            }
+        }
+    }
     wrapMultiPartFile(file) {
         if (typeof file === "string")
             file = node_fs_1.default.createReadStream(file);

package/lib/net/s3/browser-client.d.ts

@@ -1,4 +1,4 @@
-import type { S3UploadFields } from "../../translator/translator";
+import type { S3UploadFields } from "../../documents";
 import type { MultiPartFile } from "../client";
 import { S3Client } from "./client";
 /** @internal */

package/lib/net/s3/client.d.ts

@@ -1,4 +1,4 @@
-import type { S3UploadFields } from "../../translator/translator";
+import type { S3UploadFields } from "../../documents";
 import type { MultiPartFile } from "../client";
 /** @internal */
 export declare abstract class S3Client {

package/lib/net/s3/node-client.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from "node:stream";
-import type { S3UploadFields } from "../../translator/translator";
+import type { S3UploadFields } from "../../documents";
 import type { MultiPartFile } from "../client";
 import { S3Client } from "./client";
 /** @internal */

package/lib/translator.d.ts

@@ -0,0 +1,68 @@
+import type { Credentials } from "./credentials";
+import { Documents } from "./documents";
+import { Glossaries } from "./glossaries";
+import { Memories } from "./memories";
+import { type LaraClient } from "./net";
+export type TranslatorOptions = {
+    serverUrl?: string;
+    keepAlive?: boolean;
+};
+export interface NGMemoryMatch {
+    memory: string;
+    tuid?: string;
+    language: [string, string];
+    sentence: string;
+    translation: string;
+    score: number;
+}
+export interface NGGlossaryMatch {
+    glossary: string;
+    language: [string, string];
+    term: string;
+    translation: string;
+}
+export interface TextBlock {
+    readonly text: string;
+    readonly translatable?: boolean;
+}
+export interface TextResult<T extends string | string[] | TextBlock[]> {
+    readonly contentType: string;
+    readonly sourceLanguage: string;
+    readonly translation: T;
+    readonly adaptedTo?: string[];
+    readonly glossaries?: string[];
+    readonly adaptedToMatches?: NGMemoryMatch[] | NGMemoryMatch[][];
+    readonly glossariesMatches?: NGGlossaryMatch[] | NGGlossaryMatch[][];
+}
+export type TranslateOptions = {
+    sourceHint?: string;
+    adaptTo?: string[];
+    instructions?: string[];
+    glossaries?: string[];
+    contentType?: string;
+    multiline?: boolean;
+    timeoutInMillis?: number;
+    priority?: "normal" | "background";
+    useCache?: boolean | "overwrite";
+    cacheTTLSeconds?: number;
+    noTrace?: boolean;
+    verbose?: boolean;
+    headers?: Record<string, string>;
+    style?: TranslationStyle;
+    reasoning?: boolean;
+};
+export type TranslationStyle = "faithful" | "fluid" | "creative";
+export interface DetectResult {
+    language: string;
+    contentType: string;
+}
+export declare class Translator {
+    protected readonly client: LaraClient;
+    readonly memories: Memories;
+    readonly documents: Documents;
+    readonly glossaries: Glossaries;
+    constructor(credentials: Credentials, options?: TranslatorOptions);
+    getLanguages(): Promise<string[]>;
+    translate<T extends string | string[] | TextBlock[]>(text: T, source: string | null, target: string, options?: TranslateOptions, callback?: (partialResult: TextResult<T>) => void): Promise<TextResult<T>>;
+    detect(text: string | string[], hint?: string, passlist?: string[]): Promise<DetectResult>;
+}

package/lib/translator.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translator = void 0;
+const documents_1 = require("./documents");
+const glossaries_1 = require("./glossaries");
+const memories_1 = require("./memories");
+const net_1 = __importDefault(require("./net"));
+class Translator {
+    constructor(credentials, options) {
+        this.client = (0, net_1.default)(credentials.accessKeyId, credentials.accessKeySecret, options === null || options === void 0 ? void 0 : options.serverUrl, options === null || options === void 0 ? void 0 : options.keepAlive);
+        this.memories = new memories_1.Memories(this.client);
+        this.documents = new documents_1.Documents(this.client);
+        this.glossaries = new glossaries_1.Glossaries(this.client);
+    }
+    async getLanguages() {
+        return await this.client.get("/languages");
+    }
+    async translate(text, source, target, options, callback) {
+        const headers = {};
+        if (options === null || options === void 0 ? void 0 : options.headers) {
+            for (const [name, value] of Object.entries(options.headers)) {
+                headers[name] = value;
+            }
+        }
+        if (options === null || options === void 0 ? void 0 : options.noTrace) {
+            headers["X-No-Trace"] = "true";
+        }
+        const response = this.client.postAndGetStream("/translate", {
+            q: text,
+            source,
+            target,
+            source_hint: options === null || options === void 0 ? void 0 : options.sourceHint,
+            content_type: options === null || options === void 0 ? void 0 : options.contentType,
+            multiline: (options === null || options === void 0 ? void 0 : options.multiline) !== false,
+            adapt_to: options === null || options === void 0 ? void 0 : options.adaptTo,
+            glossaries: options === null || options === void 0 ? void 0 : options.glossaries,
+            instructions: options === null || options === void 0 ? void 0 : options.instructions,
+            timeout: options === null || options === void 0 ? void 0 : options.timeoutInMillis,
+            priority: options === null || options === void 0 ? void 0 : options.priority,
+            use_cache: options === null || options === void 0 ? void 0 : options.useCache,
+            cache_ttl: options === null || options === void 0 ? void 0 : options.cacheTTLSeconds,
+            verbose: options === null || options === void 0 ? void 0 : options.verbose,
+            style: options === null || options === void 0 ? void 0 : options.style,
+            reasoning: options === null || options === void 0 ? void 0 : options.reasoning
+        }, undefined, headers);
+        let lastResult;
+        for await (const partial of response) {
+            if ((options === null || options === void 0 ? void 0 : options.reasoning) && callback)
+                callback(partial);
+            lastResult = partial;
+        }
+        if (!lastResult)
+            throw new Error("No translation result received.");
+        return lastResult;
+    }
+    async detect(text, hint, passlist) {
+        return await this.client.post("/detect", {
+            q: text,
+            hint,
+            passlist
+        });
+    }
+}
+exports.Translator = Translator;

package/lib/utils/sdk-version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.7.2";

package/lib/{sdk-version.js → utils/sdk-version.js}

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = "1.7.0";
+exports.version = "1.7.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@translated/lara",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "engines": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "build": "rm -rf lib/* lib-browser/* && node scripts/generate-sdk-version.js && tsc && webpack",
-    "version": "node scripts/generate-sdk-version.js && git add src/sdk-version.ts",
+    "version": "node scripts/generate-sdk-version.js && git add src/utils/sdk-version.ts",
     "biome:check": "biome check",
     "biome:write": "biome check --write"
   },

package/lib/sdk-version.d.ts

@@ -1 +0,0 @@
-export declare const version = "1.7.0";

package/lib/translator/models.d.ts

@@ -1,109 +0,0 @@
-export interface Memory {
-    readonly id: string;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readonly sharedAt: Date;
-    readonly name: string;
-    readonly externalId?: string;
-    readonly secret?: string;
-    readonly ownerId: string;
-    readonly collaboratorsCount: number;
-}
-export interface MemoryImport {
-    readonly id: string;
-    readonly begin: number;
-    readonly end: number;
-    readonly channel: number;
-    readonly size: number;
-    readonly progress: number;
-}
-export declare enum DocumentStatus {
-    INITIALIZED = "initialized",// just been created
-    ANALYZING = "analyzing",// being analyzed for language detection and chars count
-    PAUSED = "paused",// paused after analysis, needs user confirm
-    READY = "ready",// ready to be translated
-    TRANSLATING = "translating",
-    TRANSLATED = "translated",
-    ERROR = "error"
-}
-export interface DocxExtractionParams {
-    extractComments?: boolean;
-    acceptRevisions?: boolean;
-}
-export type DocumentOptions = {
-    adaptTo?: string[];
-    glossaries?: string[];
-    noTrace?: boolean;
-    style?: TranslationStyle;
-};
-export type DocumentDownloadOptions = {
-    outputFormat?: string;
-};
-export type DocumentUploadOptions = DocumentOptions & {
-    password?: string;
-    extractionParams?: DocxExtractionParams;
-};
-export interface Document {
-    readonly id: string;
-    readonly status: DocumentStatus;
-    readonly source?: string;
-    readonly target: string;
-    readonly filename: string;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readonly options?: DocumentOptions;
-    readonly translatedChars?: number;
-    readonly totalChars?: number;
-    readonly errorReason?: string;
-}
-export interface TextBlock {
-    readonly text: string;
-    readonly translatable?: boolean;
-}
-export interface NGMemoryMatch {
-    memory: string;
-    tuid?: string;
-    language: [string, string];
-    sentence: string;
-    translation: string;
-    score: number;
-}
-export interface NGGlossaryMatch {
-    glossary: string;
-    language: [string, string];
-    term: string;
-    translation: string;
-}
-export interface TextResult<T extends string | string[] | TextBlock[]> {
-    readonly contentType: string;
-    readonly sourceLanguage: string;
-    readonly translation: T;
-    readonly adaptedTo?: string[];
-    readonly glossaries?: string[];
-    readonly adaptedToMatches?: NGMemoryMatch[] | NGMemoryMatch[][];
-    readonly glossariesMatches?: NGGlossaryMatch[] | NGGlossaryMatch[][];
-}
-export interface DetectResult {
-    language: string;
-    contentType: string;
-}
-export interface Glossary {
-    readonly id: string;
-    readonly name: string;
-    readonly ownerId: string;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-}
-export interface GlossaryImport {
-    readonly id: string;
-    readonly begin: number;
-    readonly end: number;
-    readonly channel: number;
-    readonly size: number;
-    readonly progress: number;
-}
-export interface GlossaryCounts {
-    unidirectional?: Record<string, number>;
-    multidirectional?: number;
-}
-export type TranslationStyle = "faithful" | "fluid" | "creative";

package/lib/translator/models.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentStatus = void 0;
-// biome-ignore format: keep comments aligned
-var DocumentStatus;
-(function (DocumentStatus) {
-    DocumentStatus["INITIALIZED"] = "initialized";
-    DocumentStatus["ANALYZING"] = "analyzing";
-    DocumentStatus["PAUSED"] = "paused";
-    DocumentStatus["READY"] = "ready";
-    DocumentStatus["TRANSLATING"] = "translating";
-    DocumentStatus["TRANSLATED"] = "translated";
-    DocumentStatus["ERROR"] = "error";
-})(DocumentStatus || (exports.DocumentStatus = DocumentStatus = {}));

package/lib/translator/translator.d.ts

@@ -1,81 +0,0 @@
-import type { Credentials } from "../credentials";
-import { type LaraClient } from "../net";
-import type { MultiPartFile } from "../net/client";
-import { type DetectResult, type Document, type DocumentDownloadOptions, type DocumentUploadOptions, type Glossary, type GlossaryCounts, type GlossaryImport, type Memory, type MemoryImport, type TextBlock, type TextResult, type TranslationStyle } from "./models";
-export type TranslatorOptions = {
-    serverUrl?: string;
-};
-export type MemoryImportCallback = (memoryImport: MemoryImport) => void;
-export declare class Memories {
-    private readonly client;
-    private readonly pollingInterval;
-    constructor(client: LaraClient);
-    list(): Promise<Memory[]>;
-    create(name: string, externalId?: string): Promise<Memory>;
-    get(id: string): Promise<Memory | null>;
-    delete(id: string): Promise<Memory>;
-    update(id: string, name: string): Promise<Memory>;
-    connect<T extends string | string[]>(ids: T): Promise<T extends string ? Memory : Memory[]>;
-    importTmx(id: string, tmx: MultiPartFile, gzip?: boolean): Promise<MemoryImport>;
-    addTranslation(id: string | string[], source: string, target: string, sentence: string, translation: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: string, headers?: Record<string, string>): Promise<MemoryImport>;
-    deleteTranslation(id: string | string[], source: string, target: string, sentence?: string, translation?: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: string): Promise<MemoryImport>;
-    getImportStatus(id: string): Promise<MemoryImport>;
-    waitForImport(mImport: MemoryImport, updateCallback?: MemoryImportCallback, maxWaitTime?: number): Promise<MemoryImport>;
-}
-export type TranslateOptions = {
-    sourceHint?: string;
-    adaptTo?: string[];
-    instructions?: string[];
-    glossaries?: string[];
-    contentType?: string;
-    multiline?: boolean;
-    timeoutInMillis?: number;
-    priority?: "normal" | "background";
-    useCache?: boolean | "overwrite";
-    cacheTTLSeconds?: number;
-    noTrace?: boolean;
-    verbose?: boolean;
-    headers?: Record<string, string>;
-    style?: TranslationStyle;
-};
-export type DocumentTranslateOptions = DocumentUploadOptions & DocumentDownloadOptions;
-export type S3UploadFields = {
-    acl: string;
-    bucket: string;
-    key: string;
-};
-export declare class Documents {
-    private readonly client;
-    private readonly s3Client;
-    constructor(client: LaraClient);
-    upload(file: MultiPartFile, filename: string, source: string | null, target: string, options?: DocumentUploadOptions): Promise<Document>;
-    status(id: string): Promise<Document>;
-    download(id: string, options?: DocumentDownloadOptions): Promise<Blob | Buffer>;
-    translate(file: MultiPartFile, filename: string, source: string | null, target: string, options?: DocumentTranslateOptions): Promise<Blob | Buffer>;
-}
-export type GlossaryImportCallback = (glossaryImport: GlossaryImport) => void;
-export declare class Glossaries {
-    private readonly client;
-    private readonly pollingInterval;
-    constructor(client: LaraClient);
-    list(): Promise<Glossary[]>;
-    create(name: string): Promise<Glossary>;
-    get(id: string): Promise<Glossary | null>;
-    delete(id: string): Promise<Glossary>;
-    update(id: string, name: string): Promise<Glossary>;
-    importCsv(id: string, csv: MultiPartFile, gzip?: boolean): Promise<GlossaryImport>;
-    getImportStatus(id: string): Promise<GlossaryImport>;
-    waitForImport(gImport: GlossaryImport, updateCallback?: GlossaryImportCallback, maxWaitTime?: number): Promise<GlossaryImport>;
-    counts(id: string): Promise<GlossaryCounts>;
-    export(id: string, contentType: "csv/table-uni", source?: string): Promise<string>;
-}
-export declare class Translator {
-    protected readonly client: LaraClient;
-    readonly memories: Memories;
-    readonly documents: Documents;
-    readonly glossaries: Glossaries;
-    constructor(credentials: Credentials, options?: TranslatorOptions);
-    getLanguages(): Promise<string[]>;
-    translate<T extends string | string[] | TextBlock[]>(text: T, source: string | null, target: string, options?: TranslateOptions): Promise<TextResult<T>>;
-    detect(text: string | string[], hint?: string, passlist?: string[]): Promise<DetectResult>;
-}