@alaikis/translation-sdk 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@alaikis/translation-sdk",
-	"version": "1.2.1",
+	"version": "1.2.2",
 	"description": "Laker Translation Service SDK for TypeScript/JavaScript",
 	"main": "translation-client.js",
 	"types": "translation-client.d.ts",
@@ -24,5 +24,11 @@
 	"bugs": {
 		"url": "https://github.com/alaikis/laker-translate-sdk/issues"
 	},
-	"homepage": "https://github.com/alaikis/laker-translate-sdk#readme"
-}
+	"homepage": "https://github.com/alaikis/laker-translate-sdk#readme",
+	"devDependencies": {
+		"@rollup/plugin-typescript": "^12.3.0",
+		"rollup": "^4.60.0",
+		"tslib": "^2.8.1",
+		"typescript": "^6.0.2"
+	}
+}

package/rollup.config.js

@@ -0,0 +1,19 @@
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'translation-client.ts',
+  output: [
+    {
+      file: 'translation-client.js',
+      format: 'umd',
+      name: 'LakerTranslation',
+      sourcemap: false
+    }
+  ],
+  plugins: [typescript({
+    target: 'es2015',
+    declaration: true,
+    declarationDir: './',
+    strict: false
+  })]
+};

package/translation-client.d.ts

@@ -1,357 +1,355 @@
-declare module "translation-client" {
+/**
+ * Translation Service gRPC-Web TypeScript/JavaScript Client
+ *
+ * Auto-generated for api.laker.dev Translation Service
+ * Service: TranslationService
+ * Source: proto/translation.proto
+ */
+export interface TranslateRecord {
+    id: string;
+    text: string;
+    translate: string;
+    isCustom: boolean;
+}
+export interface GetSenseTranslateRequest {
+    senseId: string;
+    fingerprint?: string;
+    page?: number;
+    pageSize?: number;
+    src_lang?: string;
+    dst_lang?: string;
+}
+export interface GetSenseTranslateResponse {
+    senseId: string;
+    total: number;
+    page: number;
+    pageSize: number;
+    result: TranslateRecord[];
+}
+export interface TranslateStreamRequest {
+    senseId: string;
+    fingerprint?: string;
+    batchSize?: number;
+}
+export interface TranslateStreamResponse {
+    batch: number;
+    hasMore: boolean;
+    total: number;
+    translations: TranslateRecord[];
+}
+/**
+ * Result of template extraction
+ */
+export interface TemplateExtractResult {
+    isTemplated: boolean;
+    srcTemplate: string;
+    dstTemplate: string;
+    variables: string[];
+}
+export interface LLMTranslateRequest {
+    text: string;
+    fromLang?: string;
+    toLang: string;
+    provider?: string;
+    senseId?: string;
+    fingerprint?: string;
+}
+export interface LLMTranslateResponse {
+    originalText: string;
+    translatedText: string;
+    provider: string;
+    timestamp: number;
+    finished: boolean;
+    cached: boolean;
+    fromLang?: string;
+    toLang?: string;
+}
+/**
+ * Result of translation lookup in TranslationPool
+ */
+export interface TranslationLookupResult {
+    found: boolean;
+    translation: string;
+    source: 'special' | 'common' | null;
+}
+/**
+ * Cross-tab cache synchronization options
+ */
+export interface CrossTabOptions {
+    enabled: boolean;
+    channelName?: string;
+    storageKeyPrefix?: string;
+}
+/**
+ * Automatic template extraction from text containing numeric variables
+ * @param text Original text that may contain numeric variables
+ * @returns Template extraction result
+ */
+export declare function extractTemplate(text: string): TemplateExtractResult;
+/**
+ * Translation options
+ */
+export interface TranslationServiceOptions {
+    senseId: string;
+    fingerprint?: string;
+    fromLang?: string;
+    toLang?: string;
+    crossTab?: boolean;
+    crossTabChannelName?: string;
+    crossTabStorageKeyPrefix?: string;
+}
+/**
+ * Cross-tab cache synchronization options for TranslationClient
+ */
+export interface ClientCrossTabOptions {
+    enabled: boolean;
+    channelName?: string;
+    storageKey?: string;
+}
+export interface TranslationClientConfig {
+    /** JWT authentication token */
+    token: string;
+    /** Translation sense ID */
+    senseId: string;
+    /** API base URL (optional, defaults to https://api.hottol.com/laker/) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (optional, defaults to 30000) */
+    timeout?: number;
+    /** LRU cache size (optional, defaults to 1000, set to 0 to disable cache) */
+    cacheSize?: number;
+    /** Initial fingerprint for personalized translations (optional) */
+    fingerprint?: string;
+    /** Enable cross-tab cache synchronization (optional, default: false) */
+    crossTab?: boolean;
+    /** Custom cross-tab channel name (optional) */
+    crossTabChannelName?: string;
+    /** Custom cross-tab storage key prefix (optional) */
+    crossTabStorageKeyPrefix?: string;
+    /** Enable cache (optional, default: true, set false to disable all caching) */
+    useCache?: boolean;
+}
+/**
+ * TranslationClient - Main entry point for Laker Translation SDK
+ *
+ * Features:
+ * - Automatic cache lookup: preloaded translations → LRU cache → backend request
+ * - Fingerprint-based personalized translations support
+ * - Optional cross-browser-tab cache synchronization
+ * - Lazy initialization: automatically preloads on first use
+ * - Simple single-level API, no complex layering
+ */
+export declare class TranslationClient {
+    private baseUrl;
+    private token;
+    private timeout;
+    private config;
+    private llmCacheEnabled;
+    private llmCache;
+    private pool;
+    private currentFingerprint;
+    private initialized;
+    private initPromise;
+    private broadcastChannel;
+    private crossTabOptions;
+    private storageKey;
+    /**
+     * Create a new TranslationClient - the only entry point you need
+     * @param config Client configuration
+     */
+    constructor(config: TranslationClientConfig);
+    /**
+     * Initialize cross-tab synchronization via Broadcast Channel
+     */
+    private initCrossTabSync;
+    /**
+     * Load cache from localStorage
+     */
+    private loadFromStorage;
+    /**
+     * Save cache to localStorage
+     */
+    private saveToStorage;
+    /**
+     * Get all cache entries for storage/broadcast
+     */
+    private getAllCacheEntries;
+    /**
+     * Broadcast full cache to other tabs
+     */
+    private broadcastFullCache;
+    /**
+     * Broadcast a single cache update to other tabs
+     */
+    private broadcastCacheUpdate;
+    /**
+     * Set or update the JWT authentication token
+     * @param token JWT token
+     */
+    setToken(token: string): void;
+    /**
+     * Enable or disable LLM cache
+     * @param enabled Whether to enable cache
+     */
+    setCacheEnabled(enabled: boolean): void;
+    /**
+     * Clear the LLM translation cache (also clears localStorage and broadcasts to other tabs)
+     */
+    clearCache(): void;
+    /**
+     * Get current LLM cache size
+     */
+    getCacheSize(): number;
+    /**
+     * Check if cross-tab synchronization is enabled
+     */
+    isCrossTabEnabled(): boolean;
+    /**
+  凤   * GetSenseTranslate - One-shot unary request with pagination
+     * @param request Request parameters
+     */
+    getSenseTranslate(request: GetSenseTranslateRequest): Promise<GetSenseTranslateResponse>;
     /**
-     * Translation Service gRPC-Web TypeScript/JavaScript Client
+     * TranslateStream - Server streaming, receives multiple batches progressively
+     * @param request Request parameters
+     * @param onBatch Callback for each batch received. Return false to stop streaming early.
+     */
+    translateStream(request: TranslateStreamRequest, onBatch: (response: TranslateStreamResponse) => boolean | void): Promise<void>;
+    /**
+     * Collect all streaming responses into an array
+     * @param request Request parameters
+     */
+    translateStreamCollect(request: TranslateStreamRequest): Promise<TranslateStreamResponse[]>;
+    /**
+     * LLMTranslate - One-shot large language model translation
+     * Uses LRU cache to avoid repeated requests for the same text
+     * With cross-tab enabled, automatically syncs cache across browser tabs
+     * @param request Translation request
+     * @param skipCache If true, bypass cache and always request from backend
+     */
+    llmTranslate(request: LLMTranslateRequest, skipCache?: boolean): Promise<LLMTranslateResponse>;
+    /**
+     * Translate text - this is the main method you need
      *
-     * Auto-generated for api.laker.dev Translation Service
-     * Service: TranslationService
-     * Source: proto/translation.proto
-     */
-    export interface TranslateRecord {
-        id: string;
-        text: string;
-        translate: string;
-        isCustom: boolean;
-    }
-    export interface GetSenseTranslateRequest {
-        senseId: string;
-        fingerprint?: string;
-        page?: number;
-        pageSize?: number;
-        src_lang?: string;
-        dst_lang?: string;
-    }
-    export interface GetSenseTranslateResponse {
-        senseId: string;
-        total: number;
-        page: number;
-        pageSize: number;
-        result: TranslateRecord[];
-    }
-    export interface TranslateStreamRequest {
-        senseId: string;
-        fingerprint?: string;
-        batchSize?: number;
-    }
-    export interface TranslateStreamResponse {
-        batch: number;
-        hasMore: boolean;
-        total: number;
-        translations: TranslateRecord[];
-    }
-    /**
-     * Result of template extraction
-     */
-    export interface TemplateExtractResult {
-        isTemplated: boolean;
-        srcTemplate: string;
-        dstTemplate: string;
-        variables: string[];
-    }
-    export interface LLMTranslateRequest {
-        text: string;
-        fromLang?: string;
-        toLang: string;
-        provider?: string;
-        senseId?: string;
-        fingerprint?: string;
-    }
-    export interface LLMTranslateResponse {
-        originalText: string;
-        translatedText: string;
-        provider: string;
-        timestamp: number;
-        finished: boolean;
-        cached: boolean;
-        fromLang?: string;
-        toLang?: string;
-    }
-    /**
-     * Result of translation lookup in TranslationPool
-     */
-    export interface TranslationLookupResult {
-        found: boolean;
-        translation: string;
-        source: 'special' | 'common' | null;
-    }
-    /**
-     * Cross-tab cache synchronization options
-     */
-    export interface CrossTabOptions {
-        enabled: boolean;
-        channelName?: string;
-        storageKeyPrefix?: string;
-    }
-    /**
-     * Automatic template extraction from text containing numeric variables
-     * @param text Original text that may contain numeric variables
-     * @returns Template extraction result
-     */
-    export function extractTemplate(text: string): TemplateExtractResult;
-    /**
-     * Translation options
-     */
-    export interface TranslationServiceOptions {
-        senseId: string;
-        fingerprint?: string;
-        fromLang?: string;
-        toLang?: string;
-        crossTab?: boolean;
-        crossTabChannelName?: string;
-        crossTabStorageKeyPrefix?: string;
-    }
-    /**
-     * Cross-tab cache synchronization options for TranslationClient
-     */
-    export interface ClientCrossTabOptions {
-        enabled: boolean;
-        channelName?: string;
-        storageKey?: string;
-    }
-    export interface TranslationClientConfig {
-        /** JWT authentication token */
-        token: string;
-        /** Translation sense ID */
-        senseId: string;
-        /** API base URL (optional, defaults to https://api.hottol.com/laker/) */
-        baseUrl?: string;
-        /** Request timeout in milliseconds (optional, defaults to 30000) */
-        timeout?: number;
-        /** LRU cache size (optional, defaults to 1000, set to 0 to disable cache) */
-        cacheSize?: number;
-        /** Initial fingerprint for personalized translations (optional) */
-        fingerprint?: string;
-        /** Enable cross-tab cache synchronization (optional, default: false) */
-        crossTab?: boolean;
-        /** Custom cross-tab channel name (optional) */
-        crossTabChannelName?: string;
-        /** Custom cross-tab storage key prefix (optional) */
-        crossTabStorageKeyPrefix?: string;
-        /** Enable cache (optional, default: true, set false to disable all caching) */
-        useCache?: boolean;
-    }
-    /**
-     * TranslationClient - Main entry point for Laker Translation SDK
+     * Workflow:
+     * 1. Check pre-loaded translation pool (provided fingerprint → current fingerprint → common)
+     * 2. If found, return immediately from cache
+     * 3. If not found, request LLM translation from backend
+     * 4. Auto-initialize on first call
      *
-     * Features:
-     * - Automatic cache lookup: preloaded translations → LRU cache → backend request
-     * - Fingerprint-based personalized translations support
-     * - Optional cross-browser-tab cache synchronization
-     * - Lazy initialization: automatically preloads on first use
-     * - Simple single-level API, no complex layering
-     */
-    export class TranslationClient {
-        private baseUrl;
-        private token;
-        private timeout;
-        private config;
-        private llmCacheEnabled;
-        private llmCache;
-        private pool;
-        private currentFingerprint;
-        private initialized;
-        private initPromise;
-        private broadcastChannel;
-        private crossTabOptions;
-        private storageKey;
-        /**
-         * Create a new TranslationClient - the only entry point you need
-         * @param config Client configuration
-         */
-        constructor(config: TranslationClientConfig);
-        /**
-         * Initialize cross-tab synchronization via Broadcast Channel
-         */
-        private initCrossTabSync;
-        /**
-         * Load cache from localStorage
-         */
-        private loadFromStorage;
-        /**
-         * Save cache to localStorage
-         */
-        private saveToStorage;
-        /**
-         * Get all cache entries for storage/broadcast
-         */
-        private getAllCacheEntries;
-        /**
-         * Broadcast full cache to other tabs
-         */
-        private broadcastFullCache;
-        /**
-         * Broadcast a single cache update to other tabs
-         */
-        private broadcastCacheUpdate;
-        /**
-         * Set or update the JWT authentication token
-         * @param token JWT token
-         */
-        setToken(token: string): void;
-        /**
-         * Enable or disable LLM cache
-         * @param enabled Whether to enable cache
-         */
-        setCacheEnabled(enabled: boolean): void;
-        /**
-         * Clear the LLM translation cache (also clears localStorage and broadcasts to other tabs)
-         */
-        clearCache(): void;
-        /**
-         * Get current LLM cache size
-         */
-        getCacheSize(): number;
-        /**
-         * Check if cross-tab synchronization is enabled
-         */
-        isCrossTabEnabled(): boolean;
-        /**
-      凤   * GetSenseTranslate - One-shot unary request with pagination
-         * @param request Request parameters
-         */
-        getSenseTranslate(request: GetSenseTranslateRequest): Promise<GetSenseTranslateResponse>;
-        /**
-         * TranslateStream - Server streaming, receives multiple batches progressively
-         * @param request Request parameters
-         * @param onBatch Callback for each batch received. Return false to stop streaming early.
-         */
-        translateStream(request: TranslateStreamRequest, onBatch: (response: TranslateStreamResponse) => boolean | void): Promise<void>;
-        /**
-         * Collect all streaming responses into an array
-         * @param request Request parameters
-         */
-        translateStreamCollect(request: TranslateStreamRequest): Promise<TranslateStreamResponse[]>;
-        /**
-         * LLMTranslate - One-shot large language model translation
-         * Uses LRU cache to avoid repeated requests for the same text
-         * With cross-tab enabled, automatically syncs cache across browser tabs
-         * @param request Translation request
-         * @param skipCache If true, bypass cache and always request from backend
-         */
-        llmTranslate(request: LLMTranslateRequest, skipCache?: boolean): Promise<LLMTranslateResponse>;
-        /**
-         * Translate text - this is the main method you need
-         *
-         * Workflow:
-         * 1. Check pre-loaded translation pool (provided fingerprint → current fingerprint → common)
-         * 2. If found, return immediately from cache
-         * 3. If not found, request LLM translation from backend
-         * 4. Auto-initialize on first call
-         *
-         * @param text Text to translate
-         * @param toLang Target language
-         * @param fromLang Source language (optional, auto-detected if not provided)
-         * @param fingerprint Optional specific fingerprint for this translation (overrides client-level fingerprint)
-         * @returns Translated text
-         */
-        translate(text: string, toLang: string, fromLang?: string, fingerprint?: string): Promise<string>;
-        /**
-         * Translate text with full response details
-         * @param text Text to translate
-         * @param toLang Target language
-         * @param fromLang Source language (optional)
-         * @param fingerprint Optional specific fingerprint for this translation (overrides client-level fingerprint)
-         * @returns Full translation response
-         */
-        translateWithDetails(text: string, toLang: string, fromLang?: string, fingerprint?: string): Promise<LLMTranslateResponse>;
-        /**
-         * Translate without using cache (always request from backend)
-         * @param text Text to translate
-         * @param toLang Target language
-         * @param fromLang Source language (optional)
-         * @param fingerprint Optional specific fingerprint for this translation
-         * @returns Translated text
-         */
-        translateNoCache(text: string, toLang: string, fromLang?: string, fingerprint?: string): Promise<string>;
-        /**
-         * Batch translate multiple texts
-         * @param texts Array of texts to translate
-         * @param toLang Target language
-         * @param fromLang Source language (optional)
-         * @param fingerprint Optional specific fingerprint for all translations in this batch
-         * @returns Array of translated texts in same order
-         */
-        translateBatch(texts: string[], toLang: string, fromLang?: string, fingerprint?: string): Promise<string[]>;
-        /**
-         * Initialize and preload all translations
-         * Call this to warm up cache before translating
-         */
-        preload(): Promise<void>;
-        /**
-         * Internal initialization - preloads translations via streaming
-         */
-        private initialize;
-        /**
-         * Check if service is initialized
-         */
-        isInitialized(): boolean;
-        /**
-         * Set or change the current fingerprint
-         * Automatically loads special translations for this fingerprint
-         * @param fingerprint The fingerprint to use
-         */
-        setFingerprint(fingerprint: string): Promise<void>;
-        /**
-         * Clear the current fingerprint
-         * Falls back to common translations
-         */
-        clearFingerprint(): void;
-        /**
-         * Get the current fingerprint
-         */
-        getFingerprint(): string | null;
-        /**
-         * Check if cache is enabled
-         * @returns true if cache is enabled
-         */
-        isCacheEnabled(): boolean;
-        /**
-         * Check if a translation exists in pre-loaded pool
-         * @param text Text to check
-         * @param fingerprint Optional specific fingerprint to check
-         * @returns true if translation exists in cache
-         */
-        hasTranslation(text: string, fingerprint?: string): boolean;
-        /**
-         * Get translation from pre-loaded cache without requesting from backend
-         * @param text Text to look up
-         * @param fingerprint Optional specific fingerprint to look up
-         * @returns Translation if found, null otherwise
-         */
-        getCached(text: string, fingerprint?: string): string | null;
-        /**
-         * Add a custom translation to the pre-loaded pool
-         * @param text Original text
-         * @param translation Translated text
-         * @param fingerprint Optional specific fingerprint to add to
-         */
-        addTranslation(text: string, translation: string, fingerprint?: string): void;
-        /**
-         * Clear all cached translations
-         */
-        clearAllCache(): void;
-        /**
-         * Destroy the instance and free resources
-         * Call this when the instance is no longer needed
-         */
-        destroy(): void;
-        /**
-         * LLMTranslateStream - Streaming large language model translation
-         * Note: Streaming requests are not cached
-         * @param request Translation request
-         * @param onResponse Callback for each response chunk
-         */
-        llmTranslateStream(request: LLMTranslateRequest, onResponse: (response: LLMTranslateResponse) => boolean | void): Promise<void>;
-        private getHeaders;
-        private fetchJson;
-        private fetchWithTimeout;
-    }
-    /**
-     * Create a TranslationClient instance with simplified configuration
-     * @param token JWT authentication token
-     * @param senseId Translation sense ID
-     * @param options Additional options
-     * @returns TranslationClient instance
-     */
-    export function createTranslation(token: string, senseId: string, options?: Partial<TranslationClientConfig>): TranslationClient;
-    export default createTranslation;
+     * @param text Text to translate
+     * @param toLang Target language
+     * @param fromLang Source language (optional, auto-detected if not provided)
+     * @param fingerprint Optional specific fingerprint for this translation (overrides client-level fingerprint)
+     * @returns Translated text
+     */
+    translate(text: string, toLang: string, fromLang?: string, fingerprint?: string): Promise<string>;
+    /**
+     * Translate text with full response details
+     * @param text Text to translate
+     * @param toLang Target language
+     * @param fromLang Source language (optional)
+     * @param fingerprint Optional specific fingerprint for this translation (overrides client-level fingerprint)
+     * @returns Full translation response
+     */
+    translateWithDetails(text: string, toLang: string, fromLang?: string, fingerprint?: string): Promise<LLMTranslateResponse>;
+    /**
+     * Translate without using cache (always request from backend)
+     * @param text Text to translate
+     * @param toLang Target language
+     * @param fromLang Source language (optional)
+     * @param fingerprint Optional specific fingerprint for this translation
+     * @returns Translated text
+     */
+    translateNoCache(text: string, toLang: string, fromLang?: string, fingerprint?: string): Promise<string>;
+    /**
+     * Batch translate multiple texts
+     * @param texts Array of texts to translate
+     * @param toLang Target language
+     * @param fromLang Source language (optional)
+     * @param fingerprint Optional specific fingerprint for all translations in this batch
+     * @returns Array of translated texts in same order
+     */
+    translateBatch(texts: string[], toLang: string, fromLang?: string, fingerprint?: string): Promise<string[]>;
+    /**
+     * Initialize and preload all translations
+     * Call this to warm up cache before translating
+     */
+    preload(): Promise<void>;
+    /**
+     * Internal initialization - preloads translations via streaming
+     */
+    private initialize;
+    /**
+     * Check if service is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Set or change the current fingerprint
+     * Automatically loads special translations for this fingerprint
+     * @param fingerprint The fingerprint to use
+     */
+    setFingerprint(fingerprint: string): Promise<void>;
+    /**
+     * Clear the current fingerprint
+     * Falls back to common translations
+     */
+    clearFingerprint(): void;
+    /**
+     * Get the current fingerprint
+     */
+    getFingerprint(): string | null;
+    /**
+     * Check if cache is enabled
+     * @returns true if cache is enabled
+     */
+    isCacheEnabled(): boolean;
+    /**
+     * Check if a translation exists in pre-loaded pool
+     * @param text Text to check
+     * @param fingerprint Optional specific fingerprint to check
+     * @returns true if translation exists in cache
+     */
+    hasTranslation(text: string, fingerprint?: string): boolean;
+    /**
+     * Get translation from pre-loaded cache without requesting from backend
+     * @param text Text to look up
+     * @param fingerprint Optional specific fingerprint to look up
+     * @returns Translation if found, null otherwise
+     */
+    getCached(text: string, fingerprint?: string): string | null;
+    /**
+     * Add a custom translation to the pre-loaded pool
+     * @param text Original text
+     * @param translation Translated text
+     * @param fingerprint Optional specific fingerprint to add to
+     */
+    addTranslation(text: string, translation: string, fingerprint?: string): void;
+    /**
+     * Clear all cached translations
+     */
+    clearAllCache(): void;
+    /**
+     * Destroy the instance and free resources
+     * Call this when the instance is no longer needed
+     */
+    destroy(): void;
+    /**
+     * LLMTranslateStream - Streaming large language model translation
+     * Note: Streaming requests are not cached
+     * @param request Translation request
+     * @param onResponse Callback for each response chunk
+     */
+    llmTranslateStream(request: LLMTranslateRequest, onResponse: (response: LLMTranslateResponse) => boolean | void): Promise<void>;
+    private getHeaders;
+    private fetchJson;
+    private fetchWithTimeout;
 }
+/**
+ * Create a TranslationClient instance with simplified configuration
+ * @param token JWT authentication token
+ * @param senseId Translation sense ID
+ * @param options Additional options
+ * @returns TranslationClient instance
+ */
+export declare function createTranslation(token: string, senseId: string, options?: Partial<TranslationClientConfig>): TranslationClient;
+export default createTranslation;

package/translation-client.js

@@ -1,23 +1,48 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        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());
-    });
-};
-/**
- * Translation Service gRPC-Web TypeScript/JavaScript Client
- *
- * Auto-generated for api.laker.dev Translation Service
- * Service: TranslationService
- * Source: proto/translation.proto
- */
-define("translation-client", ["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.createTranslation = exports.TranslationClient = exports.extractTemplate = void 0;
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LakerTranslation = {}));
+})(this, (function (exports) { 'use strict';
+
+    /******************************************************************************
+    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, Iterator */
+
+
+    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;
+    };
+
+    /**
+     * Translation Service gRPC-Web TypeScript/JavaScript Client
+     *
+     * Auto-generated for api.laker.dev Translation Service
+     * Service: TranslationService
+     * Source: proto/translation.proto
+     */
     const defaultCrossTabOptions = {
         enabled: false,
         channelName: 'laker-translation-cache',
@@ -54,7 +79,6 @@ define("translation-client", ["require", "exports"], function (require, exports)
             variables
         };
     }
-    exports.extractTemplate = extractTemplate;
     /**
      * TranslationPool - Multi-fingerprint translation cache with automatic common preloading
      *
@@ -240,12 +264,9 @@ define("translation-client", ["require", "exports"], function (require, exports)
          */
         handleCacheClear(message) {
             const fp = message.fingerprint || 'common';
-            if (fp) {
+            {
                 this.clearFingerprint(fp);
             }
-            else {
-                this.clearAll();
-            }
         }
         /**
          * Handle initial sync request from a new tab
@@ -550,7 +571,7 @@ define("translation-client", ["require", "exports"], function (require, exports)
     * Usage:
     * - Simple: Just create and call translate() - initialization is automatic
     * - Advanced: Call initialize() explicitly to preload all translations upfront
-   */
+    */
     /**
      * Simple LRU Cache implementation for TranslationClient
      * Uses Map with access order for O(1) get/set operations
@@ -1226,7 +1247,6 @@ define("translation-client", ["require", "exports"], function (require, exports)
             });
         }
     }
-    exports.TranslationClient = TranslationClient;
     /**
      * Create a TranslationClient instance with simplified configuration
      * @param token JWT authentication token
@@ -1238,8 +1258,6 @@ define("translation-client", ["require", "exports"], function (require, exports)
         return new TranslationClient(Object.assign({ token,
             senseId }, options));
     }
-    exports.createTranslation = createTranslation;
-    exports.default = createTranslation;
     // Auto-export to global for browser usage
     if (typeof window !== 'undefined') {
         window.LakerTranslation = {
@@ -1248,4 +1266,12 @@ define("translation-client", ["require", "exports"], function (require, exports)
             default: createTranslation
         };
     }
-});
+
+    exports.TranslationClient = TranslationClient;
+    exports.createTranslation = createTranslation;
+    exports.default = createTranslation;
+    exports.extractTemplate = extractTemplate;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));