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

package/dist/core/projectConfig.d.ts

@@ -0,0 +1,33 @@
+import { type I18nProjectConfig } from '@wads.dev/i18n-ts/config';
+export type I18nDeletionConfig = {
+    ignoredExtensions: string[];
+    autoDelete: boolean;
+};
+export type I18nExportConfig = {
+    importAliases: Record<string, string>;
+    codeFormat: I18nCodeFormatConfig;
+};
+export type I18nCodeFormatConfig = {
+    useDoubleQuotes: boolean;
+    useSemicolons: boolean;
+    useShorthandProperties: boolean;
+    useTrailingCommas: boolean;
+    printWidth: number;
+    maxObjectInlineItems: number;
+    maxArrayInlineItems: number;
+    objectLayout: 'fit' | 'multiline';
+    arrayLayout: 'fit' | 'multiline';
+    indentation: {
+        character: 'space' | 'tab';
+        size: number;
+    };
+};
+export type EditorProjectConfig = Omit<I18nProjectConfig, 'deletion' | 'importAliases' | 'exportConfig'> & {
+    catalogFile: string;
+    deletion: false | I18nDeletionConfig;
+    exportConfig: I18nExportConfig;
+};
+export declare function normalizeDeletionConfig(value: unknown): false | I18nDeletionConfig;
+export declare function normalizeEditorProjectConfig(value: unknown): EditorProjectConfig;
+export declare function createDefaultEditorProjectConfig(): EditorProjectConfig;
+export declare function getEditorLevelName(config: EditorProjectConfig, level: number): string;

package/dist/core/projectConfig.js

@@ -0,0 +1,93 @@
+import { createDefaultProjectConfig, normalizeProjectConfig, } from '@wads.dev/i18n-ts/config';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeStringRecord(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+}
+function normalizeCodeFormat(value, legacyExportConfig) {
+    const input = isRecord(value) ? value : {};
+    const indentation = isRecord(input.indentation) ? input.indentation : {};
+    const indentationSize = Number.parseInt(String(indentation.size ?? 2), 10);
+    const printWidth = Number.parseInt(String(input.printWidth ?? 120), 10);
+    const maxObjectInlineItems = Number.parseInt(String(input.maxObjectInlineItems ?? 4), 10);
+    const maxArrayInlineItems = Number.parseInt(String(input.maxArrayInlineItems ?? 8), 10);
+    return {
+        useDoubleQuotes: (input.useDoubleQuotes ?? legacyExportConfig.useDoubleQuotes) === true,
+        useSemicolons: input.useSemicolons !== false,
+        useShorthandProperties: input.useShorthandProperties !== false,
+        useTrailingCommas: input.useTrailingCommas !== false,
+        printWidth: Number.isFinite(printWidth) ? Math.min(400, Math.max(40, printWidth)) : 120,
+        maxObjectInlineItems: Number.isFinite(maxObjectInlineItems) ? Math.min(100, Math.max(0, maxObjectInlineItems)) : 4,
+        maxArrayInlineItems: Number.isFinite(maxArrayInlineItems) ? Math.min(100, Math.max(0, maxArrayInlineItems)) : 8,
+        objectLayout: input.objectLayout === 'multiline' ? 'multiline' : 'fit',
+        arrayLayout: input.arrayLayout === 'multiline' ? 'multiline' : 'fit',
+        indentation: {
+            character: indentation.character === 'tab' ? 'tab' : 'space',
+            size: Number.isFinite(indentationSize) ? Math.min(8, Math.max(1, indentationSize)) : 2,
+        },
+    };
+}
+export function normalizeDeletionConfig(value) {
+    if (value === false)
+        return false;
+    const input = isRecord(value) ? value : {};
+    const ignoredExtensions = Array.isArray(input.ignoredExtensions)
+        ? [...new Set(input.ignoredExtensions
+                .filter((extension) => typeof extension === 'string')
+                .map((extension) => extension.trim().toLowerCase())
+                .filter(Boolean)
+                .map((extension) => extension.startsWith('.') ? extension : `.${extension}`))]
+        : [];
+    return {
+        ignoredExtensions,
+        autoDelete: input.autoDelete === true,
+    };
+}
+export function normalizeEditorProjectConfig(value) {
+    const input = isRecord(value) ? value : {};
+    const exportInput = isRecord(input.exportConfig) ? input.exportConfig : {};
+    const importAliases = normalizeStringRecord(exportInput.importAliases ?? input.importAliases);
+    const normalized = normalizeProjectConfig({
+        ...input,
+        importAliases,
+    });
+    const normalizedRecord = normalized;
+    const normalizedExport = isRecord(normalizedRecord.exportConfig) ? normalizedRecord.exportConfig : {};
+    const normalizedAliases = normalizeStringRecord(normalizedExport.importAliases ?? normalizedRecord.importAliases);
+    const { importAliases: _legacyAliases, exportConfig: _normalizedExport, ...config } = normalizedRecord;
+    return {
+        ...config,
+        catalogFile: typeof input.catalogFile === 'string' && input.catalogFile.trim()
+            ? input.catalogFile.trim()
+            : 'src/shared/i18n/index.ts',
+        deletion: normalizeDeletionConfig(input.deletion),
+        exportConfig: {
+            importAliases: normalizedAliases,
+            codeFormat: normalizeCodeFormat(exportInput.codeFormat, exportInput),
+        },
+    };
+}
+export function createDefaultEditorProjectConfig() {
+    const defaults = createDefaultProjectConfig();
+    const defaultsExport = isRecord(defaults.exportConfig) ? defaults.exportConfig : {};
+    const importAliases = normalizeStringRecord(defaultsExport.importAliases ?? defaults.importAliases);
+    const { importAliases: _legacyAliases, exportConfig: _defaultsExport, ...config } = defaults;
+    return {
+        ...config,
+        catalogFile: 'src/shared/i18n/index.ts',
+        deletion: normalizeDeletionConfig(undefined),
+        exportConfig: {
+            importAliases,
+            codeFormat: normalizeCodeFormat(undefined, {}),
+        },
+    };
+}
+export function getEditorLevelName(config, level) {
+    if (level === 0)
+        return 'Root';
+    const names = config.levelNames.split(',').map((name) => name.trim()).filter(Boolean);
+    return names[level - 1] || `Level ${level}`;
+}

