@ollang-dev/sdk 0.3.1

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

@@ -0,0 +1,11 @@
+import { ContentDetector, ImageContent, DetectionConfig } from './content-type-detector.js';
+export declare class ImageDetector implements ContentDetector<ImageContent> {
+    supports(filePath: string): boolean;
+    detect(projectRoot: string, config: DetectionConfig): Promise<ImageContent[]>;
+    private scanDirectory;
+    private analyzeImage;
+    private shouldExclude;
+    private scanForImageUrls;
+    private extractImageUrls;
+    private getFormatFromUrl;
+}

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

@@ -0,0 +1,170 @@
+"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.ImageDetector = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'];
+const IMAGE_URL_PATTERNS = [
+    /https?:\/\/[^\s"']+\.png/gi,
+    /https?:\/\/[^\s"']+\.jpg/gi,
+    /https?:\/\/[^\s"']+\.jpeg/gi,
+    /https?:\/\/[^\s"']+\.gif/gi,
+    /https?:\/\/[^\s"']+\.webp/gi,
+    /https?:\/\/[^\s"']*amazonaws\.com[^\s"']*\.(png|jpg|jpeg|gif|webp)/gi,
+    /https?:\/\/[^\s"']*cloudfront\.net[^\s"']*\.(png|jpg|jpeg|gif|webp)/gi,
+];
+class ImageDetector {
+    supports(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return IMAGE_EXTENSIONS.includes(ext);
+    }
+    async detect(projectRoot, config) {
+        const images = [];
+        for (const includePath of config.includePaths) {
+            const fullPath = path.join(projectRoot, includePath);
+            const physicalImages = await this.scanDirectory(fullPath, config.excludePaths);
+            images.push(...physicalImages);
+            const urlImages = await this.scanForImageUrls(fullPath, config.excludePaths);
+            images.push(...urlImages);
+        }
+        return images;
+    }
+    async scanDirectory(dirPath, excludePaths) {
+        const images = [];
+        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 subImages = await this.scanDirectory(fullPath, excludePaths);
+                images.push(...subImages);
+            }
+            else if (item.isFile() && this.supports(item.name)) {
+                const imageContent = await this.analyzeImage(fullPath);
+                images.push(imageContent);
+            }
+        }
+        return images;
+    }
+    async analyzeImage(filePath) {
+        const stat = await fs.stat(filePath);
+        const filename = path.basename(filePath);
+        return {
+            id: `image-${filePath}`,
+            type: 'image',
+            path: filePath,
+            filename,
+            metadata: {
+                hasText: true,
+                format: path.extname(filePath).substring(1),
+                size: stat.size,
+            },
+        };
+    }
+    shouldExclude(filePath, excludePaths) {
+        return excludePaths.some((exclude) => filePath.includes(exclude));
+    }
+    async scanForImageUrls(dirPath, excludePaths) {
+        const images = [];
+        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 subImages = await this.scanForImageUrls(fullPath, excludePaths);
+                images.push(...subImages);
+            }
+            else if (item.isFile()) {
+                const ext = path.extname(item.name).toLowerCase();
+                if (codeExtensions.includes(ext)) {
+                    const foundUrls = await this.extractImageUrls(fullPath);
+                    images.push(...foundUrls);
+                }
+            }
+        }
+        return images;
+    }
+    async extractImageUrls(filePath) {
+        const images = [];
+        const content = await fs.readFile(filePath, 'utf-8');
+        const foundUrls = new Set();
+        const lines = content.split('\n');
+        for (const pattern of IMAGE_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;
+                }
+            }
+            images.push({
+                id: `image-url-${url}`,
+                type: 'image',
+                path: filePath,
+                url,
+                line: lineNumber,
+                column: columnNumber,
+                metadata: {
+                    hasText: true,
+                    format,
+                    isUrl: true,
+                    sourceFile: filePath,
+                },
+            });
+        }
+        return images;
+    }
+    getFormatFromUrl(url) {
+        const match = url.match(/\.(png|jpg|jpeg|gif|webp)(\?|$)/i);
+        return match ? match[1].toLowerCase() : 'png';
+    }
+}
+exports.ImageDetector = ImageDetector;

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

@@ -0,0 +1,9 @@
+import { TextItem, ScanConfig, I18nSetupInfo } from '../types.js';
+export declare class TextDetector {
+    private i18nDetector;
+    private hardcodedDetector;
+    constructor();
+    scan(config: ScanConfig): Promise<TextItem[]>;
+    scanFiles(paths: string[]): Promise<TextItem[]>;
+    detectI18nSetup(projectRoot: string): Promise<I18nSetupInfo | null>;
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextDetector = void 0;
+const i18n_detector_js_1 = require("./i18n-detector.js");
+const hardcoded_detector_js_1 = require("./hardcoded-detector.js");
+class TextDetector {
+    constructor() {
+        this.i18nDetector = new i18n_detector_js_1.I18nDetector();
+        this.hardcodedDetector = new hardcoded_detector_js_1.HardcodedDetector();
+    }
+    async scan(config) {
+        const texts = [];
+        if (config.detectI18n) {
+            const i18nTexts = await this.i18nDetector.detect(config);
+            texts.push(...i18nTexts);
+        }
+        if (config.detectHardcoded) {
+            const hardcodedTexts = await this.hardcodedDetector.detect(config);
+            texts.push(...hardcodedTexts);
+        }
+        return texts;
+    }
+    async scanFiles(paths) {
+        const texts = [];
+        for (const path of paths) {
+            const fileTexts = await this.i18nDetector.detectFile(path);
+            texts.push(...fileTexts);
+        }
+        return texts;
+    }
+    async detectI18nSetup(projectRoot) {
+        return this.i18nDetector.detectSetup(projectRoot);
+    }
+}
+exports.TextDetector = TextDetector;

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

@@ -0,0 +1,12 @@
+import { ContentDetector, VideoContent, DetectionConfig } from './content-type-detector.js';
+export declare class VideoDetector implements ContentDetector<VideoContent> {
+    supports(filePath: string): boolean;
+    detect(projectRoot: string, config: DetectionConfig): Promise<VideoContent[]>;
+    private scanDirectory;
+    private analyzeVideo;
+    private findSubtitleFile;
+    private shouldExclude;
+    private scanForVideoUrls;
+    private extractVideoUrls;
+    private getFormatFromUrl;
+}

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

@@ -0,0 +1,188 @@
+"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.VideoDetector = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const VIDEO_EXTENSIONS = ['.mp4', '.mov', '.avi', '.mkv', '.webm', '.flv', '.wmv'];
+const SUBTITLE_EXTENSIONS = ['.srt', '.vtt', '.ass', '.ssa'];
+const VIDEO_URL_PATTERNS = [
+    /https?:\/\/[^\s"']+\.mp4/gi,
+    /https?:\/\/[^\s"']+\.mov/gi,
+    /https?:\/\/[^\s"']+\.webm/gi,
+    /https?:\/\/[^\s"']+\.avi/gi,
+    /https?:\/\/[^\s"']+\.mkv/gi,
+    /https?:\/\/[^\s"']*amazonaws\.com[^\s"']*\.(mp4|mov|webm|avi)/gi,
+    /https?:\/\/[^\s"']*cloudfront\.net[^\s"']*\.(mp4|mov|webm|avi)/gi,
+];
+class VideoDetector {
+    supports(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        return VIDEO_EXTENSIONS.includes(ext);
+    }
+    async detect(projectRoot, config) {
+        const videos = [];
+        for (const includePath of config.includePaths) {
+            const fullPath = path.join(projectRoot, includePath);
+            const physicalVideos = await this.scanDirectory(fullPath, config.excludePaths);
+            videos.push(...physicalVideos);
+            const urlVideos = await this.scanForVideoUrls(fullPath, config.excludePaths);
+            videos.push(...urlVideos);
+        }
+        return videos;
+    }
+    async scanDirectory(dirPath, excludePaths) {
+        const videos = [];
+        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 subVideos = await this.scanDirectory(fullPath, excludePaths);
+                videos.push(...subVideos);
+            }
+            else if (item.isFile() && this.supports(item.name)) {
+                const videoContent = await this.analyzeVideo(fullPath);
+                videos.push(videoContent);
+            }
+        }
+        return videos;
+    }
+    async analyzeVideo(filePath) {
+        const stat = await fs.stat(filePath);
+        const dir = path.dirname(filePath);
+        const basename = path.basename(filePath, path.extname(filePath));
+        const filename = path.basename(filePath);
+        const subtitlePath = await this.findSubtitleFile(dir, basename);
+        return {
+            id: `video-${filePath}`,
+            type: 'video',
+            path: filePath,
+            filename,
+            metadata: {
+                duration: 0,
+                format: path.extname(filePath).substring(1),
+                hasSubtitles: !!subtitlePath,
+                subtitlePath,
+                size: stat.size,
+            },
+        };
+    }
+    async findSubtitleFile(dir, basename) {
+        for (const ext of SUBTITLE_EXTENSIONS) {
+            const subtitlePath = path.join(dir, `${basename}${ext}`);
+            try {
+                await fs.access(subtitlePath);
+                return subtitlePath;
+            }
+            catch { }
+        }
+        return undefined;
+    }
+    shouldExclude(filePath, excludePaths) {
+        return excludePaths.some((exclude) => filePath.includes(exclude));
+    }
+    async scanForVideoUrls(dirPath, excludePaths) {
+        const videos = [];
+        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 subVideos = await this.scanForVideoUrls(fullPath, excludePaths);
+                videos.push(...subVideos);
+            }
+            else if (item.isFile()) {
+                const ext = path.extname(item.name).toLowerCase();
+                if (codeExtensions.includes(ext)) {
+                    const foundUrls = await this.extractVideoUrls(fullPath);
+                    videos.push(...foundUrls);
+                }
+            }
+        }
+        return videos;
+    }
+    async extractVideoUrls(filePath) {
+        const videos = [];
+        const content = await fs.readFile(filePath, 'utf-8');
+        const foundUrls = new Set();
+        const lines = content.split('\n');
+        for (const pattern of VIDEO_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;
+                }
+            }
+            videos.push({
+                id: `video-url-${url}`,
+                type: 'video',
+                path: filePath,
+                url,
+                line: lineNumber,
+                column: columnNumber,
+                metadata: {
+                    duration: 0,
+                    format,
+                    hasSubtitles: false,
+                    isUrl: true,
+                    sourceFile: filePath,
+                },
+            });
+        }
+        return videos;
+    }
+    getFormatFromUrl(url) {
+        const match = url.match(/\.(mp4|mov|webm|avi|mkv)(\?|$)/i);
+        return match ? match[1].toLowerCase() : 'mp4';
+    }
+}
+exports.VideoDetector = VideoDetector;

package/dist/tms/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Translation Management System - Public API
+ */
+export { TranslationManagementSystem } from './tms.js';
+export { MultiContentTMS } from './multi-content-tms.js';
+export { ConfigManager, createConfig, DEFAULT_TMS_CONFIG } from './config.js';
+export { TextDetector } from './detector/text-detector.js';
+export { VideoDetector } from './detector/video-detector.js';
+export { ImageDetector } from './detector/image-detector.js';
+export { CMSDetector } from './detector/cms-detector.js';
+export * from './types.js';
+export * from './detector/content-type-detector.js';

package/dist/tms/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Translation Management System - Public API
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMSDetector = exports.ImageDetector = exports.VideoDetector = exports.TextDetector = exports.DEFAULT_TMS_CONFIG = exports.createConfig = exports.ConfigManager = exports.MultiContentTMS = exports.TranslationManagementSystem = void 0;
+var tms_js_1 = require("./tms.js");
+Object.defineProperty(exports, "TranslationManagementSystem", { enumerable: true, get: function () { return tms_js_1.TranslationManagementSystem; } });
+var multi_content_tms_js_1 = require("./multi-content-tms.js");
+Object.defineProperty(exports, "MultiContentTMS", { enumerable: true, get: function () { return multi_content_tms_js_1.MultiContentTMS; } });
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return config_js_1.ConfigManager; } });
+Object.defineProperty(exports, "createConfig", { enumerable: true, get: function () { return config_js_1.createConfig; } });
+Object.defineProperty(exports, "DEFAULT_TMS_CONFIG", { enumerable: true, get: function () { return config_js_1.DEFAULT_TMS_CONFIG; } });
+var text_detector_js_1 = require("./detector/text-detector.js");
+Object.defineProperty(exports, "TextDetector", { enumerable: true, get: function () { return text_detector_js_1.TextDetector; } });
+var video_detector_js_1 = require("./detector/video-detector.js");
+Object.defineProperty(exports, "VideoDetector", { enumerable: true, get: function () { return video_detector_js_1.VideoDetector; } });
+var image_detector_js_1 = require("./detector/image-detector.js");
+Object.defineProperty(exports, "ImageDetector", { enumerable: true, get: function () { return image_detector_js_1.ImageDetector; } });
+var cms_detector_js_1 = require("./detector/cms-detector.js");
+Object.defineProperty(exports, "CMSDetector", { enumerable: true, get: function () { return cms_detector_js_1.CMSDetector; } });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./detector/content-type-detector.js"), exports);

