@ollang-dev/sdk 0.3.1

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

@@ -0,0 +1,17 @@
+import { TextItem } from '../types';
+import { CapturedContent } from '../../browser';
+export declare class CMSDetector {
+    static convertToTextItems(contents: CapturedContent[]): TextItem[];
+    static convertToTextItem(content: CapturedContent): TextItem;
+    private static generateTags;
+    static filterByCMSType(items: TextItem[], cmsType: string): TextItem[];
+    static filterByCMSField(items: TextItem[], field: string): TextItem[];
+    static groupByURL(items: TextItem[]): Map<string, TextItem[]>;
+    static groupByCMSField(items: TextItem[]): Map<string, TextItem[]>;
+    static getStats(items: TextItem[]): {
+        total: number;
+        byType: Record<string, number>;
+        byField: Record<string, number>;
+        byURL: Record<string, number>;
+    };
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMSDetector = void 0;
+class CMSDetector {
+    static convertToTextItems(contents) {
+        return contents.map((content) => this.convertToTextItem(content));
+    }
+    static convertToTextItem(content) {
+        const textItem = {
+            id: content.id,
+            text: content.text,
+            type: 'cms',
+            source: {
+                file: content.url,
+                line: 0,
+                column: 0,
+                context: content.selector,
+            },
+            selected: false,
+            cmsField: content.cmsField,
+            cmsId: content.cmsId,
+            category: content.cmsType || 'dynamic',
+            tags: this.generateTags(content),
+            strapiContentType: content.strapiContentType,
+            strapiEntryId: content.strapiEntryId,
+            strapiField: content.strapiField,
+        };
+        return textItem;
+    }
+    static generateTags(content) {
+        const tags = [];
+        if (content.cmsType) {
+            tags.push(`cms:${content.cmsType}`);
+        }
+        if (content.tagName) {
+            tags.push(`tag:${content.tagName}`);
+        }
+        if (content.cmsField) {
+            tags.push(`field:${content.cmsField}`);
+        }
+        Object.keys(content.attributes).forEach((key) => {
+            if (key.startsWith('data-')) {
+                tags.push(`attr:${key.replace('data-', '')}`);
+            }
+        });
+        return tags;
+    }
+    static filterByCMSType(items, cmsType) {
+        return items.filter((item) => item.category === cmsType);
+    }
+    static filterByCMSField(items, field) {
+        return items.filter((item) => item.cmsField === field);
+    }
+    static groupByURL(items) {
+        const groups = new Map();
+        items.forEach((item) => {
+            const url = item.source.file;
+            if (!groups.has(url)) {
+                groups.set(url, []);
+            }
+            groups.get(url).push(item);
+        });
+        return groups;
+    }
+    static groupByCMSField(items) {
+        const groups = new Map();
+        items.forEach((item) => {
+            const field = item.cmsField || 'unknown';
+            if (!groups.has(field)) {
+                groups.set(field, []);
+            }
+            groups.get(field).push(item);
+        });
+        return groups;
+    }
+    static getStats(items) {
+        const stats = {
+            total: items.length,
+            byType: {},
+            byField: {},
+            byURL: {},
+        };
+        items.forEach((item) => {
+            const type = item.category || 'unknown';
+            stats.byType[type] = (stats.byType[type] || 0) + 1;
+            const field = item.cmsField || 'unknown';
+            stats.byField[field] = (stats.byField[field] || 0) + 1;
+            const url = item.source.file;
+            stats.byURL[url] = (stats.byURL[url] || 0) + 1;
+        });
+        return stats;
+    }
+}
+exports.CMSDetector = CMSDetector;

package/dist/tms/detector/content-type-detector.d.ts

@@ -0,0 +1,79 @@
+export type ContentType = 'i18n' | 'hardcoded' | 'video' | 'image' | 'audio' | 'document' | 'cms';
+export interface ContentItem {
+    id: string;
+    type: ContentType;
+    path: string;
+    metadata: Record<string, any>;
+}
+export interface I18nContent extends ContentItem {
+    type: 'i18n';
+    metadata: {
+        key: string;
+        namespace?: string;
+        text: string;
+    };
+}
+export interface VideoContent extends ContentItem {
+    type: 'video';
+    filename?: string;
+    url?: string;
+    line?: number;
+    column?: number;
+    metadata: {
+        duration: number;
+        format: string;
+        hasSubtitles: boolean;
+        subtitlePath?: string;
+        size?: number;
+        isUrl?: boolean;
+        sourceFile?: string;
+    };
+}
+export interface ImageContent extends ContentItem {
+    type: 'image';
+    filename?: string;
+    url?: string;
+    line?: number;
+    column?: number;
+    metadata: {
+        hasText: boolean;
+        detectedText?: string[];
+        format: string;
+        size?: number;
+        isUrl?: boolean;
+        sourceFile?: string;
+    };
+}
+export interface AudioContent extends ContentItem {
+    type: 'audio';
+    filename?: string;
+    url?: string;
+    line?: number;
+    column?: number;
+    metadata: {
+        duration: number;
+        format: string;
+        size?: number;
+        isUrl?: boolean;
+        sourceFile?: string;
+    };
+}
+export interface HardcodedTextContent extends ContentItem {
+    type: 'hardcoded';
+    metadata: {
+        text: string;
+        line: number;
+        column: number;
+        context: string;
+    };
+}
+export type AnyContentItem = I18nContent | VideoContent | ImageContent | AudioContent | HardcodedTextContent;
+export interface ContentDetector<T extends ContentItem = ContentItem> {
+    detect(projectRoot: string, config: DetectionConfig): Promise<T[]>;
+    supports(filePath: string): boolean;
+}
+export interface DetectionConfig {
+    includePaths: string[];
+    excludePaths: string[];
+    includePatterns: string[];
+}

package/dist/tms/detector/content-type-detector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,11 @@
+import { TextItem, ScanConfig } from '../types.js';
+export declare class HardcodedDetector {
+    private readonly MIN_TEXT_LENGTH;
+    private readonly MAX_TEXT_LENGTH;
+    detect(config: ScanConfig): Promise<TextItem[]>;
+    private scanDirectory;
+    private scanFile;
+    private isCodeFile;
+    private isValidText;
+    private shouldExclude;
+}

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

@@ -0,0 +1,154 @@
+"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.HardcodedDetector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class HardcodedDetector {
+    constructor() {
+        this.MIN_TEXT_LENGTH = 3;
+        this.MAX_TEXT_LENGTH = 500;
+    }
+    async detect(config) {
+        const texts = [];
+        for (const includePath of config.includePaths) {
+            const hardcodedTexts = await this.scanDirectory(includePath, config.excludePaths);
+            texts.push(...hardcodedTexts);
+        }
+        return texts;
+    }
+    async scanDirectory(dirPath, excludePaths) {
+        const texts = [];
+        if (!fs.existsSync(dirPath)) {
+            return texts;
+        }
+        const stat = fs.statSync(dirPath);
+        if (stat.isFile()) {
+            if (this.isCodeFile(dirPath) && !this.shouldExclude(dirPath, excludePaths)) {
+                const fileTexts = await this.scanFile(dirPath);
+                texts.push(...fileTexts);
+            }
+            return texts;
+        }
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (this.shouldExclude(fullPath, excludePaths)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                const subTexts = await this.scanDirectory(fullPath, excludePaths);
+                texts.push(...subTexts);
+            }
+            else if (entry.isFile() && this.isCodeFile(entry.name)) {
+                const fileTexts = await this.scanFile(fullPath);
+                texts.push(...fileTexts);
+            }
+        }
+        return texts;
+    }
+    async scanFile(filePath) {
+        const texts = [];
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const jsxTextRegex = />([^<>{}\n]+)</g;
+        lines.forEach((lineContent, lineIndex) => {
+            const trimmedLine = lineContent.trim();
+            if (trimmedLine.startsWith('//') ||
+                trimmedLine.startsWith('/*') ||
+                trimmedLine.startsWith('*') ||
+                trimmedLine.startsWith('<!--')) {
+                return;
+            }
+            let match;
+            const regex = new RegExp(jsxTextRegex);
+            while ((match = regex.exec(lineContent)) !== null) {
+                const text = match[1].trim();
+                if (this.isValidText(text)) {
+                    texts.push({
+                        id: `hardcoded-${filePath}-${lineIndex}-${match.index}`,
+                        text,
+                        type: 'hardcoded',
+                        source: {
+                            file: filePath,
+                            line: lineIndex + 1,
+                            column: match.index,
+                            context: lineContent.trim(),
+                        },
+                        selected: false,
+                        status: 'scanned',
+                    });
+                }
+            }
+        });
+        return texts;
+    }
+    isCodeFile(fileName) {
+        const codeExtensions = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.html'];
+        return codeExtensions.some((ext) => fileName.endsWith(ext));
+    }
+    isValidText(text) {
+        if (text.length < this.MIN_TEXT_LENGTH || text.length > this.MAX_TEXT_LENGTH) {
+            return false;
+        }
+        if (!/[a-zA-Z]/.test(text)) {
+            return false;
+        }
+        if (!text.trim()) {
+            return false;
+        }
+        const skipPatterns = [
+            /^[0-9]+$/,
+            /^[a-z_]+$/i,
+            /^[A-Z_]+$/,
+            /^\$\{.*\}$/,
+            /^https?:\/\//,
+            /^\/[a-z0-9\-_/]+$/i,
+            /^#[0-9a-f]{3,6}$/i,
+            /^rgb\(/,
+            /^\{.*\}$/,
+            /^\[.*\]$/,
+        ];
+        return !skipPatterns.some((pattern) => pattern.test(text));
+    }
+    shouldExclude(filePath, excludePaths) {
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        return excludePaths.some((exclude) => {
+            const normalizedExclude = exclude.replace(/\\/g, '/');
+            return normalizedPath.includes(normalizedExclude);
+        });
+    }
+}
+exports.HardcodedDetector = HardcodedDetector;

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

