@wads.dev/i18n-editor 0.0.1-alpha.0

package/dist/server/exportProject.js

@@ -0,0 +1,277 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { resolveImportAlias } from '@wads.dev/i18n-ts/config';
+import { createTwoFilesPatch } from 'diff';
+import { buildExportPlan, buildTranslationOwners } from '../core/exportPlan.js';
+import { generateSourceFiles } from '../core/sourceFiles.js';
+import { createProjectContext } from './projectContext.js';
+async function readOptionalFile(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function assertInsideProject(projectDirectory, filePath) {
+    const absolutePath = path.resolve(projectDirectory, filePath);
+    const relativePath = path.relative(projectDirectory, absolutePath);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(`Refusing to write outside the project directory: ${filePath}`);
+    }
+    return absolutePath;
+}
+function readInterfaceName(content) {
+    return content?.match(/export\s+default\s+interface\s+([$A-Z_a-z][$\w]*)/)?.[1] || null;
+}
+function readLanguageTypeName(content) {
+    return content?.match(/export\s+type\s+([$A-Z_a-z][$\w]*)\s*=/)?.[1] || null;
+}
+function readPropertyTypes(content, ownerKeyPath) {
+    if (!content)
+        return {};
+    const sourceFile = ts.createSourceFile('base.ts', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const result = {};
+    const interfaceNode = sourceFile.statements.find((statement) => {
+        return ts.isInterfaceDeclaration(statement)
+            && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) === true;
+    });
+    if (!interfaceNode)
+        return result;
+    function visit(members, parentPath) {
+        members.forEach((member) => {
+            if (!ts.isPropertySignature(member) || !member.type || !member.name)
+                return;
+            const name = ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)
+                ? member.name.text
+                : member.name.getText(sourceFile);
+            const keyPath = parentPath ? `${parentPath}.${name}` : name;
+            if (ts.isTypeLiteralNode(member.type))
+                visit(member.type.members, keyPath);
+            else
+                result[keyPath] = member.type.getText(sourceFile);
+        });
+    }
+    visit(interfaceNode.members, ownerKeyPath);
+    return result;
+}
+function readTypeImports(content) {
+    if (!content)
+        return [];
+    const sourceFile = ts.createSourceFile('base.ts', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    return sourceFile.statements.flatMap((statement) => {
+        if (!ts.isImportDeclaration(statement)
+            || !statement.importClause?.name
+            || !ts.isStringLiteral(statement.moduleSpecifier))
+            return [];
+        return [{ name: statement.importClause.name.text, path: statement.moduleSpecifier.text }];
+    });
+}
+function readValueImports(content) {
+    if (!content)
+        return [];
+    const sourceFile = ts.createSourceFile('language.ts', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    return sourceFile.statements.flatMap((statement) => {
+        if (!ts.isImportDeclaration(statement)
+            || statement.importClause?.isTypeOnly
+            || !statement.importClause?.name
+            || !ts.isStringLiteral(statement.moduleSpecifier))
+            return [];
+        return [{ name: statement.importClause.name.text, path: statement.moduleSpecifier.text }];
+    });
+}
+function normalizeProjectPath(filePath) {
+    return filePath.replaceAll(path.sep, '/').replaceAll(/\/+/g, '/');
+}
+function resolveTypeImportPath(baseFilePath, importPath, config) {
+    let resolved;
+    if (importPath.startsWith('.')) {
+        resolved = path.posix.normalize(path.posix.join(path.posix.dirname(baseFilePath), importPath));
+    }
+    else {
+        resolved = resolveImportAlias(importPath, config.exportConfig.importAliases);
+        if (resolved === importPath)
+            return null;
+    }
+    return /\.[cm]?[jt]sx?$/.test(resolved) ? resolved : `${resolved}.ts`;
+}
+function isInsideDirectory(filePath, directory) {
+    return filePath === directory || filePath.startsWith(`${directory}/`);
+}
+function isIgnoredDeletionFile(filePath, deletion) {
+    return deletion.ignoredExtensions.includes(path.extname(filePath).toLowerCase());
+}
+async function listManagedFiles(directory) {
+    try {
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        const nested = await Promise.all(entries.map(async (entry) => {
+            const entryPath = path.join(directory, entry.name);
+            if (entry.isDirectory() && !entry.isSymbolicLink())
+                return listManagedFiles(entryPath);
+            return [entryPath];
+        }));
+        return nested.flat();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function removeEmptyDescendants(directory) {
+    let entries;
+    try {
+        entries = await fs.readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    await Promise.all(entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).map(async (entry) => {
+        const childPath = path.join(directory, entry.name);
+        await removeEmptyDescendants(childPath);
+        try {
+            await fs.rmdir(childPath);
+        }
+        catch (error) {
+            if (!['ENOTEMPTY', 'ENOENT'].includes(error.code || ''))
+                throw error;
+        }
+    }));
+}
+export async function planProjectExport(options = {}, state) {
+    const projectDirectory = path.resolve(options.projectDirectory ?? process.cwd());
+    const project = createProjectContext(options);
+    const info = await project.getInfo();
+    const config = state?.config ?? info.config;
+    const bundle = state?.bundle ?? info.bundle;
+    if (!config) {
+        throw new Error('Could not find i18n.config.json. Pass --config with the project configuration path.');
+    }
+    if (!bundle) {
+        throw new Error(`Could not find the bundle at ${info.bundlePath}. Run the bundle command first or pass --file.`);
+    }
+    const exportFiles = buildExportPlan(bundle, config);
+    const owners = buildTranslationOwners(bundle, config);
+    const managedDirectoryPaths = owners.map((owner) => {
+        return normalizeProjectPath(`${owner.directory}/${config.translationsDirectory}`);
+    });
+    const managedDirectories = managedDirectoryPaths.map((directory) => assertInsideProject(projectDirectory, directory));
+    const plannedPaths = new Set(exportFiles.map((file) => normalizeProjectPath(file.path)));
+    const existingInterfaceNames = {};
+    const existingPropertyTypes = {};
+    const existingTypeImports = {};
+    const existingValueImportOrder = {};
+    const baseContents = new Map();
+    await Promise.all(exportFiles.filter((file) => file.kind === 'base').map(async (file) => {
+        const content = await readOptionalFile(assertInsideProject(projectDirectory, file.path));
+        baseContents.set(file.path, content);
+        const name = readInterfaceName(content);
+        if (name)
+            existingInterfaceNames[file.path] = name;
+    }));
+    owners.forEach((owner) => {
+        const expectedPath = `${owner.directory}/${config.translationsDirectory}/base.ts`.replaceAll(/\/+/g, '/');
+        const baseFile = exportFiles.find((file) => file.kind === 'base' && file.path === expectedPath);
+        if (!baseFile)
+            return;
+        const content = baseContents.get(baseFile.path) || null;
+        const imports = readTypeImports(content);
+        const obsoleteTypeNames = new Set();
+        existingTypeImports[baseFile.path] = imports.filter((item) => {
+            const targetPath = resolveTypeImportPath(baseFile.path, item.path, config);
+            if (!targetPath)
+                return true;
+            if (plannedPaths.has(targetPath))
+                return false;
+            if (managedDirectoryPaths.some((directory) => isInsideDirectory(targetPath, directory))) {
+                obsoleteTypeNames.add(item.name);
+                return false;
+            }
+            return true;
+        });
+        const propertyTypes = readPropertyTypes(content, owner.keyPath);
+        Object.entries(propertyTypes).forEach(([key, type]) => {
+            const usesObsoleteType = [...obsoleteTypeNames].some((name) => new RegExp(`\\b${name}\\b`).test(type));
+            if (!usesObsoleteType)
+                existingPropertyTypes[key] = type;
+        });
+    });
+    await Promise.all(exportFiles.filter((file) => file.kind === 'language').map(async (file) => {
+        const content = await readOptionalFile(assertInsideProject(projectDirectory, file.path));
+        existingValueImportOrder[file.path] = readValueImports(content)
+            .map((item) => resolveTypeImportPath(file.path, item.path, config))
+            .filter((targetPath) => targetPath !== null && plannedPaths.has(targetPath));
+    }));
+    const catalogFile = info.catalogPath
+        ? path.relative(projectDirectory, info.catalogPath).replaceAll(path.sep, '/')
+        : config.catalogFile;
+    const existingCatalog = catalogFile
+        ? await readOptionalFile(assertInsideProject(projectDirectory, catalogFile))
+        : null;
+    const generatedFiles = generateSourceFiles(bundle, config, {
+        catalogFile,
+        existingInterfaceNames,
+        existingPropertyTypes,
+        existingTypeImports,
+        existingValueImportOrder,
+        existingLanguageTypeName: readLanguageTypeName(existingCatalog) || undefined,
+    });
+    const generatedChanges = await Promise.all(generatedFiles.map(async (file) => {
+        const absolutePath = assertInsideProject(projectDirectory, file.path);
+        const existing = await readOptionalFile(absolutePath);
+        const status = existing === null ? 'create' : existing === file.content ? 'unchanged' : 'modify';
+        return {
+            ...file,
+            absolutePath,
+            status,
+            diff: status === 'unchanged'
+                ? undefined
+                : createTwoFilesPatch(file.path, file.path, existing ?? '', file.content, existing === null ? 'missing' : 'current', 'generated', { context: 3 }),
+        };
+    }));
+    const generatedAbsolutePaths = new Set(generatedChanges.map((change) => change.absolutePath));
+    const existingManagedFiles = config.deletion === false
+        ? []
+        : (await Promise.all(managedDirectories.map(listManagedFiles))).flat();
+    const deletedChanges = [...new Set(existingManagedFiles)]
+        .filter((filePath) => !generatedAbsolutePaths.has(filePath))
+        .filter((filePath) => config.deletion !== false && !isIgnoredDeletionFile(filePath, config.deletion))
+        .map((absolutePath) => ({
+        kind: 'obsolete',
+        path: normalizeProjectPath(path.relative(projectDirectory, absolutePath)),
+        absolutePath,
+        status: 'delete',
+    }));
+    const changes = [...generatedChanges, ...deletedChanges]
+        .sort((left, right) => left.path.localeCompare(right.path));
+    return { projectDirectory, bundlePath: info.bundlePath, changes, managedDirectories, deletion: config.deletion };
+}
+export async function applyProjectExport(plan, options = {}) {
+    for (const change of plan.changes.filter((item) => item.status !== 'delete')) {
+        if (change.status === 'unchanged' || change.content === undefined)
+            continue;
+        await fs.mkdir(path.dirname(change.absolutePath), { recursive: true });
+        const temporaryPath = `${change.absolutePath}.i18n-editor-${process.pid}.tmp`;
+        try {
+            await fs.writeFile(temporaryPath, change.content, 'utf8');
+            await fs.rename(temporaryPath, change.absolutePath);
+        }
+        catch (error) {
+            await fs.rm(temporaryPath, { force: true });
+            throw error;
+        }
+    }
+    const shouldDelete = plan.deletion !== false
+        && (plan.deletion.autoDelete || options.deleteObsolete === true);
+    if (shouldDelete) {
+        for (const change of plan.changes.filter((item) => item.status === 'delete')) {
+            await fs.rm(change.absolutePath, { force: true, recursive: true });
+        }
+        await Promise.all(plan.managedDirectories.map(removeEmptyDescendants));
+    }
+}

package/dist/server/projectContext.d.ts

@@ -0,0 +1,11 @@
+import type { GenerateBundleResult, ProjectInfo } from '../core/projectApi.js';
+export type ProjectContextOptions = {
+    projectDirectory?: string;
+    configFile?: string;
+    catalogFile?: string;
+    bundleFile?: string;
+};
+export declare function createProjectContext(options?: ProjectContextOptions): {
+    getInfo: () => Promise<ProjectInfo>;
+    generateBundle: () => Promise<GenerateBundleResult>;
+};

package/dist/server/projectContext.js

@@ -0,0 +1,122 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseBundle } from '@wads.dev/i18n-ts/bundle';
+import { PROJECT_CONFIG_FORMAT, PROJECT_CONFIG_VERSION, } from '@wads.dev/i18n-ts/config';
+import { normalizeEditorProjectConfig } from '../core/projectConfig.js';
+const DEFAULT_CATALOG_CANDIDATES = [
+    'src/shared/i18n/index.ts',
+    'src/shared/i18n/translations/index.ts',
+    'src/i18n/index.ts',
+    'src/translations/index.ts',
+];
+async function isFile(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function resolveFromProject(projectDirectory, filePath) {
+    return path.resolve(projectDirectory, filePath);
+}
+async function readConfig(configPath) {
+    if (!await isFile(configPath))
+        return null;
+    const raw = JSON.parse(await fs.readFile(configPath, 'utf8'));
+    if (raw.format !== PROJECT_CONFIG_FORMAT || raw.version !== PROJECT_CONFIG_VERSION) {
+        throw new Error(`Invalid project configuration. Expected ${PROJECT_CONFIG_FORMAT} version ${PROJECT_CONFIG_VERSION}.`);
+    }
+    const config = normalizeEditorProjectConfig(raw);
+    const catalogFile = typeof raw.catalogFile === 'string' && raw.catalogFile.trim()
+        ? raw.catalogFile.trim()
+        : 'src/shared/i18n/index.ts';
+    return { ...config, catalogFile };
+}
+async function readBundle(bundlePath) {
+    if (!await isFile(bundlePath))
+        return null;
+    return parseBundle(await fs.readFile(bundlePath, 'utf8'));
+}
+async function findCatalogPath(projectDirectory, explicitCatalogFile, config) {
+    const candidates = [
+        explicitCatalogFile,
+        config?.catalogFile,
+        ...DEFAULT_CATALOG_CANDIDATES,
+    ].filter((candidate) => Boolean(candidate));
+    for (const candidate of candidates) {
+        const resolved = resolveFromProject(projectDirectory, candidate);
+        if (await isFile(resolved))
+            return resolved;
+    }
+    return null;
+}
+function getBundlerCliPath() {
+    const runtimeEntry = fileURLToPath(import.meta.resolve('@wads.dev/i18n-ts'));
+    return path.resolve(path.dirname(runtimeEntry), '../cli/exportBundle.js');
+}
+async function runBundler(projectDirectory, catalogPath, bundlePath) {
+    const bundlerCliPath = getBundlerCliPath();
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [
+            bundlerCliPath,
+            '--input', catalogPath,
+            '--output', bundlePath,
+        ], {
+            cwd: projectDirectory,
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.once('error', reject);
+        child.once('exit', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(stderr.trim() || `The bundle generator exited with code ${String(code)}.`));
+        });
+    });
+}
+export function createProjectContext(options = {}) {
+    const projectDirectory = path.resolve(options.projectDirectory ?? process.cwd());
+    const configPath = resolveFromProject(projectDirectory, options.configFile ?? 'i18n.config.json');
+    const bundlePath = resolveFromProject(projectDirectory, options.bundleFile ?? 'i18n.bundle.json');
+    let generation = null;
+    async function getInfo() {
+        const config = await readConfig(configPath);
+        const catalogPath = await findCatalogPath(projectDirectory, options.catalogFile, config);
+        return {
+            projectDirectory,
+            configPath: config ? configPath : null,
+            catalogPath,
+            bundlePath,
+            config,
+            bundle: await readBundle(bundlePath),
+            canGenerateBundle: catalogPath !== null,
+        };
+    }
+    async function generateBundle() {
+        if (generation)
+            return generation;
+        generation = (async () => {
+            const info = await getInfo();
+            if (!info.catalogPath) {
+                throw new Error('Could not find the TypeScript catalog. Set catalogFile in i18n.config.json or pass --input to the Editor.');
+            }
+            await runBundler(projectDirectory, info.catalogPath, bundlePath);
+            const bundle = await readBundle(bundlePath);
+            if (!bundle)
+                throw new Error('The bundle generator finished without creating the bundle file.');
+            return { bundle, bundlePath };
+        })().finally(() => {
+            generation = null;
+        });
+        return generation;
+    }
+    return { getInfo, generateBundle };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@wads.dev/i18n-editor",
+  "version": "0.0.1-alpha.0",
+  "description": "Local web editor for typed i18n projects.",
+  "license": "MIT",
+  "author": {
+    "name": "Wads.dev",
+    "url": "https://github.com/wads-dev"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wads-dev/i18n-editor.git"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "i18n-edit": "./dist/cli/index.js",
+    "i18n-editor": "./dist/cli/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "clean": "node ./scripts/clean-dist.mjs",
+    "check": "npm run check:node && npm run check:web",
+    "check:node": "tsc --project tsconfig.node.json --noEmit",
+    "check:web": "tsc --project tsconfig.web.json --noEmit",
+    "build": "npm run clean && tsc --project tsconfig.node.json && node ./scripts/build-web.mjs",
+    "start": "node ./dist/cli/index.js",
+    "prepack": "npm run check && npm run build"
+  },
+  "dependencies": {
+    "@fastify/static": "^10.1.0",
+    "@wads.dev/i18n-ts": "^0.0.1-alpha.1",
+    "commander": "^14.0.3",
+    "diff": "^9.0.0",
+    "fastify": "^5.10.0",
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "esbuild": "^0.28.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}