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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wads.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# @wads.dev/i18n-editor
+
+Local web editor for typed i18n projects.
+
+This first alpha compiles the existing browser editor and its reusable operations from TypeScript, then serves the generated application through a local Fastify server.
+
+> Status: `0.0.1-alpha.0`. The package is under active development and has not been published to npm yet.
+
+## Wads i18n ecosystem
+
+| Project | Responsibility |
+| --- | --- |
+| [`@wads.dev/i18n-ts`](https://github.com/wads-dev/i18n-ts) | Framework-independent contracts, language loading, project configuration and portable bundles. |
+| [`@wads.dev/i18n-react`](https://github.com/wads-dev/i18n-react) | Optional React Provider, hooks and rich translation rendering. |
+| [`@wads.dev/i18n-editor`](https://github.com/wads-dev/i18n-editor) | Local bundle and project editor. This repository. |
+
+The Editor consumes the bundle and `i18n.config.json` formats defined by `i18n-ts`. It is framework-independent: React projects may use `i18n-react`, but the Editor does not require it.
+
+## Development
+
+```sh
+npm install
+npm run check
+npm run build
+```
+
+Run the generated executable from this repository:
+
+```sh
+./dist/cli/index.js
+```
+
+Or run it from a consuming project that keeps the repository under `wads.dev/i18n-editor`:
+
+```sh
+./wads.dev/i18n-editor/dist/cli/index.js
+```
+
+The default address is `http://127.0.0.1:4173`. Override it when needed:
+
+```sh
+./wads.dev/i18n-editor/dist/cli/index.js --port 4300
+```
+
+The current directory is the project root. On startup, the server reads `i18n.config.json` and `i18n.bundle.json`. If the bundle does not exist, it uses `catalogFile` from the configuration to generate it automatically. Paths can be overridden explicitly:
+
+```sh
+./wads.dev/i18n-editor/dist/cli/index.js \
+  --project . \
+  --config i18n.config.json \
+  --input src/shared/i18n/index.ts \
+  --bundle i18n.bundle.json
+```
+
+## CLI commands
+
+Generate the default `i18n.bundle.json` without starting the server:
+
+```sh
+i18n-edit bundle
+i18n-edit bundle --output review.bundle.json
+```
+
+Print the same generated-file preview used by the Web Editor, enriched with the current filesystem state:
+
+```sh
+i18n-edit preview
+i18n-edit preview --file review.bundle.json
+```
+
+Preview is read-only. It resolves the bundle and `i18n.config.json`, then classifies every managed path as unchanged, modified, new or deleted. New paths are green, modified paths are yellow and files that exist inside a managed `i18n` directory but are absent from the generation plan are red. Unified diffs for new and modified files are shown by default; use `--no-diff` for the compact file list. Deleted files never print their full removed contents.
+
+Plan the source files generated from a bundle:
+
+```sh
+i18n-edit export
+i18n-edit export --file review.bundle.json
+```
+
+The export command shows the same status and unified-diff preview before asking for confirmation. Divergent files are warnings and remain preserved unless the project enables `deletion.autoDelete` or the command explicitly receives `--delete`. Use `--no-diff` for the compact plan, and use `--yes` or `-y` only in automation or after reviewing the plan:
+
+```sh
+i18n-edit export --file review.bundle.json --delete
+i18n-edit export --file review.bundle.json --delete --yes
+```
+
+Generate a fresh bundle and immediately apply its export plan with one command:
+
+```sh
+i18n-edit sync
+i18n-edit sync --output review.bundle.json
+```
+
+`sync` is equivalent to running `bundle` followed by `export` with the same bundle path. It preserves the export confirmation and accepts `--yes`, `--delete` and `--no-diff` when automation is intentional.
+
+Each configured `i18n` directory is checked against the generated plan. Generated `base.ts`, language files and the configured root catalog are written; other files become deletion candidates unless their extensions are ignored by project configuration. Set `deletion` to `false` to disable this detection entirely. Files outside configured `i18n` directories are never candidates. Writes are restricted to the selected project directory and use a temporary file followed by an atomic rename.
+
+After the npm package is published, its binaries will be named `i18n-edit` and `i18n-editor`.
+
+The shortest npm invocation will be:
+
+```sh
+npx @wads.dev/i18n-editor
+```
+
+The explicit binary form will also be available:
+
+```sh
+npm exec --package=@wads.dev/i18n-editor -- i18n-edit
+```
+
+Because the npm package is scoped, `npx i18n-editor` would refer to a different, unscoped package. Use the scoped command above.
+
+## Current boundary
+
+The server reads project configuration and bundles through `GET /api/project`. It can generate a missing bundle through `POST /api/bundle`; this is currently its only project write. The Web Editor can explicitly request a read-only filesystem comparison through `POST /api/export-preview`. Source regeneration is available explicitly through the CLI `export` command and is not exposed as a browser route yet.

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import { createRequire } from 'node:module';
+import { Command, InvalidArgumentError } from 'commander';
+import { createServer } from '../server/createServer.js';
+import { applyProjectExport, planProjectExport } from '../server/exportProject.js';
+import { createProjectContext } from '../server/projectContext.js';
+function parsePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+        throw new InvalidArgumentError('Port must be an integer between 0 and 65535.');
+    }
+    return port;
+}
+function getProjectOptions(command, bundleFile) {
+    const options = command.optsWithGlobals();
+    return {
+        projectDirectory: options.project,
+        configFile: options.config,
+        catalogFile: options.input,
+        bundleFile,
+    };
+}
+function printExportPlan(plan, showDiff) {
+    const created = plan.changes.filter((change) => change.status === 'create').length;
+    const modified = plan.changes.filter((change) => change.status === 'modify').length;
+    const unchanged = plan.changes.filter((change) => change.status === 'unchanged').length;
+    const deleted = plan.changes.filter((change) => change.status === 'delete').length;
+    console.log(`Export plan from ${plan.bundlePath}`);
+    printPreview(plan, showDiff);
+    console.log(`${created} files to create, ${modified} to overwrite, ${deleted} to delete, ${unchanged} unchanged.`);
+    return { writeCount: created + modified, deletionCount: deleted };
+}
+function colorize(value, color) {
+    if (!process.stdout.isTTY)
+        return value;
+    const code = color === 'green' ? 32 : color === 'red' ? 31 : 33;
+    return `\u001B[${code}m${value}\u001B[0m`;
+}
+function colorizeDiff(diff) {
+    if (!process.stdout.isTTY)
+        return diff;
+    return diff.split('\n').map((line) => {
+        if (line.startsWith('+++') || line.startsWith('---') || line.startsWith('@@')) {
+            return colorize(line, 'yellow');
+        }
+        if (line.startsWith('+'))
+            return colorize(line, 'green');
+        if (line.startsWith('-'))
+            return colorize(line, 'red');
+        return line;
+    }).join('\n');
+}
+function printPreview(plan, showDiff) {
+    plan.changes.forEach((change) => {
+        if (change.status === 'create')
+            console.log(colorize(`+ new       ${change.path}`, 'green'));
+        else if (change.status === 'delete')
+            console.log(colorize(`- delete    ${change.path}`, 'red'));
+        else if (change.status === 'modify')
+            console.log(colorize(`~ modified  ${change.path}`, 'yellow'));
+        else
+            console.log(`  unchanged ${change.path}`);
+    });
+    const deletionCount = plan.changes.filter((change) => change.status === 'delete').length;
+    if (deletionCount > 0) {
+        const warning = plan.deletion !== false && plan.deletion.autoDelete
+            ? `Warning: ${deletionCount} divergent file${deletionCount === 1 ? '' : 's'} will be deleted during export because deletion.autoDelete is enabled.`
+            : `Warning: ${deletionCount} deletion candidate${deletionCount === 1 ? '' : 's'} detected. They will be preserved unless export runs with --delete.`;
+        console.log(`\n${colorize(warning, 'yellow')}`);
+    }
+    if (!showDiff)
+        return;
+    plan.changes.forEach((change) => {
+        if (!change.diff || change.status === 'delete')
+            return;
+        console.log(`\n${colorize(`diff ${change.path}`, 'yellow')}`);
+        process.stdout.write(colorizeDiff(change.diff));
+    });
+}
+async function confirmExport(deletionCount) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('Confirmation requires an interactive terminal. Re-run with --yes to apply non-interactively.');
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const deletionMessage = deletionCount > 0 ? ` and delete ${deletionCount} divergent file${deletionCount === 1 ? '' : 's'}` : '';
+        const answer = await prompt.question(`Apply this export plan${deletionMessage}? [y/N] `);
+        return /^(y|yes)$/i.test(answer.trim());
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function generateBundle(command, output) {
+    const projectOptions = getProjectOptions(command, output);
+    const result = await createProjectContext(projectOptions).generateBundle();
+    console.log(`i18n bundle created at ${result.bundlePath}`);
+    console.log(`${Object.keys(result.bundle.languages).length} languages exported.`);
+}
+async function exportBundle(command, options) {
+    const plan = await planProjectExport(getProjectOptions(command, options.file));
+    const { writeCount, deletionCount } = printExportPlan(plan, options.diff);
+    const deleteObsolete = plan.deletion !== false
+        && (plan.deletion.autoDelete || options.delete === true);
+    const appliedDeletionCount = deleteObsolete ? deletionCount : 0;
+    const changeCount = writeCount + appliedDeletionCount;
+    if (changeCount === 0) {
+        if (deletionCount > 0) {
+            console.log('No files were changed. Deletion candidates were preserved; re-run with --delete to remove them.');
+            return;
+        }
+        console.log('The project already matches the bundle.');
+        return;
+    }
+    if (!options.yes && !await confirmExport(appliedDeletionCount)) {
+        console.log('Export cancelled. No files were changed.');
+        return;
+    }
+    await applyProjectExport(plan, { deleteObsolete });
+    console.log(`${writeCount} files written, ${appliedDeletionCount} deleted.`);
+}
+function createProgram() {
+    const packageJson = createRequire(import.meta.url)('../../package.json');
+    const program = new Command();
+    program
+        .name('i18n-edit')
+        .description('Inspect, edit, bundle and regenerate typed i18n projects. Starts the web editor when no command is provided.')
+        .version(packageJson.version)
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .configureHelp({ showGlobalOptions: true })
+        .option('--project <path>', 'project root', process.cwd())
+        .option('--config <path>', 'project configuration (default: i18n.config.json)')
+        .option('--input <path>', 'TypeScript catalog that exports Langs');
+    program
+        .command('serve', { isDefault: true })
+        .description('start the local web editor')
+        .option('--bundle <path>', 'bundle served by the project API')
+        .option('--host <host>', 'host used by the web editor', '127.0.0.1')
+        .option('--port <port>', 'port used by the web editor', parsePort, 4173)
+        .action(async (options, command) => {
+        const server = await createServer(getProjectOptions(command, options.bundle));
+        const address = await server.listen({ host: options.host, port: options.port });
+        console.log(`i18n editor running at ${address}`);
+    });
+    program
+        .command('bundle')
+        .description('generate a portable translation bundle')
+        .option('-o, --output <path>', 'output bundle path', 'i18n.bundle.json')
+        .action(async (options, command) => {
+        await generateBundle(command, options.output);
+    });
+    program
+        .command('preview')
+        .description('show the files that would be generated from a bundle')
+        .option('-f, --file <path>', 'input bundle path', 'i18n.bundle.json')
+        .option('--no-diff', 'hide generated content diffs')
+        .action(async (options, command) => {
+        printPreview(await planProjectExport(getProjectOptions(command, options.file)), options.diff);
+    });
+    program
+        .command('export')
+        .description('regenerate project translation files from a bundle')
+        .option('-f, --file <path>', 'input bundle path', 'i18n.bundle.json')
+        .option('-y, --yes', 'apply the plan without confirmation')
+        .option('--delete', 'delete divergent files reported by the plan')
+        .option('--no-diff', 'hide generated content diffs')
+        .action(async (options, command) => {
+        await exportBundle(command, options);
+    });
+    program
+        .command('sync')
+        .description('bundle the project, then regenerate its translation files')
+        .option('-o, --output <path>', 'bundle path used between the two operations', 'i18n.bundle.json')
+        .option('-y, --yes', 'apply the export plan without confirmation')
+        .option('--delete', 'delete divergent files reported by the plan')
+        .option('--no-diff', 'hide generated content diffs')
+        .action(async (options, command) => {
+        await generateBundle(command, options.output);
+        await exportBundle(command, { ...options, file: options.output });
+    });
+    return program;
+}
+try {
+    await createProgram().parseAsync(process.argv);
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/dist/core/exportPlan.d.ts

@@ -0,0 +1,16 @@
+import { type I18nBundle } from '@wads.dev/i18n-ts/bundle';
+import { type EditorProjectConfig } from './projectConfig.js';
+export type ExportPlanFile = {
+    kind: 'base' | 'index' | 'language';
+    languageKey?: string;
+    path: string;
+};
+export type TranslationOwner = {
+    directory: string;
+    keyPath: string;
+    importPathStyle: 'alias' | 'relative';
+};
+export declare function getTranslationOwnerChain(fullKey: string, config: EditorProjectConfig): TranslationOwner[];
+export declare function getTranslationOwner(fullKey: string, config: EditorProjectConfig): TranslationOwner;
+export declare function buildTranslationOwners(bundle: I18nBundle, config: EditorProjectConfig): TranslationOwner[];
+export declare function buildExportPlan(bundle: I18nBundle, config: EditorProjectConfig): ExportPlanFile[];

package/dist/core/exportPlan.js

@@ -0,0 +1,143 @@
+import { assertBundle } from '@wads.dev/i18n-ts/bundle';
+import { flattenPathReplacer, getDefaultLevelImport, resolveImportAlias, } from '@wads.dev/i18n-ts/config';
+import { normalizeEditorProjectConfig } from './projectConfig.js';
+function getConfiguredLevelImport(config, level) {
+    return config.levelImports[level] || getDefaultLevelImport(level);
+}
+function appendPath(basePath, nextPath) {
+    return [basePath, nextPath]
+        .filter(Boolean)
+        .join('/')
+        .replaceAll(/\/+/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/\/$/, '');
+}
+function expandTemplate(template, value) {
+    return template.replaceAll('{value}', value);
+}
+function hasAlias(path, aliases) {
+    return Object.keys(aliases).some((alias) => path.startsWith(alias));
+}
+function getReplacement(replacer, fullKey, segment) {
+    const flattened = flattenPathReplacer(replacer);
+    if (Object.hasOwn(flattened, fullKey))
+        return { found: true, value: flattened[fullKey] };
+    if (Object.hasOwn(flattened, segment))
+        return { found: true, value: flattened[segment] };
+    return { found: false, value: undefined };
+}
+export function getTranslationOwnerChain(fullKey, config) {
+    const segments = fullKey.split('.');
+    const groupCount = Math.min(config.levelCount, Math.max(segments.length - 1, 0));
+    const rootImport = getConfiguredLevelImport(config, 0);
+    let directory = resolveImportAlias(expandTemplate(rootImport.path, ''), config.exportConfig.importAliases);
+    let consumedSegments = 0;
+    const owners = [{ directory, keyPath: '', importPathStyle: 'relative' }];
+    for (let level = 1; level <= groupCount; level += 1) {
+        const segment = segments[level - 1];
+        const objectPath = segments.slice(0, level).join('.');
+        const levelImport = getConfiguredLevelImport(config, level);
+        const fullReplacement = getReplacement(levelImport.fullReplacer, objectPath, segment);
+        if (fullReplacement.found) {
+            if (fullReplacement.value !== null) {
+                directory = resolveImportAlias(fullReplacement.value, config.exportConfig.importAliases);
+                consumedSegments = level;
+                owners.push({
+                    directory,
+                    keyPath: objectPath,
+                    importPathStyle: hasAlias(fullReplacement.value, config.exportConfig.importAliases) ? 'alias' : 'relative',
+                });
+            }
+            break;
+        }
+        const valueReplacement = getReplacement(levelImport.valueReplacer, objectPath, segment);
+        const value = typeof valueReplacement.value === 'string' ? valueReplacement.value : segment;
+        const template = expandTemplate(levelImport.path, value);
+        const resolved = resolveImportAlias(template, config.exportConfig.importAliases);
+        directory = hasAlias(template, config.exportConfig.importAliases) || template.startsWith('/')
+            ? resolved
+            : appendPath(directory, resolved);
+        consumedSegments = level;
+        owners.push({
+            directory,
+            keyPath: objectPath,
+            importPathStyle: hasAlias(template, config.exportConfig.importAliases) ? 'alias' : 'relative',
+        });
+    }
+    void consumedSegments;
+    return owners;
+}
+export function getTranslationOwner(fullKey, config) {
+    return getTranslationOwnerChain(fullKey, config).at(-1);
+}
+function isFunctionDescriptor(value) {
+    return value !== null
+        && typeof value === 'object'
+        && '$type' in value
+        && value.$type === 'function';
+}
+function collectTranslationKeys(value, path = '', keys = []) {
+    if (isFunctionDescriptor(value)) {
+        keys.push(path);
+        return keys;
+    }
+    if (Array.isArray(value)) {
+        keys.push(path);
+        return keys;
+    }
+    if (value && typeof value === 'object') {
+        Object.entries(value).forEach(([key, nestedValue]) => {
+            collectTranslationKeys(nestedValue, path ? `${path}.${key}` : key, keys);
+        });
+        return keys;
+    }
+    keys.push(path);
+    return keys;
+}
+export function buildTranslationOwners(bundle, config) {
+    const validBundle = assertBundle(bundle);
+    const validConfig = normalizeEditorProjectConfig(config);
+    const owners = new Map();
+    const referenceLanguage = Object.values(validBundle.languages)[0];
+    if (referenceLanguage) {
+        collectTranslationKeys(referenceLanguage.translations).forEach((key) => {
+            getTranslationOwnerChain(key, validConfig).forEach((owner) => {
+                const existing = owners.get(owner.directory);
+                if (existing && existing.keyPath !== owner.keyPath) {
+                    throw new Error(`The export path "${owner.directory}" resolves multiple translation owners.`);
+                }
+                owners.set(owner.directory, owner);
+            });
+        });
+    }
+    return [...owners.values()].sort((left, right) => left.keyPath.localeCompare(right.keyPath));
+}
+export function buildExportPlan(bundle, config) {
+    const validBundle = assertBundle(bundle);
+    const validConfig = normalizeEditorProjectConfig(config);
+    const owners = buildTranslationOwners(validBundle, validConfig);
+    return owners
+        .flatMap(({ directory, keyPath }) => {
+        const translationsDirectory = appendPath(directory, validConfig.translationsDirectory);
+        const structuralFiles = [
+            { kind: 'base', path: appendPath(translationsDirectory, 'base.ts') },
+        ];
+        if (keyPath === '') {
+            structuralFiles.push({
+                kind: 'index',
+                path: validConfig.catalogFile
+                    || appendPath(translationsDirectory, 'index.ts'),
+            });
+        }
+        const languageFiles = Object.keys(validBundle.languages).map((languageKey) => {
+            const language = validConfig.languageReplacer[languageKey] || languageKey;
+            return {
+                kind: 'language',
+                languageKey,
+                path: appendPath(translationsDirectory, validConfig.languageFileTemplate.replaceAll('{language}', language)),
+            };
+        });
+        return [...structuralFiles, ...languageFiles];
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+}

package/dist/core/keyPath.d.ts

@@ -0,0 +1,13 @@
+export type KeyPathSegment = string | number;
+export type KeyPathResult = {
+    found: false;
+} | {
+    found: true;
+    value: unknown;
+};
+type MutableContainer = Record<PropertyKey, unknown> | unknown[];
+export declare function parseKeyPath(key: string, parameterName: string): KeyPathSegment[];
+export declare function getKeyPathValue(root: unknown, segments: KeyPathSegment[]): KeyPathResult;
+export declare function deleteKeyPathValue(root: MutableContainer, segments: KeyPathSegment[]): void;
+export declare function setKeyPathValue(root: MutableContainer, segments: KeyPathSegment[], value: unknown): void;
+export {};

package/dist/core/keyPath.js

@@ -0,0 +1,59 @@
+function isContainer(value) {
+    return value !== null && typeof value === 'object';
+}
+function asRecord(value) {
+    return value;
+}
+export function parseKeyPath(key, parameterName) {
+    if (key.trim() === '') {
+        throw new Error(`${parameterName} must be a non-empty key.`);
+    }
+    const segments = [];
+    const matcher = /(?:^|\.)([^.[\]]+)|\[(\d+)\]/g;
+    let match;
+    let matchedCharacters = '';
+    while ((match = matcher.exec(key)) !== null) {
+        segments.push(match[2] === undefined ? match[1] : Number(match[2]));
+        matchedCharacters += match[0];
+    }
+    if (segments.length === 0 || matchedCharacters !== key) {
+        throw new Error(`${parameterName} contains an invalid path: ${key}`);
+    }
+    return segments;
+}
+export function getKeyPathValue(root, segments) {
+    let current = root;
+    for (const segment of segments) {
+        if (!isContainer(current) || !Object.hasOwn(current, segment))
+            return { found: false };
+        current = asRecord(current)[segment];
+    }
+    return { found: true, value: current };
+}
+export function deleteKeyPathValue(root, segments) {
+    const parentPath = segments.slice(0, -1);
+    const property = segments.at(-1);
+    let parent = root;
+    for (const segment of parentPath) {
+        const nested = asRecord(parent)[segment];
+        if (!isContainer(nested))
+            throw new Error(`The key path is invalid at ${String(segment)}.`);
+        parent = nested;
+    }
+    delete asRecord(parent)[property];
+}
+export function setKeyPathValue(root, segments, value) {
+    const property = segments.at(-1);
+    let current = root;
+    segments.slice(0, -1).forEach((segment, index) => {
+        if (!Object.hasOwn(current, segment)) {
+            asRecord(current)[segment] = typeof segments[index + 1] === 'number' ? [] : {};
+        }
+        const nested = asRecord(current)[segment];
+        if (!isContainer(nested)) {
+            throw new Error(`The destination key cannot be created inside ${String(segment)}.`);
+        }
+        current = nested;
+    });
+    asRecord(current)[property] = value;
+}

package/dist/core/moveKey.d.ts

@@ -0,0 +1,6 @@
+import { type I18nBundle } from '@wads.dev/i18n-ts/bundle';
+export type MoveKeyOptions = {
+    sourceKey: string;
+    targetKey: string;
+};
+export declare function moveKey(bundle: I18nBundle, { sourceKey, targetKey }: MoveKeyOptions): I18nBundle;

package/dist/core/moveKey.js

@@ -0,0 +1,32 @@
+import { assertBundle } from '@wads.dev/i18n-ts/bundle';
+import { deleteKeyPathValue, getKeyPathValue, parseKeyPath, setKeyPathValue, } from './keyPath.js';
+function cloneBundle(bundle) {
+    return structuredClone(bundle);
+}
+export function moveKey(bundle, { sourceKey, targetKey }) {
+    const validBundle = assertBundle(bundle);
+    const sourceSegments = parseKeyPath(sourceKey, 'sourceKey');
+    const targetSegments = parseKeyPath(targetKey, 'targetKey');
+    if (sourceKey === targetKey)
+        return cloneBundle(validBundle);
+    if (targetKey.startsWith(`${sourceKey}.`) || targetKey.startsWith(`${sourceKey}[`)) {
+        throw new Error('The destination key cannot be nested inside the source key.');
+    }
+    const valuesByLanguage = Object.entries(validBundle.languages).map(([languageKey, language]) => {
+        const source = getKeyPathValue(language.translations, sourceSegments);
+        if (!source.found) {
+            throw new Error(`The source key does not exist in language "${languageKey}".`);
+        }
+        if (getKeyPathValue(language.translations, targetSegments).found) {
+            throw new Error(`The destination key already exists in language "${languageKey}".`);
+        }
+        return [languageKey, source.value];
+    });
+    const nextBundle = cloneBundle(validBundle);
+    valuesByLanguage.forEach(([languageKey, value]) => {
+        const translations = nextBundle.languages[languageKey].translations;
+        deleteKeyPathValue(translations, sourceSegments);
+        setKeyPathValue(translations, targetSegments, value);
+    });
+    return nextBundle;
+}

package/dist/core/projectApi.d.ts

@@ -0,0 +1,31 @@
+import type { I18nBundle } from '@wads.dev/i18n-ts/bundle';
+import type { EditorProjectConfig } from './projectConfig.js';
+export type ProjectInfo = {
+    projectDirectory: string;
+    configPath: string | null;
+    catalogPath: string | null;
+    bundlePath: string;
+    config: EditorProjectConfig | null;
+    bundle: I18nBundle | null;
+    canGenerateBundle: boolean;
+};
+export type GenerateBundleResult = {
+    bundle: I18nBundle;
+    bundlePath: string;
+};
+export type ProjectExportPreviewRequest = {
+    bundle: I18nBundle;
+    config: EditorProjectConfig;
+};
+export type ProjectExportPreviewChange = {
+    kind: 'base' | 'index' | 'language' | 'obsolete';
+    path: string;
+    status: 'create' | 'modify' | 'unchanged' | 'delete';
+    diff?: string;
+};
+export type ProjectExportPreviewResult = {
+    changes: ProjectExportPreviewChange[];
+};
+export type ApiError = {
+    error: string;
+};

package/dist/core/projectApi.js

@@ -0,0 +1 @@
+export {};