package/dist/core/setStringValue.d.ts

@@ -0,0 +1,7 @@
+import { type I18nBundle } from '@wads.dev/i18n-ts/bundle';
+export type SetStringValueOptions = {
+    languageKey: string;
+    key: string;
+    value: string;
+};
+export declare function setStringValue(bundle: I18nBundle, { languageKey, key, value }: SetStringValueOptions): I18nBundle;

package/dist/core/setStringValue.js

@@ -0,0 +1,23 @@
+import { assertBundle } from '@wads.dev/i18n-ts/bundle';
+import { getKeyPathValue, parseKeyPath, setKeyPathValue } from './keyPath.js';
+function cloneBundle(bundle) {
+    return structuredClone(bundle);
+}
+export function setStringValue(bundle, { languageKey, key, value }) {
+    const validBundle = assertBundle(bundle);
+    const language = validBundle.languages[languageKey];
+    if (!language) {
+        throw new Error(`Language "${languageKey}" does not exist in the bundle.`);
+    }
+    const segments = parseKeyPath(key, 'key');
+    const currentValue = getKeyPathValue(language.translations, segments);
+    if (!currentValue.found) {
+        throw new Error(`Key "${key}" does not exist in language "${languageKey}".`);
+    }
+    if (typeof currentValue.value !== 'string') {
+        throw new Error('Editing functions and non-string values is not supported yet.');
+    }
+    const nextBundle = cloneBundle(validBundle);
+    setKeyPathValue(nextBundle.languages[languageKey].translations, segments, value);
+    return nextBundle;
+}

package/dist/core/sourceFiles.d.ts

