gtx-cli 2.5.2 → 2.5.4

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # gtx-cli
 
+## 2.5.4
+
+### Patch Changes
+
+- [#807](https://github.com/generaltranslation/gt/pull/807) [`293a5a3`](https://github.com/generaltranslation/gt/commit/293a5a3ceba2321eed7b1271ca955331995f40a7) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Add handling of shared static assets
+
+## 2.5.3
+
+### Patch Changes
+
+- Updated dependencies [[`f98c504`](https://github.com/generaltranslation/gt/commit/f98c504f1e025024b3e1e5e16a0271e86ed095fa)]:
+  - generaltranslation@8.0.1
+
 ## 2.5.2
 
 ### Patch Changes

package/dist/cli/base.js

@@ -21,6 +21,7 @@ import { getDownloaded, clearDownloaded } from '../state/recentDownloads.js';
 import updateConfig from '../fs/config/updateConfig.js';
 import { createLoadTranslationsFile } from '../fs/createLoadTranslationsFile.js';
 import { saveLocalEdits } from '../api/saveLocalEdits.js';
+import processSharedStaticAssets from '../utils/sharedStaticAssets.js';
 export class BaseCLI {
     library;
     additionalModules;
@@ -79,6 +80,8 @@ export class BaseCLI {
     }
     async handleStage(initOptions) {
         const settings = await generateSettings(initOptions);
+        // Preprocess shared static assets if configured (move + rewrite sources)
+        await processSharedStaticAssets(settings);
         if (!settings.stageTranslations) {
             // Update settings.stageTranslations to true
             settings.stageTranslations = true;
@@ -91,6 +94,8 @@ export class BaseCLI {
     }
     async handleTranslate(initOptions) {
         const settings = await generateSettings(initOptions);
+        // Preprocess shared static assets if configured (move + rewrite sources)
+        await processSharedStaticAssets(settings);
         if (!settings.stageTranslations) {
             const results = await handleStage(initOptions, settings, this.library, false);
             if (results) {

package/dist/types/index.d.ts

@@ -134,6 +134,7 @@ export type Settings = {
     modelProvider?: string;
     parsingOptions: ParsingConfigOptions;
     branchOptions: BranchOptions;
+    sharedStaticAssets?: SharedStaticAssetsConfig;
 };
 export type BranchOptions = {
     currentBranch?: string;
@@ -163,6 +164,11 @@ export type AdditionalOptions = {
     experimentalFlattenJsonFiles?: boolean;
     baseDomain?: string;
 };
+export type SharedStaticAssetsConfig = {
+    include: string | string[];
+    outDir: string;
+    publicPath?: string;
+};
 export type JsonSchema = {
     preset?: 'mintlify';
     include?: string[];

package/dist/utils/sharedStaticAssets.d.ts

@@ -0,0 +1,2 @@
+import type { Settings } from '../types/index.js';
+export default function processSharedStaticAssets(settings: Settings): Promise<void>;

package/dist/utils/sharedStaticAssets.js

@@ -0,0 +1,274 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import fg from 'fast-glob';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMdx from 'remark-mdx';
+import remarkFrontmatter from 'remark-frontmatter';
+import remarkStringify from 'remark-stringify';
+import { visit } from 'unist-util-visit';
+import escapeHtmlInTextNodes from 'gt-remark';
+function derivePublicPath(outDir, provided) {
+    if (provided)
+        return provided;
+    const norm = outDir.replace(/\\/g, '/');
+    if (norm.startsWith('public/'))
+        return '/' + norm.slice('public/'.length);
+    if (norm.startsWith('static/'))
+        return '/' + norm.slice('static/'.length);
+    if (norm.startsWith('/'))
+        return norm; // already absolute URL path
+    return '/' + path.basename(norm);
+}
+function toArray(val) {
+    if (!val)
+        return [];
+    return Array.isArray(val) ? val : [val];
+}
+async function ensureDir(dir) {
+    await fs.promises.mkdir(dir, { recursive: true });
+}
+async function moveFile(src, dest) {
+    if (src === dest)
+        return;
+    try {
+        await ensureDir(path.dirname(dest));
+        await fs.promises.rename(src, dest);
+    }
+    catch (err) {
+        // Fallback to copy+unlink for cross-device or existing files
+        if (err &&
+            (err.code === 'EXDEV' ||
+                err.code === 'EEXIST' ||
+                err.code === 'ENOTEMPTY')) {
+            const data = await fs.promises.readFile(src);
+            await ensureDir(path.dirname(dest));
+            await fs.promises.writeFile(dest, data);
+            try {
+                await fs.promises.unlink(src);
+            }
+            catch { }
+        }
+        else if (err && err.code === 'ENOENT') {
+            // already moved or missing; ignore
+            return;
+        }
+        else {
+            throw err;
+        }
+    }
+}
+async function pathExists(p) {
+    try {
+        await fs.promises.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirEmpty(dir) {
+    try {
+        const entries = await fs.promises.readdir(dir);
+        return entries.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function removeEmptyDirsUpwards(startDir, stopDir) {
+    let current = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (current.startsWith(stop)) {
+        if (current === stop)
+            break;
+        const exists = await pathExists(current);
+        if (!exists)
+            break;
+        const empty = await isDirEmpty(current);
+        if (!empty)
+            break;
+        try {
+            await fs.promises.rmdir(current);
+        }
+        catch {
+            break;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+}
+function stripQueryAndHash(url) {
+    const match = url.match(/^[^?#]+/);
+    const base = match ? match[0] : url;
+    const suffix = url.slice(base.length);
+    return { base, suffix };
+}
+function rewriteMdxContent(content, filePath, pathMap) {
+    let changed = false;
+    let ast;
+    try {
+        const processor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        ast = processor.runSync(processor.parse(content));
+    }
+    catch (e) {
+        return { content, changed: false };
+    }
+    const fileDir = path.dirname(filePath);
+    // Helper to resolve and possibly rewrite a URL
+    const maybeRewrite = (url) => {
+        if (!url ||
+            /^(https?:)?\/\//i.test(url) ||
+            url.startsWith('data:') ||
+            url.startsWith('#') ||
+            url.startsWith('mailto:') ||
+            url.startsWith('tel:')) {
+            return null;
+        }
+        const { base, suffix } = stripQueryAndHash(url);
+        // Only handle relative paths
+        if (base.startsWith('/'))
+            return null;
+        const abs = path.resolve(fileDir, base);
+        const normAbs = path.normalize(abs);
+        const mapped = pathMap.get(normAbs);
+        if (mapped) {
+            changed = true;
+            return mapped + suffix;
+        }
+        return null;
+    };
+    visit(ast, (node) => {
+        // Markdown image: ![alt](url)
+        if (node.type === 'image' && typeof node.url === 'string') {
+            const newUrl = maybeRewrite(node.url);
+            if (newUrl)
+                node.url = newUrl;
+            return;
+        }
+        // Markdown link: [text](url) — useful for PDFs and other downloadable assets
+        if (node.type === 'link' && typeof node.url === 'string') {
+            const newUrl = maybeRewrite(node.url);
+            if (newUrl)
+                node.url = newUrl;
+            return;
+        }
+        // MDX <img src="..." />
+        if ((node.type === 'mdxJsxFlowElement' ||
+            node.type === 'mdxJsxTextElement') &&
+            Array.isArray(node.attributes)) {
+            for (const attr of node.attributes) {
+                if (attr &&
+                    attr.type === 'mdxJsxAttribute' &&
+                    (attr.name === 'src' || attr.name === 'href') &&
+                    typeof attr.value === 'string') {
+                    const newUrl = maybeRewrite(attr.value);
+                    if (newUrl)
+                        attr.value = newUrl;
+                }
+            }
+        }
+    });
+    try {
+        const s = unified()
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx)
+            .use(escapeHtmlInTextNodes)
+            .use(remarkStringify, {
+            handlers: {
+                text(node) {
+                    return node.value;
+                },
+            },
+        });
+        const outTree = s.runSync(ast);
+        let out = s.stringify(outTree);
+        // Preserve trailing/leading newlines similar to localizeStaticUrls
+        if (out.endsWith('\n') && !content.endsWith('\n'))
+            out = out.slice(0, -1);
+        if (content.startsWith('\n') && !out.startsWith('\n'))
+            out = '\n' + out;
+        return { content: out, changed };
+    }
+    catch (e) {
+        return { content, changed: false };
+    }
+}
+export default async function processSharedStaticAssets(settings) {
+    const cfg = settings.sharedStaticAssets;
+    if (!cfg)
+        return;
+    const cwd = process.cwd();
+    const include = toArray(cfg.include);
+    if (include.length === 0)
+        return;
+    // Resolve assets
+    const assetPaths = new Set();
+    for (let pattern of include) {
+        // Treat leading '/' as repo-relative, not filesystem root
+        if (pattern.startsWith('/'))
+            pattern = pattern.slice(1);
+        const matches = fg.sync(path.resolve(cwd, pattern), { absolute: true });
+        for (const m of matches)
+            assetPaths.add(path.normalize(m));
+    }
+    if (assetPaths.size === 0)
+        return;
+    const outDirInput = cfg.outDir.startsWith('/')
+        ? cfg.outDir.slice(1)
+        : cfg.outDir;
+    const outDirAbs = path.resolve(cwd, outDirInput);
+    const publicPath = derivePublicPath(outDirInput, cfg.publicPath);
+    // Map original absolute path -> public URL
+    const originalToPublic = new Map();
+    for (const abs of assetPaths) {
+        const relFromRoot = path.relative(cwd, abs).replace(/\\/g, '/');
+        const publicUrl = (publicPath.endsWith('/') ? publicPath.slice(0, -1) : publicPath) +
+            '/' +
+            relFromRoot;
+        originalToPublic.set(path.normalize(abs), publicUrl);
+    }
+    // Move assets to outDir, preserving relative structure
+    for (const abs of assetPaths) {
+        const relFromRoot = path.relative(cwd, abs);
+        const destAbs = path.resolve(outDirAbs, relFromRoot);
+        // Skip if already in destination
+        if (path.normalize(abs) === path.normalize(destAbs))
+            continue;
+        // If destination exists, assume already moved
+        try {
+            const st = await fs.promises.stat(destAbs).catch(() => null);
+            if (st && st.isFile()) {
+                // Remove source if it still exists
+                await fs.promises.unlink(abs).catch(() => { });
+                await removeEmptyDirsUpwards(path.dirname(abs), cwd);
+                continue;
+            }
+        }
+        catch { }
+        await moveFile(abs, destAbs);
+        await removeEmptyDirsUpwards(path.dirname(abs), cwd);
+    }
+    // Rewrite references in default-locale files we send for translation
+    const resolved = settings.files?.resolvedPaths || {};
+    const mdFiles = [...(resolved.mdx || []), ...(resolved.md || [])];
+    await Promise.all(mdFiles.map(async (filePath) => {
+        // only rewrite existing files
+        const exists = await fs.promises
+            .stat(filePath)
+            .then(() => true)
+            .catch(() => false);
+        if (!exists)
+            return;
+        const orig = await fs.promises.readFile(filePath, 'utf8');
+        const { content: out, changed } = rewriteMdxContent(orig, filePath, originalToPublic);
+        if (changed) {
+            await fs.promises.writeFile(filePath, out, 'utf8');
+        }
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -93,7 +93,7 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "generaltranslation": "8.0.0"
+    "generaltranslation": "8.0.1"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",