package/dist/tms/multi-content-tms.d.ts

@@ -0,0 +1,42 @@
+import { Ollang } from '../index.js';
+import { AnyContentItem, ContentType, VideoContent, ImageContent, I18nContent } from './detector/content-type-detector.js';
+import { TMSConfig } from './types.js';
+import { OrderType } from '../types/index.js';
+export interface MultiContentScanResult {
+    i18n: I18nContent[];
+    videos: VideoContent[];
+    images: ImageContent[];
+    total: number;
+}
+export interface TranslationRequest {
+    contentType: ContentType;
+    items: AnyContentItem[];
+    targetLanguage: string;
+    level?: number;
+}
+export interface TranslationResult {
+    orderId: string;
+    orderType: OrderType;
+    status: string;
+    contentType: ContentType;
+    itemCount: number;
+}
+export declare class MultiContentTMS {
+    private config;
+    private configManager;
+    private ollangClient;
+    private textDetector;
+    private videoDetector;
+    private imageDetector;
+    constructor(customConfig?: Partial<TMSConfig>);
+    scanAll(): Promise<MultiContentScanResult>;
+    private scanI18n;
+    translate(request: TranslationRequest): Promise<TranslationResult>;
+    private translateVideos;
+    private translateImages;
+    private translateI18n;
+    getOrderStatus(orderId: string): Promise<import("../index.js").Order>;
+    waitForCompletion(orderId: string, maxWaitSeconds?: number): Promise<any>;
+    getSDK(): Ollang;
+    getConfig(): TMSConfig;
+}