@@ -0,0 +1,16 @@
+import { TextItem, ScanConfig, I18nSetupInfo } from '../types.js';
+export declare class I18nDetector {
+    detect(config: ScanConfig): Promise<TextItem[]>;
+    private isI18nDirectory;
+    private scanI18nDirectory;
+    detectFile(filePath: string): Promise<TextItem[]>;
+    detectSetup(projectRoot: string): Promise<I18nSetupInfo | null>;
+    private detectNextI18next;
+    private detectReactI18next;
+    private detectVueI18n;
+    private detectGenericI18n;
+    private buildI18nSetupFromDir;
+    private extractKeyValues;
+    private parseSimpleYaml;
+    private fileExists;
+}

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

@@ -0,0 +1,311 @@
+"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.I18nDetector = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class I18nDetector {
+    async detect(config) {
+        const texts = [];
+        for (const includePath of config.includePaths) {
+            if (await this.isI18nDirectory(includePath)) {
+                const dirTexts = await this.scanI18nDirectory(includePath, config.sourceLanguage);
+                texts.push(...dirTexts);
+            }
+            else {
+                const setup = await this.detectSetup(includePath);
+                if (!setup || setup.framework === 'none') {
+                    continue;
+                }
+                for (const translationFile of setup.translationFiles) {
+                    if (config.sourceLanguage && translationFile.language !== config.sourceLanguage) {
+                        continue;
+                    }
+                    const fileTexts = await this.detectFile(translationFile.path);
+                    texts.push(...fileTexts);
+                }
+            }
+        }
+        return texts;
+    }
+    async isI18nDirectory(dirPath) {
+        try {
+            const stat = await fs.stat(dirPath);
+            if (!stat.isDirectory())
+                return false;
+            const dirName = path.basename(dirPath).toLowerCase();
+            if (dirName.includes('i18n') ||
+                dirName.includes('locale') ||
+                dirName.includes('translation')) {
+                return true;
+            }
+            const files = await fs.readdir(dirPath);
+            const hasJsonFiles = files.some((f) => f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml'));
+            return hasJsonFiles;
+        }
+        catch {
+            return false;
+        }
+    }
+    async scanI18nDirectory(dirPath, sourceLanguage) {
+        const texts = [];
+        const items = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const item of items) {
+            const itemPath = path.join(dirPath, item.name);
+            if (item.isDirectory()) {
+                const subTexts = await this.scanI18nDirectory(itemPath, sourceLanguage);
+                texts.push(...subTexts);
+            }
+            else if (item.isFile()) {
+                if (item.name.endsWith('.json') ||
+                    item.name.endsWith('.yaml') ||
+                    item.name.endsWith('.yml')) {
+                    const lang = path.basename(item.name, path.extname(item.name));
+                    if (sourceLanguage && lang !== sourceLanguage) {
+                        continue;
+                    }
+                    const fileTexts = await this.detectFile(itemPath);
+                    texts.push(...fileTexts);
+                }
+            }
+        }
+        return texts;
+    }
+    async detectFile(filePath) {
+        const texts = [];
+        const content = await fs.readFile(filePath, 'utf-8');
+        let data;
+        if (filePath.endsWith('.json')) {
+            data = JSON.parse(content);
+        }
+        else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+            data = this.parseSimpleYaml(content);
+        }
+        else {
+            return texts;
+        }
+        const items = this.extractKeyValues(data, '', filePath);
+        texts.push(...items);
+        return texts;
+    }
+    async detectSetup(projectRoot) {
+        const nextI18nConfig = path.join(projectRoot, 'next-i18next.config.js');
+        if (await this.fileExists(nextI18nConfig)) {
+            return this.detectNextI18next(projectRoot);
+        }
+        const packageJson = path.join(projectRoot, 'package.json');
+        if (await this.fileExists(packageJson)) {
+            const pkg = JSON.parse(await fs.readFile(packageJson, 'utf-8'));
+            if (pkg.dependencies?.['react-i18next'] || pkg.devDependencies?.['react-i18next']) {
+                return this.detectReactI18next(projectRoot);
+            }
+            if (pkg.dependencies?.['vue-i18n'] || pkg.devDependencies?.['vue-i18n']) {
+                return this.detectVueI18n(projectRoot);
+            }
+        }
+        return this.detectGenericI18n(projectRoot);
+    }
+    async detectNextI18next(projectRoot) {
+        const translationFiles = [];
+        const localesDir = path.join(projectRoot, 'public', 'locales');
+        if (await this.fileExists(localesDir)) {
+            const languages = await fs.readdir(localesDir);
+            for (const lang of languages) {
+                const langDir = path.join(localesDir, lang);
+                const stat = await fs.stat(langDir);
+                if (stat.isDirectory()) {
+                    const files = await fs.readdir(langDir);
+                    for (const file of files) {
+                        if (file.endsWith('.json')) {
+                            translationFiles.push({
+                                language: lang,
+                                path: path.join(langDir, file),
+                                format: 'json',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            framework: 'next-i18next',
+            configFile: path.join(projectRoot, 'next-i18next.config.js'),
+            translationFiles,
+            defaultNamespace: 'common',
+            namespaces: [...new Set(translationFiles.map((f) => path.basename(f.path, '.json')))],
+        };
+    }
+    async detectReactI18next(projectRoot) {
+        const possibleDirs = [
+            path.join(projectRoot, 'public', 'locales'),
+            path.join(projectRoot, 'src', 'locales'),
+            path.join(projectRoot, 'locales'),
+        ];
+        for (const dir of possibleDirs) {
+            if (await this.fileExists(dir)) {
+                return this.buildI18nSetupFromDir(dir, 'react-i18next');
+            }
+        }
+        return {
+            framework: 'react-i18next',
+            translationFiles: [],
+            defaultNamespace: 'translation',
+            namespaces: [],
+        };
+    }
+    async detectVueI18n(projectRoot) {
+        const possibleDirs = [
+            path.join(projectRoot, 'src', 'locales'),
+            path.join(projectRoot, 'locales'),
+        ];
+        for (const dir of possibleDirs) {
+            if (await this.fileExists(dir)) {
+                return this.buildI18nSetupFromDir(dir, 'vue-i18n');
+            }
+        }
+        return {
+            framework: 'vue-i18n',
+            translationFiles: [],
+            defaultNamespace: 'messages',
+            namespaces: [],
+        };
+    }
+    async detectGenericI18n(projectRoot) {
+        const possibleDirs = [
+            path.join(projectRoot, 'public', 'locales'),
+            path.join(projectRoot, 'src', 'locales'),
+            path.join(projectRoot, 'locales'),
+            path.join(projectRoot, 'translations'),
+            path.join(projectRoot, 'i18n'),
+        ];
+        for (const dir of possibleDirs) {
+            if (await this.fileExists(dir)) {
+                return this.buildI18nSetupFromDir(dir, 'custom');
+            }
+        }
+        return null;
+    }
+    async buildI18nSetupFromDir(dir, framework) {
+        const translationFiles = [];
+        const items = await fs.readdir(dir, { withFileTypes: true });
+        for (const item of items) {
+            if (item.isDirectory()) {
+                const langDir = path.join(dir, item.name);
+                const files = await fs.readdir(langDir);
+                for (const file of files) {
+                    if (file.endsWith('.json') || file.endsWith('.yaml') || file.endsWith('.yml')) {
+                        translationFiles.push({
+                            language: item.name,
+                            path: path.join(langDir, file),
+                            format: file.endsWith('.json') ? 'json' : 'yaml',
+                        });
+                    }
+                }
+            }
+            else if (item.isFile()) {
+                const fileName = item.name;
+                if (fileName.endsWith('.json') || fileName.endsWith('.yaml') || fileName.endsWith('.yml')) {
+                    const lang = path.basename(fileName, path.extname(fileName));
+                    translationFiles.push({
+                        language: lang,
+                        path: path.join(dir, fileName),
+                        format: fileName.endsWith('.json') ? 'json' : 'yaml',
+                    });
+                }
+            }
+        }
+        return {
+            framework,
+            translationFiles,
+            defaultNamespace: 'common',
+            namespaces: [
+                ...new Set(translationFiles.map((f) => path.basename(f.path, path.extname(f.path)))),
+            ],
+        };
+    }
+    extractKeyValues(obj, prefix, filePath, lineOffset = 0) {
+        const items = [];
+        for (const [key, value] of Object.entries(obj)) {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            if (typeof value === 'string') {
+                items.push({
+                    id: `i18n-${filePath}-${fullKey}`,
+                    text: value,
+                    type: 'i18n',
+                    source: {
+                        file: filePath,
+                        line: lineOffset,
+                        column: 0,
+                    },
+                    i18nKey: fullKey,
+                    selected: false,
+                });
+            }
+            else if (typeof value === 'object' && value !== null) {
+                const nestedItems = this.extractKeyValues(value, fullKey, filePath, lineOffset);
+                items.push(...nestedItems);
+            }
+        }
+        return items;
+    }
+    parseSimpleYaml(content) {
+        const result = {};
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const colonIndex = trimmed.indexOf(':');
+            if (colonIndex === -1)
+                continue;
+            const key = trimmed.substring(0, colonIndex).trim();
+            const value = trimmed.substring(colonIndex + 1).trim();
+            if (value) {
+                result[key] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+        return result;
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.I18nDetector = I18nDetector;