@mxml3gend/gloss 0.1.2 → 0.1.3

package/dist/config.js

@@ -33,6 +33,65 @@ const normalizeScanConfig = (value) => {
     }
     return { include, exclude, mode };
 };
+const DEFAULT_HARDCODED_MIN_LENGTH = 3;
+const DEFAULT_STRICT_PLACEHOLDERS = true;
+const normalizeStrictPlaceholders = (value) => {
+    if (value === undefined) {
+        return DEFAULT_STRICT_PLACEHOLDERS;
+    }
+    if (typeof value !== "boolean") {
+        throw new GlossConfigError("INVALID_CONFIG", "`strictPlaceholders` must be a boolean when provided.");
+    }
+    return value;
+};
+const normalizeHardcodedTextConfig = (value) => {
+    if (value === undefined) {
+        return {
+            enabled: true,
+            minLength: DEFAULT_HARDCODED_MIN_LENGTH,
+            excludePatterns: [],
+        };
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new GlossConfigError("INVALID_CONFIG", "`hardcodedText` must be an object when provided.");
+    }
+    const hardcodedText = value;
+    const enabled = typeof hardcodedText.enabled === "boolean" ? hardcodedText.enabled : true;
+    const minLength = typeof hardcodedText.minLength === "number" &&
+        Number.isFinite(hardcodedText.minLength) &&
+        hardcodedText.minLength >= 1
+        ? Math.floor(hardcodedText.minLength)
+        : DEFAULT_HARDCODED_MIN_LENGTH;
+    if (hardcodedText.minLength !== undefined &&
+        (typeof hardcodedText.minLength !== "number" ||
+            !Number.isFinite(hardcodedText.minLength) ||
+            hardcodedText.minLength < 1)) {
+        throw new GlossConfigError("INVALID_CONFIG", "`hardcodedText.minLength` must be a number >= 1 when provided.");
+    }
+    if (hardcodedText.excludePatterns !== undefined &&
+        !Array.isArray(hardcodedText.excludePatterns)) {
+        throw new GlossConfigError("INVALID_CONFIG", "`hardcodedText.excludePatterns` must be a string array when provided.");
+    }
+    const excludePatterns = Array.isArray(hardcodedText.excludePatterns)
+        ? hardcodedText.excludePatterns
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)
+        : [];
+    for (const pattern of excludePatterns) {
+        try {
+            void new RegExp(pattern);
+        }
+        catch {
+            throw new GlossConfigError("INVALID_CONFIG", `Invalid regex in hardcodedText.excludePatterns: ${pattern}`);
+        }
+    }
+    return {
+        enabled,
+        minLength,
+        excludePatterns,
+    };
+};
 const CONFIG_FILE_NAMES = [
     "gloss.config.ts",
     "gloss.config.mts",
@@ -95,7 +154,7 @@ const discoverLocales = async (cwd, localesPath) => {
         return [];
     }
 };
