@ollang-dev/sdk 0.3.1

package/dist/tms/server/strapi-pusher.d.ts

@@ -0,0 +1,31 @@
+export interface StrapiPusherConfig {
+    strapiUrl: string;
+    strapiToken: string;
+}
+export interface StrapiTranslationItem {
+    contentType: string;
+    entryId: number;
+    field: string;
+    translatedText: string;
+    route?: string;
+}
+export interface StrapiPushResult {
+    success: boolean;
+    contentType: string;
+    entryId: number;
+    field: string;
+    error?: string;
+}
+export declare class StrapiPusher {
+    private client;
+    private config;
+    constructor(config: StrapiPusherConfig);
+    private ensureLocale;
+    pushTranslation(item: StrapiTranslationItem, targetLocale: string): Promise<StrapiPushResult>;
+    pushBatch(items: StrapiTranslationItem[], targetLocale: string): Promise<{
+        results: StrapiPushResult[];
+        errors: StrapiPushResult[];
+    }>;
+    private buildNestedUpdate;
+    private deepMerge;
+}

package/dist/tms/server/strapi-pusher.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrapiPusher = void 0;
+const axios_1 = __importDefault(require("axios"));
+const STRAPI_LOCALE_MAP = {
+    af: 'af-ZA',
+    ak: 'ak-GH',
+    sq: 'sq-AL',
+    am: 'am-ET',
+    ar: 'ar-SA',
+    hy: 'hy-AM',
+    as: 'as-IN',
+    az: 'az-Latn-AZ',
+    bm: 'bm-ML',
+    eu: 'eu-ES',
+    be: 'be-BY',
+    bn: 'bn-BD',
+    bs: 'bs-BA',
+    br: 'br-FR',
+    bg: 'bg-BG',
+    my: 'my-MM',
+    ca: 'ca-ES',
+    zh: 'zh-Hans-CN',
+    hr: 'hr-HR',
+    cs: 'cs-CZ',
+    da: 'da-DK',
+    nl: 'nl-NL',
+    en: 'en-US',
+    eo: 'eo',
+    et: 'et-EE',
+    ee: 'ee-GH',
+    fil: 'fil-PH',
+    fi: 'fi-FI',
+    fr: 'fr-FR',
+    gl: 'gl-ES',
+    ka: 'ka-GE',
+    de: 'de-DE',
+    el: 'el-GR',
+    gu: 'gu-IN',
+    ha: 'ha-Latn-NG',
+    haw: 'haw-US',
+    he: 'he-IL',
+    hi: 'hi-IN',
+    hu: 'hu-HU',
+    is: 'is-IS',
+    ig: 'ig-NG',
+    id: 'id-ID',
+    ga: 'ga-IE',
+    it: 'it-IT',
+    ja: 'ja-JP',
+    kn: 'kn-IN',
+    kk: 'kk-Cyrl-KZ',
+    km: 'km-KH',
+    rw: 'rw-RW',
+    ko: 'ko',
+    ky: 'ky',
+    lo: 'lo',
+    lv: 'lv-LV',
+    ln: 'ln-CD',
+    lt: 'lt-LT',
+    mk: 'mk-MK',
+    mg: 'mg-MG',
+    ms: 'ms-MY',
+    ml: 'ml-IN',
+    mt: 'mt-MT',
+    mr: 'mr-IN',
+    mn: 'mn',
+    ne: 'ne-NP',
+    nb: 'nb-NO',
+    nn: 'nn-NO',
+    or: 'or-IN',
+    om: 'om-ET',
+    ps: 'ps-AF',
+    fa: 'fa-IR',
+    pl: 'pl-PL',
+    pt: 'pt-PT',
+    pa: 'pa-Guru-IN',
+    ro: 'ro-RO',
+    ru: 'ru-RU',
+    sg: 'sg-CF',
+    sr: 'sr-Cyrl-RS',
+    sn: 'sn-ZW',
+    si: 'si-LK',
+    sk: 'sk-SK',
+    sl: 'sl-SI',
+    so: 'so-SO',
+    es: 'es-ES',
+    sw: 'sw-KE',
+    sv: 'sv-SE',
+    tg: 'tg',
+    ta: 'ta-IN',
+    te: 'te-IN',
+    th: 'th-TH',
+    ti: 'ti-ET',
+    to: 'to-TO',
+    tr: 'tr-TR',
+    tk: 'tk',
+    uk: 'uk-UA',
+    ur: 'ur-PK',
+    uz: 'uz-Latn-UZ',
+    vi: 'vi-VN',
+    cy: 'cy-GB',
+    yo: 'yo-NG',
+    zu: 'zu-ZA',
+};
+function normalizeLocaleForStrapi(targetLocale) {
+    if (targetLocale.includes('-'))
+        return targetLocale;
+    return STRAPI_LOCALE_MAP[targetLocale] || targetLocale;
+}
+class StrapiPusher {
+    constructor(config) {
+        this.config = config;
+        const apiBase = config.strapiUrl.replace(/\/$/, '');
+        this.client = axios_1.default.create({
+            baseURL: `${apiBase}/api`,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${config.strapiToken}`,
+            },
+            timeout: 30000,
+        });
+    }
+    async ensureLocale(targetLocale) {
+        const normalized = normalizeLocaleForStrapi(targetLocale);
+        try {
+            const res = await this.client.get('/i18n/locales');
+            const locales = res.data || [];
+            const exact = locales.find((l) => l.code === normalized);
+            if (exact)
+                return exact.code;
+            const fallback = locales.find((l) => l.code.startsWith(normalized.split('-')[0]));
+            if (fallback) {
+                return fallback.code;
+            }
+            return normalized;
+        }
+        catch (error) {
+            const msg = error.response?.data?.error?.message || error.message || 'Unknown error';
+            return normalized;
+        }
+    }
+    async pushTranslation(item, targetLocale) {
+        const { contentType, entryId, field, translatedText } = item;
+        const normalizedLocale = normalizeLocaleForStrapi(targetLocale);
+        const locale = await this.ensureLocale(normalizedLocale);
+        try {
+            const entryRes = await this.client.get(`/${contentType}/${entryId}?populate=localizations`);
+            const attributes = entryRes.data?.data?.attributes || {};
+            const originalLocale = attributes.locale;
+            const localizations = attributes.localizations?.data || [];
+            const existing = localizations.find((loc) => loc.attributes?.locale === locale);
+            let updateData = this.buildNestedUpdate(field, translatedText);
+            if (item.route && !updateData.route) {
+                updateData = { ...updateData, route: item.route };
+            }
+            if (!existing && locale !== originalLocale) {
+                const currentRoute = updateData.route !== undefined ? updateData.route : attributes.route;
+                if (currentRoute) {
+                    const localeSuffix = (targetLocale.split('-')[0] || targetLocale).toLowerCase();
+                    if (!updateData.route || updateData.route === attributes.route) {
+                        updateData.route = `${currentRoute}-${localeSuffix}`;
+                    }
+                }
+            }
+            if (locale === originalLocale && !existing) {
+                await this.client.put(`/${contentType}/${entryId}`, {
+                    data: updateData,
+                });
+            }
+            else {
+                if (existing) {
+                    await this.client.put(`/${contentType}/${existing.id}`, {
+                        data: updateData,
+                    });
+                }
+                else {
+                    await this.client.post(`/${contentType}/${entryId}/localizations`, {
+                        locale,
+                        ...updateData,
+                    });
+                }
+            }
+            return { success: true, contentType, entryId, field };
+        }
+        catch (error) {
+            const raw = error.response?.data;
+            const msg = raw?.error?.message || raw?.message || error.message || 'Unknown error';
+            return { success: false, contentType, entryId, field, error: msg };
+        }
+    }
+    async pushBatch(items, targetLocale) {
+        const results = [];
+        const errors = [];
+        const normalizedLocale = normalizeLocaleForStrapi(targetLocale);
+        const locale = await this.ensureLocale(normalizedLocale);
+        const grouped = new Map();
+        for (const item of items) {
+            const key = `${item.contentType}:${item.entryId}`;
+            if (!grouped.has(key))
+                grouped.set(key, []);
+            grouped.get(key).push(item);
+        }
+        for (const [key, entryItems] of grouped) {
+            const { contentType, entryId } = entryItems[0];
+            try {
+                const entryRes = await this.client.get(`/${contentType}/${entryId}?populate=localizations`);
+                const attributes = entryRes.data?.data?.attributes || {};
+                const originalLocale = attributes.locale;
+                const localizations = attributes.localizations?.data || [];
+                const existing = localizations.find((loc) => loc.attributes?.locale === locale);
+                let mergedUpdate = {};
+                for (const item of entryItems) {
+                    const fieldUpdate = this.buildNestedUpdate(item.field, item.translatedText);
+                    mergedUpdate = this.deepMerge(mergedUpdate, fieldUpdate);
+                }
+                const explicitRoute = entryItems.find((i) => i.route)?.route;
+                if (explicitRoute && !mergedUpdate.route) {
+                    mergedUpdate.route = explicitRoute;
+                }
+                if (!existing && locale !== originalLocale) {
+                    const baseRoute = mergedUpdate.route !== undefined ? mergedUpdate.route : attributes.route;
+                    if (baseRoute) {
+                        const localeSuffix = (targetLocale.split('-')[0] || targetLocale).toLowerCase();
+                        if (!mergedUpdate.route || mergedUpdate.route === attributes.route) {
+                            mergedUpdate.route = `${baseRoute}-${localeSuffix}`;
+                        }
+                    }
+                }
+                if (locale === originalLocale && !existing) {
+                    await this.client.put(`/${contentType}/${entryId}`, {
+                        data: mergedUpdate,
+                    });
+                }
+                else {
+                    if (existing) {
+                        await this.client.put(`/${contentType}/${existing.id}`, {
+                            data: mergedUpdate,
+                        });
+                    }
+                    else {
+                        await this.client.post(`/${contentType}/${entryId}/localizations`, {
+                            locale,
+                            ...mergedUpdate,
+                        });
+                    }
+                }
+                for (const item of entryItems) {
+                    results.push({ success: true, contentType, entryId, field: item.field });
+                }
+            }
+            catch (error) {
+                const raw = error.response?.data;
+                const msg = raw?.error?.message || raw?.message || error.message || 'Unknown error';
+                for (const item of entryItems) {
+                    errors.push({ success: false, contentType, entryId, field: item.field, error: msg });
+                }
+            }
+        }
+        return { results, errors };
+    }
+    buildNestedUpdate(fieldPath, value) {
+        const cleanPath = fieldPath.replace(/\[\d+\]/g, '');
+        const parts = cleanPath.split('.');
+        if (parts.length === 1)
+            return { [parts[0]]: value };
+        const result = {};
+        let current = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+            current[parts[i]] = {};
+            current = current[parts[i]];
+        }
+        current[parts[parts.length - 1]] = value;
+        return result;
+    }
+    deepMerge(target, source) {
+        const result = { ...target };
+        for (const key of Object.keys(source)) {
+            if (result[key] &&
+                typeof result[key] === 'object' &&
+                !Array.isArray(result[key]) &&
+                typeof source[key] === 'object' &&
+                !Array.isArray(source[key])) {
+                result[key] = this.deepMerge(result[key], source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+}
+exports.StrapiPusher = StrapiPusher;

package/dist/tms/server/strapi-schema.d.ts

@@ -0,0 +1,47 @@
+export interface StrapiSchemaConfig {
+    fieldsByContentType: Record<string, string[]>;
+    fetchedAt: number;
+}
+interface ContentTypeAttribute {
+    type: string;
+    pluginOptions?: {
+        i18n?: {
+            localized?: boolean;
+        };
+    };
+    component?: string;
+    repeatable?: boolean;
+    [key: string]: unknown;
+}
+interface ContentTypeSchema {
+    attributes: Record<string, ContentTypeAttribute>;
+    [key: string]: unknown;
+}
+interface ContentTypeItem {
+    uid: string;
+    apiID?: string;
+    schema: ContentTypeSchema;
+    [key: string]: unknown;
+}
+interface ComponentAttribute {
+    type: string;
+    component?: string;
+    repeatable?: boolean;
+    [key: string]: unknown;
+}
+interface ComponentSchema {
+    attributes: Record<string, ComponentAttribute>;
+    [key: string]: unknown;
+}
+interface ComponentItem {
+    uid: string;
+    schema: ComponentSchema;
+    [key: string]: unknown;
+}
+export declare function parseStrapiSchema(contentTypesData: ContentTypeItem[], componentsData: ComponentItem[]): Record<string, string[]>;
+export declare function fetchStrapiSchema(strapiBaseUrl: string, adminJwt: string): Promise<{
+    contentTypes: ContentTypeItem[];
+    components: ComponentItem[];
+}>;
+export declare function loadStrapiSchema(strapiBaseUrl: string, adminJwt: string): Promise<StrapiSchemaConfig>;
+export {};

package/dist/tms/server/strapi-schema.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrapiSchema = parseStrapiSchema;
+exports.fetchStrapiSchema = fetchStrapiSchema;
+exports.loadStrapiSchema = loadStrapiSchema;
+const TRANSLATABLE_TYPES = new Set(['string', 'text', 'richtext']);
+const SCALAR_TYPES = new Set(['string', 'text', 'richtext', 'enumeration', 'email', 'password']);
+function getComponentTranslatablePaths(componentUid, componentsMap, prefix, visited, parentRepeatable) {
+    if (visited.has(componentUid))
+        return [];
+    visited.add(componentUid);
+    const schema = componentsMap.get(componentUid);
+    if (!schema || !schema.attributes)
+        return [];
+    const pathPrefix = parentRepeatable && prefix ? `${prefix}[]` : prefix;
+    const paths = [];
+    for (const [attrName, attr] of Object.entries(schema.attributes)) {
+        const fullPath = pathPrefix ? `${pathPrefix}.${attrName}` : attrName;
+        if (attr.type === 'component' && attr.component) {
+            const nested = getComponentTranslatablePaths(attr.component, componentsMap, fullPath, visited, attr.repeatable);
+            paths.push(...nested);
+        }
+        else if (TRANSLATABLE_TYPES.has(attr.type)) {
+            paths.push(attr.repeatable ? `${fullPath}[]` : fullPath);
+        }
+    }
+    return paths;
+}
+function parseStrapiSchema(contentTypesData, componentsData) {
+    const componentsMap = new Map();
+    for (const item of componentsData) {
+        if (item.uid && item.schema) {
+            componentsMap.set(item.uid, item.schema);
+        }
+    }
+    const fieldsByContentType = {};
+    for (const item of contentTypesData) {
+        if (!item.uid || !item.uid.startsWith('api::'))
+            continue;
+        const apiID = item.apiID || item.uid.split('.').pop() || item.uid;
+        const attrs = item.schema?.attributes;
+        if (!attrs)
+            continue;
+        const paths = [];
+        for (const [attrName, attr] of Object.entries(attrs)) {
+            const localized = attr.pluginOptions?.i18n?.localized === true;
+            if (!localized && attr.type !== 'relation')
+                continue;
+            if (TRANSLATABLE_TYPES.has(attr.type)) {
+                paths.push(attrName);
+            }
+            else if (attr.type === 'component' && attr.component && localized) {
+                const visited = new Set();
+                const nested = getComponentTranslatablePaths(attr.component, componentsMap, attrName, visited, attr.repeatable);
+                paths.push(...nested);
+            }
+        }
+        if (paths.length > 0) {
+            fieldsByContentType[apiID] = paths;
+        }
+    }
+    return fieldsByContentType;
+}
+async function fetchStrapiSchema(strapiBaseUrl, adminJwt) {
+    const base = strapiBaseUrl.replace(/\/$/, '');
+    const headers = {
+        Authorization: `Bearer ${adminJwt}`,
+        'Content-Type': 'application/json',
+    };
+    const [ctRes, compRes] = await Promise.all([
+        fetch(`${base}/content-type-builder/content-types`, { headers }),
+        fetch(`${base}/content-type-builder/components`, { headers }),
+    ]);
+    if (!ctRes.ok) {
+        const text = await ctRes.text();
+        throw new Error(`Content-types request failed (${ctRes.status}): ${text}`);
+    }
+    if (!compRes.ok) {
+        const text = await compRes.text();
+        throw new Error(`Components request failed (${compRes.status}): ${text}`);
+    }
+    const contentTypes = (await ctRes.json()).data || [];
+    const components = (await compRes.json()).data || [];
+    return { contentTypes, components };
+}
+async function loadStrapiSchema(strapiBaseUrl, adminJwt) {
+    const { contentTypes, components } = await fetchStrapiSchema(strapiBaseUrl, adminJwt);
+    const fieldsByContentType = parseStrapiSchema(contentTypes, components);
+    return {
+        fieldsByContentType,
+        fetchedAt: Date.now(),
+    };
+}

package/dist/tms/tms.d.ts

@@ -0,0 +1,48 @@
+import { Ollang } from '../index.js';
+import { TMSConfig, TMSState, TextItem, I18nSetupInfo, TranslationOrder, Translation } from './types.js';
+import { VideoContent, ImageContent, AudioContent } from './detector/content-type-detector.js';
+export declare class TranslationManagementSystem {
+    private config;
+    private configManager;
+    private textDetector;
+    private videoDetector;
+    private imageDetector;
+    private audioDetector;
+    private ollangClient;
+    private state;
+    constructor(customConfig?: Partial<TMSConfig>);
+    scan(): Promise<TextItem[]>;
+    private checkExistingTranslations;
+    syncWithCodebase(targetLanguage: string): Promise<void>;
+    translate(texts: TextItem[], targetLanguage: string, level?: number, folderName?: string, folderId?: string): Promise<TranslationOrder>;
+    private translateMock;
+    private createOrder;
+    private pollOrderStatus;
+    private extractTranslations;
+    private createProjectWithVtt;
+    private generateVttContent;
+    private formatVttTime;
+    getState(): TMSState;
+    getConfig(): TMSConfig;
+    getI18nSetup(): I18nSetupInfo | null;
+    getSDK(): Ollang;
+    getTexts(): TextItem[];
+    getTranslations(): Map<string, Translation>;
+    applyTranslations(targetLanguage: string, textIds?: string[]): Promise<number>;
+    private findSourceFileForUrl;
+    private replaceUrlInFile;
+    scanVideos(): Promise<VideoContent[]>;
+    scanImages(): Promise<ImageContent[]>;
+    scanAudios(): Promise<AudioContent[]>;
+    scanAll(): Promise<{
+        texts: TextItem[];
+        videos: VideoContent[];
+        images: ImageContent[];
+        audios: AudioContent[];
+        total: number;
+    }>;
+    translateVideo(video: VideoContent, targetLanguage: string, level?: number): Promise<string>;
+    translateImage(image: ImageContent, targetLanguage: string, level?: number): Promise<string>;
+    translateAudio(audio: AudioContent, targetLanguage: string, level?: number): Promise<string>;
+    private createInitialState;
+}