@mxml3gend/gloss 0.1.1 → 0.1.3

package/dist/server.js

@@ -3,9 +3,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import express from "express";
 import cors from "cors";
-import { readAllTranslations, writeAllTranslations } from "./fs.js";
+import { updateIssueBaseline } from "./baseline.js";
+import { runGlossCheck } from "./check.js";
+import { readAllTranslations, WriteLockError, writeAllTranslations } from "./fs.js";
+import { buildGitKeyDiff } from "./gitDiff.js";
+import { flattenObject, unflattenObject } from "./translationTree.js";
 import { buildKeyUsageMap } from "./usage.js";
 import { inferUsageRoot, scanUsage } from "./usageScanner.js";
+import { buildXliffDocument, parseXliffTargets } from "./xliff.js";
 import { renameKeyUsage } from "./renameKeyUsage.js";
 const resolveUiDistPath = () => {
     const runtimeDir = path.dirname(fileURLToPath(import.meta.url));
@@ -23,26 +28,175 @@ const resolveUiDistPath = () => {
     return null;
 };
 export function createServerApp(cfg) {
+    return createServerAppWithOptions(cfg);
+}
+const shouldBypassCache = (value) => {
+    if (typeof value !== "string") {
+        return false;
+    }
+    return value === "1" || value.toLowerCase() === "true";
+};
+export function createServerAppWithOptions(cfg, runtimeOptions = {}) {
     const app = express();
     app.use(cors());
     app.use(express.json({ limit: "5mb" }));
+    const defaultUseCache = runtimeOptions.useCache !== false;
+    const requestUseCache = (req) => {
+        if (!defaultUseCache) {
+            return false;
+        }
+        const noCacheValue = req.query.noCache;
+        if (Array.isArray(noCacheValue)) {
+            return !noCacheValue.some((entry) => shouldBypassCache(entry));
+        }
+        return !shouldBypassCache(noCacheValue);
+    };
     app.get("/api/config", (_req, res) => res.json(cfg));
     app.get("/api/translations", async (_req, res) => {
         const data = await readAllTranslations(cfg);
         res.json(data);
     });
     app.get("/api/usage", async (_req, res) => {
-        const usage = await scanUsage(inferUsageRoot(cfg), cfg.scan);
+        const usage = await scanUsage(inferUsageRoot(cfg), cfg.scan, {
+            useCache: requestUseCache(_req),
+        });
         res.json(usage);
     });
-    app.get("/api/key-usage", async (_req, res) => {
-        const usage = await buildKeyUsageMap(cfg);
+    app.get("/api/key-usage", async (req, res) => {
+        const usage = await buildKeyUsageMap(cfg, {
+            useCache: requestUseCache(req),
+        });
         res.json(usage);
     });
+    app.get("/api/check", async (req, res) => {
+        const result = await runGlossCheck(cfg, {
+            useCache: requestUseCache(req),
+        });
+        let baseline = null;
+        try {
+            baseline = await updateIssueBaseline(process.env.INIT_CWD || process.cwd(), result.summary);
+        }
+        catch {
+            baseline = null;
+        }
+        const summaryValue = typeof req.query.summary === "string" ? req.query.summary : "";
+        const summaryOnly = summaryValue === "1" || summaryValue === "true";
+        if (summaryOnly) {
+            res.json({
+                ok: result.ok,
+                generatedAt: result.generatedAt,
+                summary: result.summary,
+                hardcodedTexts: result.hardcodedTexts.slice(0, 20),
+                baseline,
+            });
+            return;
+        }
+        res.json({ ...result, baseline });
+    });
+    app.get("/api/git-diff", async (req, res) => {
+        const base = typeof req.query.base === "string" && req.query.base.trim()
+            ? req.query.base.trim()
+            : "origin/main";
+        const diff = await buildGitKeyDiff(cfg, base);
+        res.json(diff);
+    });
+    app.get("/api/xliff/export", async (req, res) => {
+        const locale = typeof req.query.locale === "string" ? req.query.locale.trim() : "";
+        const sourceLocale = typeof req.query.sourceLocale === "string" && req.query.sourceLocale.trim()
+            ? req.query.sourceLocale.trim()
+            : cfg.defaultLocale;
+        if (!locale || !cfg.locales.includes(locale)) {
+            res.status(400).json({
+                ok: false,
+                error: "Query parameter `locale` is required and must be one of configured locales.",
+            });
+            return;
+        }
+        if (!cfg.locales.includes(sourceLocale)) {
+            res.status(400).json({
+                ok: false,
+                error: "Query parameter `sourceLocale` must be one of configured locales when provided.",
+            });
+            return;
+        }
+        const data = await readAllTranslations(cfg);
+        const xml = buildXliffDocument({
+            translations: data,
+            locales: cfg.locales,
+            sourceLocale,
+            targetLocale: locale,
+        });
+        res.setHeader("Content-Type", "application/xliff+xml; charset=utf-8");
+        res.setHeader("Content-Disposition", `attachment; filename="gloss-${locale}.xlf"`);
+        res.send(xml);
+    });
+    app.post("/api/xliff/import", async (req, res) => {
+        const locale = typeof req.query.locale === "string" ? req.query.locale.trim() : "";
+        if (!locale || !cfg.locales.includes(locale)) {
+            res.status(400).json({
+                ok: false,
+                error: "Query parameter `locale` is required and must be one of configured locales.",
+            });
+            return;
+        }
+        const body = req.body;
+        if (typeof body.content !== "string" || body.content.trim().length === 0) {
+            res.status(400).json({
+                ok: false,
+                error: "Request body must include non-empty `content` string.",
+            });
+            return;
+        }
+        try {
+            const parsedTargets = parseXliffTargets(body.content);
+            const updates = Object.entries(parsedTargets).filter(([key]) => key.trim().length > 0);
+            if (updates.length === 0) {
+                res.status(400).json({
+                    ok: false,
+                    error: "No translatable units found in XLIFF content.",
+                });
+                return;
+            }
+            const data = await readAllTranslations(cfg);
+            const localeFlat = flattenObject(data[locale] ?? {});
+            for (const [key, value] of updates) {
+                localeFlat[key] = value;
+            }
+            data[locale] = unflattenObject(localeFlat);
+            await writeAllTranslations(cfg, data);
+            res.json({
+                ok: true,
+                locale,
+                updated: updates.length,
+            });
+        }
+        catch (error) {
+            if (error instanceof WriteLockError) {
+                res.status(409).json({ ok: false, error: error.message });
+                return;
+            }
+            res.status(400).json({
+                ok: false,
+                error: error.message || "Failed to parse XLIFF content.",
+            });
+        }
+    });
     app.post("/api/translations", async (req, res) => {
         const data = req.body;
-        await writeAllTranslations(cfg, data);
-        res.json({ ok: true });
+        try {
+            await writeAllTranslations(cfg, data);
+            res.json({ ok: true });
+        }
+        catch (error) {
+            if (error instanceof WriteLockError) {
+                res.status(409).json({ ok: false, error: error.message });
+                return;
+            }
+            res.status(500).json({
+                ok: false,
+                error: "Failed to write translation files.",
+            });
+        }
     });
     app.post("/api/rename-key", async (req, res) => {
         const body = req.body;
@@ -56,7 +210,7 @@ export function createServerApp(cfg) {
             return;
         }
         try {
-            const result = await renameKeyUsage(oldKey, newKey);
+            const result = await renameKeyUsage(oldKey, newKey, undefined, cfg.scan?.mode);
             res.json({ ok: true, ...result });
         }
         catch (error) {
@@ -81,8 +235,8 @@ export function createServerApp(cfg) {
     }
     return app;
 }
-export async function startServer(cfg, port = 5179) {
-    const app = createServerApp(cfg);
+export async function startServer(cfg, port = 5179, runtimeOptions = {}) {
+    const app = createServerAppWithOptions(cfg, runtimeOptions);
     const server = await new Promise((resolve) => {
         const nextServer = app.listen(port, () => resolve(nextServer));
     });

package/dist/translationKeys.js

@@ -1,4 +1,5 @@
 const TRANSLATION_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+const KEY_CHAR_PATTERN = /^[A-Za-z0-9._:/-]+$/;
 export const isLikelyTranslationKey = (value) => {
     const key = value.trim();
     if (key.length === 0 || key.length > 160) {
@@ -15,3 +16,22 @@ export const isLikelyTranslationKey = (value) => {
     }
     return TRANSLATION_KEY_PATTERN.test(key);
 };
+export const getInvalidTranslationKeyReason = (value) => {
+    const key = value.trim();
+    if (!key) {
+        return "Key is empty.";
+    }
+    if (key.startsWith(".") || key.endsWith(".")) {
+        return "Key cannot start or end with a dot.";
+    }
+    if (key.includes("..")) {
+        return "Key cannot contain consecutive dots.";
+    }
+    if (key.split(".").some((segment) => segment.trim() === "")) {
+        return "Key contains an empty segment.";
+    }
+    if (!KEY_CHAR_PATTERN.test(key)) {
+        return "Key contains unsupported characters.";
+    }
+    return null;
+};

package/dist/translationTree.js

@@ -0,0 +1,42 @@
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const flattenObject = (obj) => {
+    const result = {};
+    const visit = (node, path) => {
+        for (const [key, value] of Object.entries(node)) {
+            const nextPath = path ? `${path}.${key}` : key;
+            if (isPlainObject(value)) {
+                visit(value, nextPath);
+                continue;
+            }
+            if (typeof value === "string") {
+                result[nextPath] = value;
+                continue;
+            }
+            if (value !== undefined) {
+                result[nextPath] = String(value);
+            }
+        }
+    };
+    visit(obj, "");
+    return result;
+};
+export const unflattenObject = (flat) => {
+    const root = {};
+    for (const [key, value] of Object.entries(flat)) {
+        const parts = key.split(".").filter((part) => part.length > 0);
+        if (parts.length === 0) {
+            continue;
+        }
+        let cursor = root;
+        for (let index = 0; index < parts.length - 1; index += 1) {
+            const part = parts[index];
+            const existing = cursor[part];
+            if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+                cursor[part] = {};
+            }
+            cursor = cursor[part];
+        }
+        cursor[parts[parts.length - 1]] = value;
+    }
+    return root;
+};

package/dist/typegen.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readAllTranslations } from "./fs.js";
+import { flattenObject } from "./translationTree.js";
+const projectRoot = () => process.env.INIT_CWD || process.cwd();
+const renderTypeFile = (keys) => {
+    const keyUnion = keys.length === 0
+        ? "never"
+        : keys.map((key) => `  | ${JSON.stringify(key)}`).join("\n");
+    return `/* This file is auto-generated by Gloss. Do not edit manually. */
+
+export type I18nKey =
+${keyUnion};
+
+export type TranslateFn = (
+  key: I18nKey,
+  variables?: Record<string, string | number>,
+) => string;
+
+export type GlossI18nKey = I18nKey;
+`;
+};
+export async function generateKeyTypes(cfg, options = {}) {
+    const data = await readAllTranslations(cfg);
+    const keys = Array.from(new Set(Object.values(data).flatMap((tree) => Object.keys(flattenObject((tree ?? {})))))).sort((left, right) => left.localeCompare(right));
+    const outFile = path.resolve(projectRoot(), options.outFile ?? "i18n-keys.d.ts");
+    const content = renderTypeFile(keys);
+    await fs.writeFile(outFile, content, "utf8");
+    return { outFile, keyCount: keys.length };
+}