@@ -0,0 +1,19 @@
+import { type I18nBundle } from '@wads.dev/i18n-ts/bundle';
+import { type EditorProjectConfig } from './projectConfig.js';
+export type GeneratedSourceFile = {
+    kind: 'base' | 'index' | 'language';
+    path: string;
+    content: string;
+};
+export type SourceGenerationOptions = {
+    catalogFile?: string;
+    existingInterfaceNames?: Record<string, string>;
+    existingLanguageTypeName?: string;
+    existingPropertyTypes?: Record<string, string>;
+    existingTypeImports?: Record<string, Array<{
+        name: string;
+        path: string;
+    }>>;
+    existingValueImportOrder?: Record<string, string[]>;
+};
+export declare function generateSourceFiles(bundle: I18nBundle, projectConfig: EditorProjectConfig, options?: SourceGenerationOptions): GeneratedSourceFile[];

package/dist/core/sourceFiles.js

@@ -0,0 +1,406 @@
+import { assertBundle } from '@wads.dev/i18n-ts/bundle';
+import { buildTranslationOwners } from './exportPlan.js';
+import { normalizeEditorProjectConfig, } from './projectConfig.js';
+function appendPath(basePath, nextPath) {
+    return [basePath, nextPath].filter(Boolean).join('/').replaceAll(/\/+/g, '/').replace(/^\.\//, '');
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isFunctionDescriptor(value) {
+    return isRecord(value) && value.$type === 'function' && typeof value.source === 'string';
+}
+function isTypeReference(value) {
+    return isRecord(value) && typeof value.$reference === 'string' && typeof value.$value === 'string';
+}
+function getAtPath(value, keyPath) {
+    if (!keyPath)
+        return value;
+    return keyPath.split('.').reduce((current, segment) => {
+        return isRecord(current) ? current[segment] : undefined;
+    }, value);
+}
+function setAtPath(target, segments, value) {
+    let current = target;
+    segments.forEach((segment, index) => {
+        if (index === segments.length - 1) {
+            current[segment] = value;
+            return;
+        }
+        const existing = current[segment];
+        if (!isRecord(existing) || isFunctionDescriptor(existing) || isTypeReference(existing)) {
+            current[segment] = {};
+        }
+        current = current[segment];
+    });
+}
+function toPascalCase(value) {
+    const result = value
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((part) => `${part[0]?.toUpperCase() || ''}${part.slice(1)}`)
+        .join('');
+    return result || 'Project';
+}
+function toIdentifier(value) {
+    const pascal = toPascalCase(value);
+    const identifier = `${pascal[0]?.toLowerCase() || ''}${pascal.slice(1)}`;
+    return /^[$A-Z_a-z]/.test(identifier) ? identifier : `_${identifier}`;
+}
+function quoteString(value, codeFormat) {
+    if (codeFormat.useDoubleQuotes)
+        return JSON.stringify(value);
+    const escaped = [...value].map((character) => {
+        if (character === "'")
+            return "\\'";
+        if (character === '\\')
+            return '\\\\';
+        if (character === '\n')
+            return '\\n';
+        if (character === '\r')
+            return '\\r';
+        if (character === '\t')
+            return '\\t';
+        if (character === '\b')
+            return '\\b';
+        if (character === '\f')
+            return '\\f';
+        const codePoint = character.codePointAt(0);
+        if (codePoint < 0x20 || codePoint === 0x2028 || codePoint === 0x2029) {
+            return `\\u${codePoint.toString(16).padStart(4, '0')}`;
+        }
+        return character;
+    }).join('');
+    return `'${escaped}'`;
+}
+function propertyName(value, codeFormat) {
+    return /^[$A-Z_a-z][$\w]*$/.test(value) ? value : quoteString(value, codeFormat);
+}
+function indent(level, codeFormat) {
+    const character = codeFormat.indentation.character === 'tab' ? '\t' : ' ';
+    return character.repeat(codeFormat.indentation.size * level);
+}
+function terminateStatement(value, codeFormat) {
+    return `${value}${codeFormat.useSemicolons ? ';' : ''}`;
+}
+function addCommas(values, codeFormat) {
+    return values.map((value, index) => {
+        const needsComma = index < values.length - 1 || codeFormat.useTrailingCommas;
+        return `${value}${needsComma ? ',' : ''}`;
+    });
+}
+function renderCompactValue(value, codeFormat) {
+    if (isTypeReference(value))
+        return value.$value;
+    if (isFunctionDescriptor(value))
+        return value.source.includes('\n') ? null : value.source;
+    if (Array.isArray(value)) {
+        if (codeFormat.arrayLayout === 'multiline')
+            return null;
+        if (value.length > codeFormat.maxArrayInlineItems)
+            return null;
+        if (value.some((item) => Array.isArray(item) || (isRecord(item) && !isFunctionDescriptor(item) && !isTypeReference(item))))
+            return null;
+        const items = value.map((item) => renderCompactValue(item, codeFormat));
+        if (items.some((item) => item === null))
+            return null;
+        return `[${items.join(', ')}]`;
+    }
+    if (isRecord(value)) {
+        if (codeFormat.objectLayout === 'multiline')
+            return null;
+        if (Object.keys(value).length > codeFormat.maxObjectInlineItems)
+            return null;
+        if (Object.values(value).some((item) => Array.isArray(item) || (isRecord(item) && !isFunctionDescriptor(item) && !isTypeReference(item))))
+            return null;
+        const properties = Object.entries(value).map(([key, item]) => {
+            const renderedValue = renderCompactValue(item, codeFormat);
+            if (renderedValue === null)
+                return null;
+            const canUseShorthand = codeFormat.useShorthandProperties
+                && /^[$A-Z_a-z][$\w]*$/.test(key)
+                && renderedValue === key;
+            return canUseShorthand ? key : `${propertyName(key, codeFormat)}: ${renderedValue}`;
+        });
+        if (properties.some((property) => property === null))
+            return null;
+        return `{ ${properties.join(', ')} }`;
+    }
+    if (typeof value === 'string')
+        return quoteString(value, codeFormat);
+    return JSON.stringify(value);
+}
+function getTypeName(owner, basePath, names) {
+    return names[basePath] || `${toPascalCase(owner.keyPath)}Translation`;
+}
+function getFunctionType(source) {
+    const arrowIndex = source.indexOf('=>');
+    if (arrowIndex < 0)
+        return '(...args: any[]) => string';
+    const rawParameters = source.slice(0, arrowIndex).trim().replace(/^async\s+/, '');
+    const parameterText = rawParameters.startsWith('(')
+        ? rawParameters.slice(1, rawParameters.lastIndexOf(')'))
+        : rawParameters;
+    const parameters = parameterText
+        .split(',')
+        .map((parameter) => parameter.trim().replace(/=.*$/, '').replace(/^\.\.\./, '').trim())
+        .filter((parameter) => /^[$A-Z_a-z][$\w]*$/.test(parameter))
+        .map((parameter) => `${parameter}: any`);
+    return `(${parameters.join(', ')}) => string`;
+}
+function renderType(value, level, keyPath, existingPropertyTypes, codeFormat) {
+    if (isTypeReference(value))
+        return value.$reference;
+    if (existingPropertyTypes[keyPath])
+        return existingPropertyTypes[keyPath];
+    if (isFunctionDescriptor(value))
+        return getFunctionType(value.source);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return 'unknown[]';
+        const types = [...new Set(value.map((item) => renderType(item, level, keyPath, existingPropertyTypes, codeFormat)))];
+        return types.length === 1 ? `${types[0]}[]` : `Array<${types.join(' | ')}>`;
+    }
+    if (isRecord(value)) {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return 'Record<string, never>';
+        const pad = indent(level, codeFormat);
+        const childPad = indent(level + 1, codeFormat);
+        return `{\n${entries.map(([key, item]) => {
+            const childPath = keyPath ? `${keyPath}.${key}` : key;
+            const member = `${childPad}${propertyName(key, codeFormat)}: ${renderType(item, level + 1, childPath, existingPropertyTypes, codeFormat)}`;
+            return terminateStatement(member, codeFormat);
+        }).join('\n')}\n${pad}}`;
+    }
+    if (value === null)
+        return 'null';
+    return typeof value;
+}
+function renderValue(value, level, codeFormat, currentColumn = 0, allowInline = true) {
+    if (isTypeReference(value))
+        return value.$value;
+    if (isFunctionDescriptor(value))
+        return value.source;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const compact = allowInline ? renderCompactValue(value, codeFormat) : null;
+        if (compact !== null && currentColumn + compact.length <= codeFormat.printWidth)
+            return compact;
+        const pad = indent(level, codeFormat);
+        const childPad = indent(level + 1, codeFormat);
+        const items = value.map((item) => `${childPad}${renderValue(item, level + 1, codeFormat, childPad.length)}`);
+        return `[\n${addCommas(items, codeFormat).join('\n')}\n${pad}]`;
+    }
+    if (isRecord(value)) {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        const compact = allowInline ? renderCompactValue(value, codeFormat) : null;
+        if (compact !== null && currentColumn + compact.length <= codeFormat.printWidth)
+            return compact;
+        const pad = indent(level, codeFormat);
+        const childPad = indent(level + 1, codeFormat);
+        const properties = entries.map(([key, item]) => {
+            const renderedKey = propertyName(key, codeFormat);
+            const valueColumn = childPad.length + renderedKey.length + 2;
+            const renderedValue = renderValue(item, level + 1, codeFormat, valueColumn);
+            const canUseShorthand = codeFormat.useShorthandProperties
+                && /^[$A-Z_a-z][$\w]*$/.test(key)
+                && renderedValue === key;
+            return `${childPad}${canUseShorthand ? key : `${renderedKey}: ${renderedValue}`}`;
+        });
+        return `{\n${addCommas(properties, codeFormat).join('\n')}\n${pad}}`;
+    }
+    if (typeof value === 'string')
+        return quoteString(value, codeFormat);
+    return JSON.stringify(value);
+}
+function relativeImport(fromFile, toFile) {
+    const fromSegments = fromFile.split('/').slice(0, -1);
+    const toSegments = toFile.replace(/\.ts$/, '').split('/');
+    while (fromSegments[0] === toSegments[0]) {
+        fromSegments.shift();
+        toSegments.shift();
+    }
+    const relative = [...fromSegments.map(() => '..'), ...toSegments].join('/');
+    return relative.startsWith('.') ? relative : `./${relative}`;
+}
+function aliasedImport(toFile, aliases) {
+    const normalizedTarget = toFile.replace(/\.ts$/, '');
+    const match = Object.entries(aliases)
+        .filter(([, target]) => {
+        const prefix = target.replace(/\/$/, '');
+        return normalizedTarget === prefix || normalizedTarget.startsWith(`${prefix}/`);
+    })
+        .sort((left, right) => right[1].length - left[1].length)[0];
+    if (!match)
+        return null;
+    const [alias, target] = match;
+    const normalizedAlias = alias.endsWith('/') ? alias : `${alias}/`;
+    const normalizedPrefix = target.replace(/\/$/, '');
+    const remainder = normalizedTarget.slice(normalizedPrefix.length).replace(/^\//, '');
+    return `${normalizedAlias}${remainder}`;
+}
+function generatedImport(fromFile, toFile, owner, config) {
+    if (owner.importPathStyle === 'alias') {
+        const aliased = aliasedImport(toFile, config.exportConfig.importAliases);
+        if (aliased)
+            return aliased;
+    }
+    return relativeImport(fromFile, toFile);
+}
+function ownerIdentifier(owner) {
+    return toIdentifier(owner.keyPath.split('.').at(-1) || owner.keyPath);
+}
+function orderChildrenByExistingImports(children, childPaths, existingOrder = []) {
+    const ranks = new Map(existingOrder.map((targetPath, index) => [targetPath, index]));
+    return [...children].sort((left, right) => {
+        const leftRank = ranks.get(childPaths.get(left.keyPath) || '') ?? Number.POSITIVE_INFINITY;
+        const rightRank = ranks.get(childPaths.get(right.keyPath) || '') ?? Number.POSITIVE_INFINITY;
+        return leftRank - rightRank;
+    });
+}
+function renderBaseFile(typeName, ownerKeyPath, tree, imports, existingPropertyTypes, codeFormat) {
+    const importLines = [
+        `import type { Translation } from ${quoteString('@wads.dev/i18n-ts', codeFormat)}`,
+        ...imports.map((item) => `import type ${item.name} from ${quoteString(item.path, codeFormat)}`),
+    ].map((line) => terminateStatement(line, codeFormat));
+    const body = Object.entries(tree)
+        .map(([key, value]) => {
+        const keyPath = ownerKeyPath ? `${ownerKeyPath}.${key}` : key;
+        const member = `${indent(1, codeFormat)}${propertyName(key, codeFormat)}: ${renderType(value, 1, keyPath, existingPropertyTypes, codeFormat)}`;
+        return terminateStatement(member, codeFormat);
+    })
+        .join('\n');
+    return `${importLines.join('\n')}\n\nexport default interface ${typeName} extends Translation {\n${body}\n}\n`;
+}
+function renderLanguageFile(variableName, typeName, tree, imports, codeFormat) {
+    const importLines = [
+        ...imports.map((item) => `import ${item.name} from ${quoteString(item.path, codeFormat)}`),
+        `import type ${typeName} from ${quoteString('./base', codeFormat)}`,
+    ].map((line) => terminateStatement(line, codeFormat));
+    const declaration = terminateStatement(`const ${variableName}: ${typeName} = ${renderValue(tree, 0, codeFormat, 0, false)}`, codeFormat);
+    const exportLine = terminateStatement(`export default ${variableName}`, codeFormat);
+    return `${importLines.join('\n')}\n\n${declaration}\n\n${exportLine}\n`;
+}
+function renderIndexFile(bundle, rootTypeName, languageTypeName, config, indexPath, rootBasePath) {
+    const languageKeys = Object.keys(bundle.languages);
+    const codeFormat = config.exportConfig.codeFormat;
+    const languageUnion = languageKeys.map((key) => quoteString(key, codeFormat)).join(' | ') || 'never';
+    const entries = languageKeys.map((languageKey) => {
+        const language = bundle.languages[languageKey];
+        const filename = config.languageReplacer[languageKey] || languageKey;
+        const languagePath = `${rootBasePath.slice(0, -'base.ts'.length)}${config.languageFileTemplate.replaceAll('{language}', filename)}`;
+        const properties = addCommas([
+            `${indent(2, codeFormat)}lang: () => import(${quoteString(relativeImport(indexPath, languagePath), codeFormat)})`,
+            `${indent(2, codeFormat)}name: ${quoteString(language.name, codeFormat)}`,
+            `${indent(2, codeFormat)}short: ${quoteString(language.short, codeFormat)}`,
+            `${indent(2, codeFormat)}locale: ${quoteString(language.locale, codeFormat)}`,
+        ], codeFormat);
+        return `${indent(1, codeFormat)}${propertyName(languageKey, codeFormat)}: {\n${properties.join('\n')}\n${indent(1, codeFormat)}}`;
+    });
+    const imports = [
+        terminateStatement(`import type { AvailableLangs } from ${quoteString('@wads.dev/i18n-ts', codeFormat)}`, codeFormat),
+        terminateStatement(`import type ${rootTypeName} from ${quoteString(relativeImport(indexPath, rootBasePath), codeFormat)}`, codeFormat),
+    ];
+    const typeDeclaration = terminateStatement(`export type ${languageTypeName} = ${languageUnion}`, codeFormat);
+    const langsDeclaration = terminateStatement(`export const Langs: AvailableLangs<${languageTypeName}, ${rootTypeName}> = {\n${addCommas(entries, codeFormat).join('\n')}\n}`, codeFormat);
+    return `${imports.join('\n')}\n\n${typeDeclaration}\n\n${langsDeclaration}\n`;
+}
+export function generateSourceFiles(bundle, projectConfig, options = {}) {
+    const validBundle = assertBundle(bundle);
+    const config = normalizeEditorProjectConfig(projectConfig);
+    const owners = buildTranslationOwners(validBundle, config);
+    const ownerByKey = new Map(owners.map((owner) => [owner.keyPath, owner]));
+    const typeNames = new Map();
+    const basePaths = new Map();
+    owners.forEach((owner) => {
+        const basePath = appendPath(appendPath(owner.directory, config.translationsDirectory), 'base.ts');
+        basePaths.set(owner.keyPath, basePath);
+        typeNames.set(owner.keyPath, getTypeName(owner, basePath, options.existingInterfaceNames || {}));
+    });
+    function getParent(owner) {
+        return owners
+            .filter((candidate) => candidate.keyPath !== owner.keyPath)
+            .filter((candidate) => !candidate.keyPath || owner.keyPath.startsWith(`${candidate.keyPath}.`))
+            .sort((left, right) => right.keyPath.length - left.keyPath.length)[0];
+    }
+    const children = new Map();
+    owners.forEach((owner) => {
+        const parent = getParent(owner);
+        if (!parent)
+            return;
+        children.set(parent.keyPath, [...(children.get(parent.keyPath) || []), owner]);
+    });
+    const files = [];
+    owners.forEach((owner) => {
+        const translationDirectory = appendPath(owner.directory, config.translationsDirectory);
+        const basePath = basePaths.get(owner.keyPath);
+        const typeName = typeNames.get(owner.keyPath);
+        const ownerChildren = children.get(owner.keyPath) || [];
+        const referenceTree = structuredClone(getAtPath(Object.values(validBundle.languages)[0]?.translations, owner.keyPath) || {});
+        ownerChildren.forEach((child) => {
+            const relativeSegments = child.keyPath.slice(owner.keyPath ? owner.keyPath.length + 1 : 0).split('.');
+            setAtPath(referenceTree, relativeSegments, {
+                $reference: typeNames.get(child.keyPath),
+                $value: ownerIdentifier(child),
+            });
+        });
+        const generatedBaseImports = ownerChildren.map((child) => ({
+            name: typeNames.get(child.keyPath),
+            path: generatedImport(basePath, basePaths.get(child.keyPath), child, config),
+        }));
+        const generatedImportNames = new Set(generatedBaseImports.map((item) => item.name));
+        const preservedBaseImports = (options.existingTypeImports?.[basePath] || [])
+            .filter((item) => !generatedImportNames.has(item.name));
+        const baseImports = [...generatedBaseImports, ...preservedBaseImports];
+        files.push({
+            kind: 'base',
+            path: basePath,
+            content: renderBaseFile(typeName, owner.keyPath, referenceTree, baseImports, options.existingPropertyTypes || {}, config.exportConfig.codeFormat),
+        });
+        Object.entries(validBundle.languages).forEach(([languageKey, language]) => {
+            const filenameValue = config.languageReplacer[languageKey] || languageKey;
+            const languagePath = appendPath(translationDirectory, config.languageFileTemplate.replaceAll('{language}', filenameValue));
+            const tree = structuredClone(getAtPath(language.translations, owner.keyPath) || {});
+            ownerChildren.forEach((child) => {
+                const relativeSegments = child.keyPath.slice(owner.keyPath ? owner.keyPath.length + 1 : 0).split('.');
+                setAtPath(tree, relativeSegments, {
+                    $reference: typeNames.get(child.keyPath),
+                    $value: ownerIdentifier(child),
+                });
+            });
+            const childPaths = new Map(ownerChildren.map((child) => {
+                const childDirectory = appendPath(child.directory, config.translationsDirectory);
+                const childPath = appendPath(childDirectory, config.languageFileTemplate.replaceAll('{language}', filenameValue));
+                return [child.keyPath, childPath];
+            }));
+            const orderedChildren = orderChildrenByExistingImports(ownerChildren, childPaths, options.existingValueImportOrder?.[languagePath]);
+            const languageImports = orderedChildren.map((child) => {
+                const childPath = childPaths.get(child.keyPath);
+                return {
+                    name: ownerIdentifier(child),
+                    path: generatedImport(languagePath, childPath, child, config),
+                };
+            });
+            files.push({
+                kind: 'language',
+                path: languagePath,
+                content: renderLanguageFile(toIdentifier(filenameValue), typeName, tree, languageImports, config.exportConfig.codeFormat),
+            });
+        });
+    });
+    const rootOwner = ownerByKey.get('');
+    if (rootOwner) {
+        const rootBasePath = basePaths.get('');
+        const indexPath = options.catalogFile || appendPath(appendPath(rootOwner.directory, config.translationsDirectory), 'index.ts');
+        files.push({
+            kind: 'index',
+            path: indexPath,
+            content: renderIndexFile(validBundle, typeNames.get(''), options.existingLanguageTypeName || 'I18nLanguage', config, indexPath, rootBasePath),
+        });
+    }
+    return files.sort((left, right) => left.path.localeCompare(right.path));
+}