@ollang-dev/sdk 0.3.1

package/dist/resources/revisions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Revisions = void 0;
+class Revisions {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(orderId, params) {
+        return this.client.post(`/integration/revision/${orderId}`, params);
+    }
+    async delete(orderId, revisionId) {
+        return this.client.delete(`/integration/revision/${orderId}/${revisionId}`);
+    }
+    async list(orderId) {
+        return this.client.get(`/integration/revision/${orderId}`);
+    }
+}
+exports.Revisions = Revisions;

package/dist/resources/scans.d.ts

@@ -0,0 +1,38 @@
+import { OllangClient } from '../client';
+export interface ScanSessionResponse {
+    id: string;
+    projectId: string;
+    userId: string;
+    isActive: boolean;
+    scannedDocs?: ScannedDocResponse[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ScannedDocResponse {
+    id: string;
+    sessionId: string;
+    docId: string;
+    originalUrl: string;
+    processedUrl?: string;
+    scanData: any;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateScanInput {
+    file?: Buffer | Blob;
+    url?: string;
+    scanData: any;
+    originalFilename?: string;
+    folderName?: string;
+}
+export declare class Scans {
+    private client;
+    constructor(client: OllangClient);
+    getOrCreateSession(projectId?: string, folderName?: string): Promise<ScanSessionResponse>;
+    createScan(input: CreateScanInput): Promise<ScannedDocResponse>;
+    listScans(): Promise<ScannedDocResponse[]>;
+    getScan(scanId: string): Promise<ScannedDocResponse>;
+    deleteScan(scanId: string): Promise<void>;
+    updateScan(scanId: string, input: Partial<CreateScanInput>): Promise<ScannedDocResponse>;
+}

package/dist/resources/scans.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scans = void 0;
+class Scans {
+    constructor(client) {
+        this.client = client;
+    }
+    async getOrCreateSession(projectId, folderName) {
+        return this.client.post('/scans/session', { projectId, folderName });
+    }
+    async createScan(input) {
+        const formData = new FormData();
+        if (input.file) {
+            if (Buffer.isBuffer(input.file)) {
+                const blob = new Blob([input.file]);
+                formData.append('file', blob, input.originalFilename || 'scan.jpg');
+            }
+            else {
+                formData.append('file', input.file, input.originalFilename || 'scan.jpg');
+            }
+        }
+        if (input.url) {
+            formData.append('url', input.url);
+        }
+        formData.append('scanData', JSON.stringify(input.scanData));
+        if (input.originalFilename) {
+            formData.append('originalFilename', input.originalFilename);
+        }
+        if (input.folderName) {
+            formData.append('folderName', input.folderName);
+        }
+        return this.client.postFormData('/scans', formData);
+    }
+    async listScans() {
+        return this.client.get('/scans');
+    }
+    async getScan(scanId) {
+        return this.client.get(`/scans/${scanId}`);
+    }
+    async deleteScan(scanId) {
+        return this.client.delete(`/scans/${scanId}`);
+    }
+    async updateScan(scanId, input) {
+        return this.client.patch(`/scans/${scanId}`, {
+            scanData: input.scanData,
+            url: input.url,
+            originalFilename: input.originalFilename,
+            folderName: input.folderName,
+        });
+    }
+}
+exports.Scans = Scans;

package/dist/resources/uploads.d.ts

@@ -0,0 +1,8 @@
+import { OllangClient } from '../client';
+import { DirectUploadParams, DirectUploadResponse, UploadVttParams, UploadVttResponse } from '../types';
+export declare class Uploads {
+    private client;
+    constructor(client: OllangClient);
+    direct(params: DirectUploadParams): Promise<DirectUploadResponse>;
+    vtt(params: UploadVttParams): Promise<UploadVttResponse>;
+}

package/dist/resources/uploads.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uploads = void 0;
+class Uploads {
+    constructor(client) {
+        this.client = client;
+    }
+    async direct(params) {
+        const formData = new FormData();
+        formData.append('file', params.file);
+        formData.append('name', params.name);
+        formData.append('sourceLanguage', params.sourceLanguage);
+        if (params.notes) {
+            formData.append('notes', JSON.stringify(params.notes));
+        }
+        return this.client.uploadFile('/integration/upload/direct', formData);
+    }
+    async vtt(params) {
+        const formData = new FormData();
+        formData.append('file', params.file);
+        formData.append('orderId', params.orderId);
+        return this.client.uploadFile('/integration/upload/vtt', formData);
+    }
+}
+exports.Uploads = Uploads;

package/dist/tms/config.d.ts

@@ -0,0 +1,16 @@
+import { TMSConfig, ControlPanelConfig } from './types.js';
+export declare const DEFAULT_PANEL_CONFIG: ControlPanelConfig;
+export declare const DEFAULT_TMS_CONFIG: Partial<TMSConfig>;
+export declare class ConfigManager {
+    private config;
+    load(customConfig?: Partial<TMSConfig>, projectRoot?: string): TMSConfig;
+    private loadConfigFile;
+    private loadFromEnv;
+    get(): TMSConfig;
+    update(updates: Partial<TMSConfig>): TMSConfig;
+    private validate;
+    toJSON(): string;
+    fromJSON(json: string): TMSConfig;
+}
+export declare const configManager: ConfigManager;
+export declare function createConfig(customConfig?: Partial<TMSConfig>): TMSConfig;

package/dist/tms/config.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = exports.DEFAULT_TMS_CONFIG = exports.DEFAULT_PANEL_CONFIG = void 0;
+exports.createConfig = createConfig;
+exports.DEFAULT_PANEL_CONFIG = {
+    position: 'bottom-right',
+    theme: 'auto',
+    hotkey: 'Ctrl+Shift+T',
+    width: 400,
+    height: 600,
+    minimized: false,
+    zIndex: 10000,
+};
+exports.DEFAULT_TMS_CONFIG = {
+    version: '1.0.0',
+    sourceLanguage: 'en',
+    targetLanguages: ['tr'],
+    detection: {
+        includePaths: ['src', 'pages', 'components', 'app'],
+        excludePaths: ['node_modules', '.git', 'dist', 'build', '.next', 'out'],
+        includePatterns: ['**/*.{ts,tsx,js,jsx,vue}', '**/locales/**/*.{json,yaml,yml}'],
+        detectI18n: true,
+        detectHardcoded: true,
+        detectCMS: false,
+    },
+    i18n: {
+        framework: 'none',
+        translationDir: 'public/locales',
+        defaultNamespace: 'common',
+        keyStyle: 'nested',
+    },
+    ollang: {
+        apiKey: '',
+        baseUrl: 'http://localhost:8080', // TODO: Change to 'https://api-integration.ollang.com' before npm publish
+        defaultLevel: 0,
+    },
+    ui: exports.DEFAULT_PANEL_CONFIG,
+};
+class ConfigManager {
+    constructor() {
+        this.config = null;
+    }
+    load(customConfig = {}, projectRoot = process.cwd()) {
+        const configFile = this.loadConfigFile(projectRoot);
+        const envConfig = this.loadFromEnv();
+        this.config = {
+            ...exports.DEFAULT_TMS_CONFIG,
+            ...configFile,
+            ...envConfig,
+            ...customConfig,
+            projectRoot,
+            detection: {
+                ...exports.DEFAULT_TMS_CONFIG.detection,
+                ...configFile?.detection,
+                ...envConfig?.detection,
+                ...customConfig.detection,
+            },
+            i18n: {
+                ...exports.DEFAULT_TMS_CONFIG.i18n,
+                ...configFile?.i18n,
+                ...envConfig?.i18n,
+                ...customConfig.i18n,
+            },
+            ollang: {
+                ...exports.DEFAULT_TMS_CONFIG.ollang,
+                ...configFile?.ollang,
+                ...envConfig?.ollang,
+                ...customConfig.ollang,
+            },
+            ui: {
+                ...exports.DEFAULT_TMS_CONFIG.ui,
+                ...configFile?.ui,
+                ...envConfig?.ui,
+                ...customConfig.ui,
+            },
+        };
+        this.validate(this.config);
+        return this.config;
+    }
+    loadConfigFile(projectRoot) {
+        const fs = require('fs');
+        const path = require('path');
+        const configPaths = [
+            path.join(projectRoot, '.tmsrc.json'),
+            path.join(projectRoot, 'tms.config.json'),
+            path.join(projectRoot, '.tmsrc'),
+        ];
+        for (const configPath of configPaths) {
+            try {
+                if (fs.existsSync(configPath)) {
+                    const content = fs.readFileSync(configPath, 'utf-8');
+                    const config = JSON.parse(content);
+                    console.log(`✅ Loaded config from: ${path.basename(configPath)}`);
+                    return config;
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to load config from ${configPath}:`, error);
+            }
+        }
+        return null;
+    }
+    loadFromEnv() {
+        const config = {};
+        if (process.env.OLLANG_API_KEY || process.env.OLLANG_BASE_URL) {
+            const ollangConfig = {};
+            if (process.env.OLLANG_API_KEY) {
+                ollangConfig.apiKey = process.env.OLLANG_API_KEY;
+            }
+            if (process.env.OLLANG_BASE_URL) {
+                ollangConfig.baseUrl = process.env.OLLANG_BASE_URL;
+            }
+            config.ollang = ollangConfig;
+        }
+        if (process.env.TMS_SOURCE_LANGUAGE) {
+            config.sourceLanguage = process.env.TMS_SOURCE_LANGUAGE;
+        }
+        if (process.env.TMS_TARGET_LANGUAGES) {
+            config.targetLanguages = process.env.TMS_TARGET_LANGUAGES.split(',').map((l) => l.trim());
+        }
+        return config;
+    }
+    get() {
+        if (!this.config) {
+            throw new Error('Configuration not loaded. Call load() first.');
+        }
+        return this.config;
+    }
+    update(updates) {
+        if (!this.config) {
+            throw new Error('Configuration not loaded. Call load() first.');
+        }
+        this.config = {
+            ...this.config,
+            ...updates,
+        };
+        this.validate(this.config);
+        return this.config;
+    }
+    validate(config) {
+        if (!config.projectRoot) {
+            throw new Error('Project root is required');
+        }
+        if (!config.sourceLanguage) {
+            throw new Error('Source language is required');
+        }
+        if (!config.targetLanguages || config.targetLanguages.length === 0) {
+            throw new Error('At least one target language is required');
+        }
+        if (!config.detection.includePaths || config.detection.includePaths.length === 0) {
+            throw new Error('At least one include path is required for detection');
+        }
+        if (!config.ollang.apiKey) {
+            console.warn('⚠️  OLLANG_API_KEY not set. Translation features will not work.');
+        }
+    }
+    toJSON() {
+        if (!this.config) {
+            throw new Error('Configuration not loaded');
+        }
+        return JSON.stringify(this.config, null, 2);
+    }
+    fromJSON(json) {
+        const parsed = JSON.parse(json);
+        return this.load(parsed, parsed.projectRoot);
+    }
+}
+exports.ConfigManager = ConfigManager;
+exports.configManager = new ConfigManager();
+function createConfig(customConfig = {}) {
+    return exports.configManager.load(customConfig);
+}

package/dist/tms/detector/audio-detector.d.ts

@@ -0,0 +1,27 @@
+import { ContentDetector, DetectionConfig } from './content-type-detector.js';
+export interface AudioContent {
+    id: string;
+    type: 'audio';
+    path: string;
+    filename?: string;
+    url?: string;
+    line?: number;
+    column?: number;
+    metadata: {
+        duration: number;
+        format: string;
+        size?: number;
+        isUrl?: boolean;
+        sourceFile?: string;
+    };
+}
+export declare class AudioDetector implements ContentDetector<AudioContent> {
+    supports(filePath: string): boolean;
+    detect(projectRoot: string, config: DetectionConfig): Promise<AudioContent[]>;
+    private scanDirectory;
+    private analyzeAudio;
+    private shouldExclude;
+    private scanForAudioUrls;
+    private extractAudioUrls;
+    private getFormatFromUrl;
+}

package/dist/tms/detector/audio-detector.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioDetector = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const AUDIO_EXTENSIONS = ['.mp3', '.wav', '.m4a', '.aac', '.ogg', '.flac', '.wma', '.opus'];
+const AUDIO_URL_PATTERNS = [
+    /https?:\/\/[^\s"']+\.mp3/gi,
+    /https?:\/\/[^\s"']+\.wav/gi,
+    /https?:\/\/[^\s"']+\.m4a/gi,
+    /https?:\/\/[^\s"']+\.aac/gi,
+    /https?:\/\/[^\s"']+\.ogg/gi,
+    /https?:\/\/[^\s"']+\.flac/gi,
+    /https?:\/\/[^\s"']*amazonaws\.com[^\s"']*\.(mp3|wav|m4a|aac|ogg|flac)/gi,
+    /https?:\/\/[^\s"']*cloudfront\.net[^\s"']*\.(mp3|wav|m4a|aac|ogg|flac)/gi,
+];
+class AudioDetector {
+    supports(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return AUDIO_EXTENSIONS.includes(ext);
+    }
+    async detect(projectRoot, config) {
+        const audios = [];
+        for (const includePath of config.includePaths) {
+            const fullPath = path.join(projectRoot, includePath);
+            const physicalAudios = await this.scanDirectory(fullPath, config.excludePaths);
+            audios.push(...physicalAudios);
+            const urlAudios = await this.scanForAudioUrls(fullPath, config.excludePaths);
+            audios.push(...urlAudios);
+        }
+        return audios;
+    }
+    async scanDirectory(dirPath, excludePaths) {
+        const audios = [];
+        const items = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.join(dirPath, item.name);
+            if (this.shouldExclude(fullPath, excludePaths)) {
+                continue;
+            }
+            if (item.isDirectory()) {
+                const subAudios = await this.scanDirectory(fullPath, excludePaths);
+                audios.push(...subAudios);
+            }
+            else if (item.isFile() && this.supports(item.name)) {
+                const audioContent = await this.analyzeAudio(fullPath);
+                audios.push(audioContent);
+            }
+        }
+        return audios;
+    }
+    async analyzeAudio(filePath) {
+        const stat = await fs.stat(filePath);
+        const filename = path.basename(filePath);
+        return {
+            id: `audio-${filePath}`,
+            type: 'audio',
+            path: filePath,
+            filename,
+            metadata: {
+                duration: 0,
+                format: path.extname(filePath).substring(1),
+                size: stat.size,
+            },
+        };
+    }
+    shouldExclude(filePath, excludePaths) {
+        return excludePaths.some((exclude) => filePath.includes(exclude));
+    }
+    async scanForAudioUrls(dirPath, excludePaths) {
+        const audios = [];
+        const codeExtensions = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.html'];
+        const items = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.join(dirPath, item.name);
+            if (this.shouldExclude(fullPath, excludePaths)) {
+                continue;
+            }
+            if (item.isDirectory()) {
+                const subAudios = await this.scanForAudioUrls(fullPath, excludePaths);
+                audios.push(...subAudios);
+            }
+            else if (item.isFile() && codeExtensions.includes(path.extname(item.name).toLowerCase())) {
+                const foundUrls = await this.extractAudioUrls(fullPath);
+                audios.push(...foundUrls);
+            }
+        }
+        return audios;
+    }
+    async extractAudioUrls(filePath) {
+        const audios = [];
+        const content = await fs.readFile(filePath, 'utf-8');
+        const foundUrls = new Set();
+        const lines = content.split('\n');
+        for (const pattern of AUDIO_URL_PATTERNS) {
+            const matches = content.matchAll(pattern);
+            for (const match of matches) {
+                foundUrls.add(match[0]);
+            }
+        }
+        for (const url of foundUrls) {
+            const format = this.getFormatFromUrl(url);
+            let lineNumber = 0;
+            let columnNumber = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const index = lines[i].indexOf(url);
+                if (index !== -1) {
+                    lineNumber = i + 1;
+                    columnNumber = index;
+                    break;
+                }
+            }
+            audios.push({
+                id: `audio-url-${url}`,
+                type: 'audio',
+                path: filePath,
+                url,
+                line: lineNumber,
+                column: columnNumber,
+                metadata: {
+                    duration: 0,
+                    format,
+                    isUrl: true,
+                    sourceFile: filePath,
+                },
+            });
+        }
+        return audios;
+    }
+    getFormatFromUrl(url) {
+        const match = url.match(/\.(mp3|wav|m4a|aac|ogg|flac)(\?|$)/i);
+        return match ? match[1].toLowerCase() : 'mp3';
+    }
+}
+exports.AudioDetector = AudioDetector;

package/dist/tms/detector/auto-detect.d.ts

@@ -0,0 +1 @@
+export declare function autoDetectI18nDirs(projectRoot: string): Promise<string[]>;

package/dist/tms/detector/auto-detect.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoDetectI18nDirs = autoDetectI18nDirs;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const I18N_PATTERNS = [
+    // Next.js
+    'public/locales',
+    'messages',
+    'locales',
+    // React
+    'src/locales',
+    'src/i18n',
+    'src/messages',
+    'locales',
+    'i18n',
+    // Angular
+    'src/assets/i18n',
+    'src/assets/locales',
+    'assets/i18n',
+    // Vue
+    'src/locales',
+    'locales',
+    // General
+    'translations',
+    'lang',
+    'languages',
+];
+async function autoDetectI18nDirs(projectRoot) {
+    const foundDirs = [];
+    for (const pattern of I18N_PATTERNS) {
+        const fullPath = path.join(projectRoot, pattern);
+        if (await dirExists(fullPath)) {
+            if (await hasI18nFiles(fullPath)) {
+                foundDirs.push(pattern);
+            }
+        }
+    }
+    if (foundDirs.length === 0) {
+        const shallowDirs = await shallowSearch(projectRoot);
+        foundDirs.push(...shallowDirs);
+    }
+    return foundDirs;
+}
+async function dirExists(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function hasI18nFiles(dirPath) {
+    try {
+        const items = await fs.readdir(dirPath, { withFileTypes: true });
+        const hasFiles = items.some((item) => item.isFile() &&
+            (item.name.endsWith('.json') || item.name.endsWith('.yaml') || item.name.endsWith('.yml')));
+        if (hasFiles)
+            return true;
+        const hasLangDirs = items.some((item) => {
+            if (!item.isDirectory())
+                return false;
+            const langCodes = ['en', 'tr', 'fr', 'es', 'de', 'it', 'pt', 'ja', 'ko', 'zh', 'ar', 'ru'];
+            return langCodes.includes(item.name.toLowerCase());
+        });
+        return hasLangDirs;
+    }
+    catch {
+        return false;
+    }
+}
+async function shallowSearch(dirPath, depth = 0, maxDepth = 3) {
+    if (depth >= maxDepth)
+        return [];
+    const foundDirs = [];
+    const items = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const item of items) {
+        if (shouldSkip(item.name))
+            continue;
+        if (item.isDirectory()) {
+            const fullPath = path.join(dirPath, item.name);
+            const relativePath = path.relative(process.cwd(), fullPath);
+            if (looksLikeI18nDir(item.name) && (await hasI18nFiles(fullPath))) {
+                foundDirs.push(relativePath);
+            }
+            const subDirs = await shallowSearch(fullPath, depth + 1, maxDepth);
+            foundDirs.push(...subDirs);
+        }
+    }
+    return foundDirs;
+}
+function looksLikeI18nDir(name) {
+    const lowerName = name.toLowerCase();
+    return (lowerName.includes('i18n') ||
+        lowerName.includes('locale') ||
+        lowerName.includes('translation') ||
+        lowerName.includes('lang') ||
+        lowerName.includes('message') ||
+        lowerName === 'translations' ||
+        lowerName === 'messages');
+}
+function shouldSkip(name) {
+    const skipDirs = [
+        'node_modules',
+        '.git',
+        '.next',
+        'dist',
+        'build',
+        'out',
+        '.angular',
+        'coverage',
+        '.vscode',
+        '.idea',
+        'tmp',
+        'temp',
+    ];
+    return skipDirs.includes(name) || name.startsWith('.');
+}