-const discoverLocaleDirectoryCandidates = async (cwd) => {
+const discoverLocaleDirectoryCandidatesInternal = async (cwd) => {
     const candidates = [];
     const visit = async (directory) => {
         const entries = await fs.readdir(directory, { withFileTypes: true });
@@ -129,7 +188,7 @@ const discoverLocaleDirectoryCandidates = async (cwd) => {
     await visit(cwd);
     return candidates;
 };
-const selectLocaleDirectoryCandidate = (candidates, preferredLocales) => {
+const scoreLocaleDirectoryCandidates = (candidates, preferredLocales) => {
     const scored = candidates.map((candidate) => {
         const localeMatches = preferredLocales.filter((locale) => candidate.locales.includes(locale));
         const allPreferredMatch = preferredLocales.length > 0 &&
@@ -157,7 +216,10 @@ const selectLocaleDirectoryCandidate = (candidates, preferredLocales) => {
         }
         return left.candidate.directoryPath.localeCompare(right.candidate.directoryPath);
     });
-    return scored[0]?.candidate;
+    return scored;
+};
+const selectLocaleDirectoryCandidate = (candidates, preferredLocales) => {
+    return scoreLocaleDirectoryCandidates(candidates, preferredLocales)[0]?.candidate;
 };
 const resolveDiscoveredPath = (cwd, directoryPath) => {
     const relative = path.relative(cwd, directoryPath);
@@ -188,6 +250,17 @@ const normalizeLoadedConfig = (value) => {
     }
     return value;
 };
+export async function discoverLocaleDirectoryCandidates(cwdInput) {
+    const cwd = cwdInput ?? process.env.INIT_CWD ?? process.cwd();
+    const candidates = await discoverLocaleDirectoryCandidatesInternal(cwd);
+    const scored = scoreLocaleDirectoryCandidates(candidates, []);
+    return scored.map(({ candidate, score }) => ({
+        path: resolveDiscoveredPath(cwd, candidate.directoryPath),
+        locales: candidate.locales,
+        depth: candidate.depth,
+        score,
+    }));
+}
 export async function loadGlossConfig() {
     const cwd = process.env.INIT_CWD || process.cwd();
     const configPath = await resolveConfigPath(cwd);
@@ -218,7 +291,7 @@ export async function loadGlossConfig() {
         const configuredPath = typeof cfg.path === "string" ? cfg.path.trim() : "";
         const discoveredDirectoryCandidate = configuredPath
             ? null
-            : selectLocaleDirectoryCandidate(await discoverLocaleDirectoryCandidates(cwd), configuredLocales);
+            : selectLocaleDirectoryCandidate(await discoverLocaleDirectoryCandidatesInternal(cwd), configuredLocales);
         const translationsPath = configuredPath
             ? configuredPath
             : discoveredDirectoryCandidate
@@ -253,7 +326,9 @@ export async function loadGlossConfig() {
             defaultLocale,
             path: translationsPath,
             format: "json",
+            strictPlaceholders: normalizeStrictPlaceholders(cfg.strictPlaceholders),
             scan: normalizeScanConfig(cfg.scan),
+            hardcodedText: normalizeHardcodedTextConfig(cfg.hardcodedText),
         };
     }
     catch (e) {

package/dist/fs.js

@@ -1,5 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+const DEFAULT_WRITE_LOCK_TIMEOUT_MS = 4_000;
+const DEFAULT_WRITE_LOCK_RETRY_MS = 50;
+const WRITE_LOCK_FILE_NAME = ".gloss-write.lock";
+export class WriteLockError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WriteLockError";
+    }
+}
 function projectRoot() {
     return process.env.INIT_CWD || process.cwd();
 }
@@ -12,6 +21,77 @@ function translationsDir(cfg) {
 function localeFile(cfg, locale) {
     return path.join(translationsDir(cfg), `${locale}.json`);
 }
+const compareKeys = (left, right) => {
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+};
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const sortTranslationTree = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sortTranslationTree(entry));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const sorted = {};
+    const entries = Object.entries(value).sort(([leftKey], [rightKey]) => compareKeys(leftKey, rightKey));
+    for (const [key, entryValue] of entries) {
+        sorted[key] = sortTranslationTree(entryValue);
+    }
+    return sorted;
+};
+const sleep = (durationMs) => new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+});
+const parsePositiveInteger = (value, fallback) => {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return parsed;
+};
+const writeLockTimeoutMs = () => parsePositiveInteger(process.env.GLOSS_WRITE_LOCK_TIMEOUT_MS, DEFAULT_WRITE_LOCK_TIMEOUT_MS);
+const writeLockRetryMs = () => parsePositiveInteger(process.env.GLOSS_WRITE_LOCK_RETRY_MS, DEFAULT_WRITE_LOCK_RETRY_MS);
+const withTranslationsWriteLock = async (dir, run) => {
+    await fs.mkdir(dir, { recursive: true });
+    const lockFilePath = path.join(dir, WRITE_LOCK_FILE_NAME);
+    const timeoutMs = writeLockTimeoutMs();
+    const retryMs = writeLockRetryMs();
+    const startTime = Date.now();
+    let lockHandle = null;
+    while (!lockHandle) {
+        try {
+            lockHandle = await fs.open(lockFilePath, "wx");
+        }
+        catch (error) {
+            const errno = error;
+            if (errno.code !== "EEXIST") {
+                throw error;
+            }
+            if (Date.now() - startTime >= timeoutMs) {
+                throw new WriteLockError("Could not save translations because another Gloss save is in progress. Try again.");
+            }
+            await sleep(retryMs);
+        }
+    }
+    try {
+        return await run();
+    }
+    finally {
+        await lockHandle.close().catch(() => undefined);
+        await fs.unlink(lockFilePath).catch(() => undefined);
+    }
+};
 export async function readAllTranslations(cfg) {
     const out = {};
     for (const locale of cfg.locales) {
@@ -28,10 +108,29 @@ export async function readAllTranslations(cfg) {
 }
 export async function writeAllTranslations(cfg, data) {
     const dir = translationsDir(cfg);
-    await fs.mkdir(dir, { recursive: true });
-    for (const locale of cfg.locales) {
-        const file = localeFile(cfg, locale);
-        const json = JSON.stringify(data[locale] ?? {}, null, 2) + "\n";
-        await fs.writeFile(file, json, "utf8");
-    }
+    await withTranslationsWriteLock(dir, async () => {
+        const serialized = cfg.locales.map((locale) => {
+            return {
+                locale,
+                filePath: localeFile(cfg, locale),
+                json: JSON.stringify(sortTranslationTree(data[locale] ?? {}), null, 2) + "\n",
+            };
+        });
+        const operationId = `${Date.now()}-${process.pid}`;
+        const tempFiles = [];
+        try {
+            for (const entry of serialized) {
+                const tempPath = `${entry.filePath}.tmp-${operationId}-${entry.locale}`;
+                await fs.writeFile(tempPath, entry.json, "utf8");
+                tempFiles.push(tempPath);
+            }
+            for (let index = 0; index < serialized.length; index += 1) {
+                await fs.rename(tempFiles[index], serialized[index].filePath);
+            }
+        }
+        catch (error) {
+            await Promise.allSettled(tempFiles.map((filePath) => fs.unlink(filePath)));
+            throw error;
+        }
+    });
 }

package/dist/hooks.js

@@ -0,0 +1,101 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+const GLOSS_HOOK_MARKER = "# gloss-pre-commit";
+const GLOSS_HUSKY_MARKER = "# gloss-husky-hook";
+const GLOSS_HOOK_COMMAND = "npx gloss check --format human";
+const fileExists = async (filePath) => {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const resolveGitDir = (projectDir) => {
+    try {
+        const raw = execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: projectDir,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+        }).trim();
+        if (!raw) {
+            return null;
+        }
+        if (path.isAbsolute(raw)) {
+            return raw;
+        }
+        return path.resolve(projectDir, raw);
+    }
+    catch {
+        return null;
+    }
+};
+const writeExecutable = async (filePath, content) => {
+    await fs.writeFile(filePath, content, "utf8");
+    await fs.chmod(filePath, 0o755);
+};
+const installGitHook = async (hookPath) => {
+    const nextSnippet = `\n${GLOSS_HOOK_MARKER}\n${GLOSS_HOOK_COMMAND}\n`;
+    if (!(await fileExists(hookPath))) {
+        await writeExecutable(hookPath, `#!/bin/sh\nset -e${nextSnippet}`);
+        return "created";
+    }
+    const existing = await fs.readFile(hookPath, "utf8");
+    if (existing.includes(GLOSS_HOOK_MARKER) || existing.includes(GLOSS_HOOK_COMMAND)) {
+        return "skipped";
+    }
+    const suffix = existing.endsWith("\n") ? nextSnippet : `\n${nextSnippet}`;
+    await writeExecutable(hookPath, `${existing}${suffix}`);
+    return "updated";
+};
+const installHuskyHook = async (huskyDirectoryPath) => {
+    if (!(await fileExists(huskyDirectoryPath))) {
+        return "missing";
+    }
+    const hookPath = path.join(huskyDirectoryPath, "pre-commit");
+    const huskyBootstrapPath = path.join(huskyDirectoryPath, "_", "husky.sh");
+    const huskyBootstrapLine = `. "$(dirname -- "$0")/_/husky.sh"`;
+    const nextSnippet = `\n${GLOSS_HUSKY_MARKER}\n${GLOSS_HOOK_COMMAND}\n`;
+    if (!(await fileExists(hookPath))) {
+        const bootstrap = (await fileExists(huskyBootstrapPath))
+            ? `${huskyBootstrapLine}\n\n`
+            : "";
+        await writeExecutable(hookPath, `#!/usr/bin/env sh\n${bootstrap}${nextSnippet}`);
+        return "created";
+    }
+    const existing = await fs.readFile(hookPath, "utf8");
+    if (existing.includes(GLOSS_HUSKY_MARKER) || existing.includes(GLOSS_HOOK_COMMAND)) {
+        return "skipped";
+    }
+    const suffix = existing.endsWith("\n") ? nextSnippet : `\n${nextSnippet}`;
+    await writeExecutable(hookPath, `${existing}${suffix}`);
+    return "updated";
+};
+export async function installPreCommitHooks(projectDir, options) {
+    const messages = [];
+    const gitDir = options?.gitDirPath === undefined
+        ? resolveGitDir(projectDir)
+        : options.gitDirPath;
+    let gitHook = "missing";
+    if (gitDir) {
+        const hooksDir = path.join(gitDir, "hooks");
+        await fs.mkdir(hooksDir, { recursive: true });
+        gitHook = await installGitHook(path.join(hooksDir, "pre-commit"));
+        messages.push(`.git hook: ${gitHook}`);
+    }
+    else {
+        messages.push(".git hook: missing (not a git repository)");
+    }
+    const huskyHook = await installHuskyHook(path.join(projectDir, ".husky"));
+    messages.push(`husky hook: ${huskyHook}`);
+    if (gitHook === "missing" && huskyHook === "missing") {
+        messages.push("No hook target found. Initialize git or husky first.");
+    }
+    return {
+        gitHook,
+        huskyHook,
+        messages,
+    };
+}