@logto/cli 1.19.0 → 1.20.0

package/lib/commands/translate/openai.js

@@ -1,73 +0,0 @@
-import fs from 'node:fs/promises';
-import { trySafe } from '@silverhand/essentials';
-import { got, HTTPError } from 'got';
-import { HttpsProxyAgent } from 'hpagent';
-import { z } from 'zod';
-import { consoleLog, getProxy } from '../../utils.js';
-import { getTranslationPromptMessages } from './prompts.js';
-export const createOpenaiApi = () => {
-    const proxy = getProxy();
-    return got.extend({
-        prefixUrl: process.env.OPENAI_API_PROXY_ENDPOINT ?? 'https://api.openai.com/v1',
-        headers: {
-            Authorization: `Bearer ${process.env.OPENAI_API_KEY ?? ''}`,
-        },
-        timeout: { request: 300_000 },
-        ...(proxy && { agent: { https: new HttpsProxyAgent({ proxy, timeout: 300_000 }) } }),
-    });
-};
-const gptResponseGuard = z.object({
-    choices: z
-        .object({
-        message: z.object({ role: z.string(), content: z.string() }),
-        finish_reason: z.string(),
-    })
-        .array(),
-});
-export const translate = async ({ api, targetLanguage, sourceFilePath, extraPrompt, }) => {
-    const sourceFileContent = await fs.readFile(sourceFilePath, 'utf8');
-    const response = await trySafe(api
-        .post('chat/completions', {
-        json: {
-            // The full list of OPENAI model can be found at https://platform.openai.com/docs/models.
-            model: process.env.OPENAI_MODEL_NAME ?? 'gpt-3.5-turbo-0125',
-            messages: getTranslationPromptMessages({
-                sourceFileContent,
-                targetLanguage,
-                extraPrompt,
-            }),
-        },
-    })
-        .json(), (error) => {
-        consoleLog.warn(`Error while translating ${sourceFilePath}:`, String(error));
-        if (error instanceof HTTPError) {
-            consoleLog.warn(error.response.body);
-        }
-    });
-    if (!response) {
-        return;
-    }
-    const guarded = gptResponseGuard.safeParse(response);
-    if (!guarded.success) {
-        consoleLog.warn(`Error while guarding response for ${sourceFilePath}:`, response);
-        return;
-    }
-    const [entity] = guarded.data.choices;
-    if (!entity) {
-        consoleLog.warn(`No choice found in response when translating ${sourceFilePath}`);
-        return;
-    }
-    if (entity.finish_reason !== 'stop') {
-        consoleLog.warn(`Unexpected finish reason ${entity.finish_reason} for ${sourceFilePath}`);
-    }
-    const { content } = entity.message;
-    const matched = /```(?:ts)?\n(.*)```/s.exec(content)?.[1];
-    if (!matched) {
-        // Treat as pure code
-        if (['const ', 'import '].some((prefix) => content.startsWith(prefix))) {
-            return content;
-        }
-        consoleLog.warn('No matching code snippet from response:', content);
-    }
-    return matched;
-};

package/lib/commands/translate/prompts.d.ts

@@ -1,18 +0,0 @@
-import { type LanguageTag } from '@logto/language-kit';
-type GetTranslationPromptProperties = {
-    sourceFileContent: string;
-    targetLanguage: LanguageTag;
-    extraPrompt?: string;
-};
-export declare const untranslatedMark = "/** UNTRANSLATED */";
-/**
- * Note:
- * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1600.
- * Remember to check the token limit before adding more prompt.
- * Tokens can be counted in https://platform.openai.com/tokenizer
- */
-export declare const getTranslationPromptMessages: ({ sourceFileContent, targetLanguage, extraPrompt, }: GetTranslationPromptProperties) => {
-    role: string;
-    content: string;
-}[];
-export {};

package/lib/commands/translate/prompts.js

@@ -1,48 +0,0 @@
-import { languages } from '@logto/language-kit';
-import { conditionalString } from '@silverhand/essentials';
-export const untranslatedMark = '/** UNTRANSLATED */';
-/**
- * Note:
- * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1600.
- * Remember to check the token limit before adding more prompt.
- * Tokens can be counted in https://platform.openai.com/tokenizer
- */
-export const getTranslationPromptMessages = ({ sourceFileContent, targetLanguage, extraPrompt, }) => [
-    {
-        role: 'assistant',
-        content: `You are a assistant translator and will receive a TypeScript object. Traverse and find object values with "${untranslatedMark}" annotation on the top, then translate these values to target locale "${languages[targetLanguage]}". Remove the "${untranslatedMark}" annotations from output. Escape the single quotes (if any) in translated results by prepending a backslash. Keep the interpolation double curly brackets and their inner values intact. Make sure there is a space between the CJK and non-CJK characters. Prefer using "你" instead of "您" in Chinese. Do not include sample code snippet below in the final output. ${conditionalString(extraPrompt)}
-
-Take translating to zh-CN as an example, if the input is:
-\`\`\`ts
-import others from './others.js';
-
-const translation = {
-  hello: 'Hello',
-  ${untranslatedMark}
-  world: 'world',
-  others,
-};
-
-export default translation;
-\`\`\`
-
-Then the output should be:
-\`\`\`ts
-import others from './others.js';
-
-const translation = {
-  hello: 'Hello',
-  world: '世界',
-  others,
-};
-
-export default translation;
-\`\`\``,
-    },
-    {
-        role: 'user',
-        content: `\`\`\`ts
-${sourceFileContent}
-\`\`\``,
-    },
-];

package/lib/commands/translate/sync-keys/index.d.ts

@@ -1,13 +0,0 @@
-import { type CommandModule } from 'yargs';
-declare const syncKeys: CommandModule<{
-    path?: string;
-    skipCoreCheck?: boolean;
-}, {
-    path?: string;
-    skipCoreCheck?: boolean;
-    baseline: string;
-    target: string;
-    skipLint?: boolean;
-    package: string;
-}>;
-export default syncKeys;

package/lib/commands/translate/sync-keys/index.js

@@ -1,73 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { isLanguageTag } from '@logto/language-kit';
-import ora from 'ora';
-import { consoleLog, inquireInstancePath, lintLocaleFiles } from '../../../utils.js';
-import { parseLocaleFiles, syncPhraseKeysAndFileStructure } from './utils.js';
-const syncKeys = {
-    command: ['sync-keys', 'sk'],
-    describe: [
-        'Sync nested object keys and the file structure from baseline to target.',
-        'If a key is missing in the target, it will be added with a comment to indicate that the phrase is untranslated;',
-        'If a key is missing in the baseline, it will be removed from the target;',
-        'If a key exists in both the baseline and the target, the value of the target will be used.',
-    ].join(' '),
-    builder: (yargs) => yargs
-        .option('baseline', {
-        alias: 'b',
-        type: 'string',
-        describe: 'The baseline language tag',
-        default: 'en',
-    })
-        .option('package', {
-        alias: 'pkg',
-        type: 'string',
-        describe: 'The package name of the phrases, e.g. `phrases` or `phrases-experience`',
-        default: 'phrases',
-    })
-        .option('target', {
-        alias: 't',
-        type: 'string',
-        describe: 'The target language tag, or `all` to sync all languages',
-    })
-        .option('skip-lint', {
-        alias: 'sl',
-        type: 'boolean',
-        describe: 'Skip running `eslint --fix` for locales after syncing',
-    })
-        .demandOption(['baseline', 'target']),
-    handler: async ({ path: inputPath, skipCoreCheck, baseline: baselineTag, target: targetTag, skipLint, package: packageName, }) => {
-        if (!isLanguageTag(baselineTag)) {
-            consoleLog.fatal('Invalid baseline language tag');
-        }
-        if (targetTag !== 'all' && !isLanguageTag(targetTag)) {
-            consoleLog.fatal('Invalid target language tag');
-        }
-        if (baselineTag === targetTag) {
-            consoleLog.fatal('Baseline and target cannot be the same');
-        }
-        const instancePath = await inquireInstancePath(inputPath, skipCoreCheck);
-        const phrasesPath = path.join(instancePath, 'packages', packageName);
-        const localesPath = path.join(phrasesPath, 'src/locales');
-        const entrypoint = path.join(localesPath, baselineTag.toLowerCase(), 'index.ts');
-        const baseline = parseLocaleFiles(entrypoint);
-        const targetLocales = targetTag === 'all' ? fs.readdirSync(localesPath) : [targetTag.toLowerCase()];
-        /* eslint-disable no-await-in-loop */
-        for (const target of targetLocales) {
-            if (target === baselineTag) {
-                continue;
-            }
-            const spinner = ora({
-                text: `Syncing object keys and file structure from ${baselineTag} to ${target}`,
-            }).start();
-            const targetDirectory = path.join(localesPath, target);
-            await syncPhraseKeysAndFileStructure(baseline, target, targetDirectory);
-            spinner.succeed(`Synced object keys and file structure from ${baselineTag} to ${target}`);
-        }
-        /* eslint-enable no-await-in-loop */
-        if (!skipLint) {
-            void lintLocaleFiles(instancePath, packageName);
-        }
-    },
-};
-export default syncKeys;

package/lib/commands/translate/sync-keys/utils.d.ts

@@ -1,57 +0,0 @@
-type FileStructure = {
-    [key: string | number]: {
-        filePath?: string;
-        structure: FileStructure;
-    };
-};
-type NestedPhraseObject = {
-    [key: string | number]: [phrase: string, isTranslated: boolean] | NestedPhraseObject;
-};
-type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
-/**
- * Given a entrypoint file path of a language, parse the nested object of
- * phrases and the file structure.
- *
- * @example
- * Given the following file:
- *
- * ```ts
- * import errors from './errors/index.js';
- *
- * const translation = {
- *   // UNTRANSLATED
- *   page_title: 'Applications',
- *   errors,
- * };
- * ```
- *
- * The returned object will be:
- *
- * ```ts
- * {
- *   page_title: ['Anwendungen', false],
- *   errors: {
- *     page_not_found: ['Seite nicht gefunden', true],
- *   },
- * }
- * ```
- *
- * And the file structure will be:
- *
- * ```ts
- * {
- *   errors: {
- *     filePath: './errors/index.js',
- *     structure: {},
- *   },
- * }
- * ```
- *
- * @param filePath The entrypoint file path of a language
- *
- * @returns A tuple of the nested object of phrases and the file structure
- *
- */
-export declare const parseLocaleFiles: (filePath: string) => ParsedTuple;
-export declare const syncPhraseKeysAndFileStructure: (baseline: ParsedTuple, targetLocale: string, targetDirectory: string) => Promise<void>;
-export {};

package/lib/commands/translate/sync-keys/utils.js

@@ -1,295 +0,0 @@
-import { readFileSync, existsSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { tryThat } from '@silverhand/essentials';
-import ts from 'typescript';
-import { consoleLog } from '../../../utils.js';
-const getValue = (property) => {
-    if (ts.isStringLiteral(property.initializer) ||
-        ts.isNoSubstitutionTemplateLiteral(property.initializer)) {
-        return property.initializer.getText();
-    }
-    consoleLog.fatal('Unsupported property:', property.getFullText());
-};
-const hasLeadingUntranslatedComment = (fullText) => {
-    const commentRanges = ts.getLeadingCommentRanges(fullText, 0);
-    if (commentRanges?.[0]) {
-        if (commentRanges.length > 1) {
-            consoleLog.fatal('Multiple comments found for property.');
-        }
-        const commentRange = commentRanges[0];
-        const comment = fullText.slice(commentRange.pos, commentRange.end);
-        if (comment.includes(untranslatedMark)) {
-            return true;
-        }
-        consoleLog.warn('Unsupported comment:', comment);
-    }
-    return false;
-};
-const untranslatedMark = 'UNTRANSLATED';
-/**
- * Given a entrypoint file path of a language, parse the nested object of
- * phrases and the file structure.
- *
- * @example
- * Given the following file:
- *
- * ```ts
- * import errors from './errors/index.js';
- *
- * const translation = {
- *   // UNTRANSLATED
- *   page_title: 'Applications',
- *   errors,
- * };
- * ```
- *
- * The returned object will be:
- *
- * ```ts
- * {
- *   page_title: ['Anwendungen', false],
- *   errors: {
- *     page_not_found: ['Seite nicht gefunden', true],
- *   },
- * }
- * ```
- *
- * And the file structure will be:
- *
- * ```ts
- * {
- *   errors: {
- *     filePath: './errors/index.js',
- *     structure: {},
- *   },
- * }
- * ```
- *
- * @param filePath The entrypoint file path of a language
- *
- * @returns A tuple of the nested object of phrases and the file structure
- *
- */
-export const parseLocaleFiles = (filePath) => {
-    const content = readFileSync(filePath, 'utf8');
-    const ast = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-    const importIdentifierPath = new Map();
-    const traverseNode = (node, nestedObject, fileStructure) => {
-        /**
-         * Handle property assignment in object literal expression:
-         *
-         * - Shorthand property assignments (e.g. `{ errors }`) are treated as import
-         * - Property assignments will be categorized per its initializer:
-         *   - Object literal expressions (e.g. `{ errors: { page_not_found: 'Page not found' } }`)
-         *     will be treated as nested object
-         *   - String literals (e.g. `{ page_title: 'Applications' }`) or no substitution template
-         *     literals (e.g. `{ page_title: `Applications` }`) will be treated as string
-         *   - Others are not supported, and will exit with error
-         */
-        const handleProperty = (property) => {
-            // Treat shorthand property assignment as import
-            if (ts.isShorthandPropertyAssignment(property)) {
-                const key = property.name.getText();
-                const importPath = importIdentifierPath.get(key);
-                if (!importPath) {
-                    consoleLog.fatal(`Cannot find import path for ${key} in ${filePath}`);
-                }
-                const resolvedPath = path.resolve(path.dirname(filePath), importPath);
-                // Recursively parse the nested object from the imported file
-                const [phrases, structure] = parseLocaleFiles(resolvedPath);
-                /* eslint-disable @silverhand/fp/no-mutation */
-                nestedObject[key] = phrases;
-                fileStructure[key] = {
-                    filePath: importPath,
-                    structure,
-                };
-                /* eslint-enable @silverhand/fp/no-mutation */
-            }
-            if (ts.isPropertyAssignment(property)) {
-                const key = property.name.getText();
-                // Nested object, recursively parse it
-                if (ts.isObjectLiteralExpression(property.initializer)) {
-                    const [phrases, structure] = traverseNode(property.initializer, {}, {});
-                    /* eslint-disable @silverhand/fp/no-mutation */
-                    nestedObject[key] = phrases;
-                    fileStructure[key] = { structure };
-                    /* eslint-enable @silverhand/fp/no-mutation */
-                }
-                else if (ts.isArrayLiteralExpression(property.initializer)) {
-                    const elements = property.initializer.elements.map((element) => {
-                        if (ts.isStringLiteralLike(element)) {
-                            return [
-                                [element.getText(), !hasLeadingUntranslatedComment(element.getFullText())],
-                                {},
-                            ];
-                        }
-                        return traverseNode(element, {}, {});
-                    });
-                    /* eslint-disable @silverhand/fp/no-mutation */
-                    nestedObject[key] = Object.fromEntries(elements.map(([phrases], index) => [index, phrases]));
-                    fileStructure[key] = {
-                        structure: Object.fromEntries(elements.map(([, structure], index) => [index, { structure }])),
-                    };
-                    /* eslint-enable @silverhand/fp/no-mutation */
-                }
-                else {
-                    const value = getValue(property);
-                    // eslint-disable-next-line @silverhand/fp/no-mutation
-                    nestedObject[key] = [value, !hasLeadingUntranslatedComment(property.getFullText())];
-                }
-            }
-        };
-        if (ts.isImportDeclaration(node)) {
-            const importPath = node.moduleSpecifier.getText().slice(1, -1).replace('.js', '.ts');
-            const importIdentifier = node.importClause?.getText();
-            // Assuming only default import is used
-            if (importIdentifier) {
-                importIdentifierPath.set(importIdentifier, importPath);
-            }
-        }
-        else if (ts.isObjectLiteralExpression(node)) {
-            for (const property of node.properties) {
-                handleProperty(property);
-            }
-        }
-        else {
-            node.forEachChild((child) => {
-                traverseNode(child, nestedObject, fileStructure);
-            });
-        }
-        return [nestedObject, fileStructure];
-    };
-    return traverseNode(ast, {}, {});
-};
-const getIdentifier = (filePath) => {
-    const filename = path.basename(filePath, '.ts');
-    return (filename === 'index' ? path.basename(path.dirname(filePath)) : filename).replaceAll('-', '_');
-};
-/** Traverse the file structure and return an array of imports in the current file. */
-const getCurrentFileImports = (fileStructure) => {
-    const imports = new Set();
-    for (const [key, value] of Object.entries(fileStructure)) {
-        // If the key has a file path, treat it as an import and stop traversing
-        // since it's pointing to another file
-        if (value.filePath) {
-            imports.add([key, value.filePath]);
-        }
-        // Otherwise, recursively traverse the nested object
-        else {
-            for (const importEntry of getCurrentFileImports(value.structure)) {
-                imports.add(importEntry);
-            }
-        }
-    }
-    return [...imports];
-};
-/**
- * Recursively traverse the nested object of phrases and the file structure of
- * the baseline language, and generate the target language directory with the
- * same file structure.
- *
- * Values of the nested object will be replaced with the values of the target
- * language if the key exists; otherwise, the value of the baseline language
- * will be used.
- *
- * @param baseline The baseline language tuple
- * @param targetObject The target language nested object
- * @param targetFilePath The target language entrypoint file path
- * @param isRoot Whether the target file is the root entrypoint
- */
-/* eslint-disable no-await-in-loop */
-const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = false) => {
-    const [, baselineStructure] = baseline;
-    const targetDirectory = path.dirname(targetFilePath);
-    await fs.mkdir(targetDirectory, { recursive: true });
-    await fs.writeFile(targetFilePath, '', { flag: 'w+' });
-    if (isRoot) {
-        await fs.appendFile(targetFilePath, "import { type DeepPartial } from '@silverhand/essentials';\n\nimport type { LocalePhrase } from '../../types.js';\n\n");
-    }
-    // Write imports first
-    const baselineEntries = getCurrentFileImports(baselineStructure);
-    for (const [key, value] of baselineEntries
-        .slice()
-        .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))) {
-        const importPath = path.join(targetDirectory, value);
-        await fs.appendFile(targetFilePath, `import ${key} from './${path
-            .relative(targetDirectory, importPath)
-            .replace('.ts', '.js')}';\n`);
-    }
-    // Add a newline between imports and the object
-    if (baselineEntries.length > 0) {
-        await fs.appendFile(targetFilePath, '\n');
-    }
-    // Write the object
-    const identifier = getIdentifier(targetFilePath);
-    await fs.appendFile(targetFilePath, `const ${identifier} = {\n`);
-    // Recursively traverse the nested object of phrases and the file structure
-    // of the baseline language
-    // eslint-disable-next-line complexity
-    const traverseObject = async (baseline, targetObject, tabSize) => {
-        const [baselineObject, baselineStructure] = baseline;
-        const isBaselineArray = 0 in baselineObject;
-        for (const [key, value] of Object.entries(baselineObject)) {
-            const existingValue = targetObject[key];
-            const keyOutput = isBaselineArray ? '' : `${key}: `;
-            if (Array.isArray(value)) {
-                const [phrase] = value;
-                // If the key exists in the target language and the value is a translated
-                // string, use the value of the target language; otherwise, use the value
-                // of the baseline language and add a comment to indicate that the phrase
-                // is untranslated to help identify missing translations.
-                if (Array.isArray(existingValue) && existingValue[1]) {
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${keyOutput}${existingValue[0]},\n`);
-                }
-                else {
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}/** ${untranslatedMark} */\n`);
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${keyOutput}${phrase},\n`);
-                }
-            }
-            // Not a string, treat it as a nested object or an import
-            else {
-                const keyStructure = baselineStructure[key];
-                // If the key has a file structure, treat it as an import
-                if (keyStructure?.filePath) {
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key},\n`);
-                    await traverseNode([value, keyStructure.structure], Array.isArray(existingValue) ? {} : existingValue ?? {}, path.join(targetDirectory, keyStructure.filePath));
-                }
-                // Otherwise, treat it as a nested object or array.
-                else {
-                    const isValueArray = 0 in value;
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${keyOutput}${isValueArray ? '[' : '{'}\n`);
-                    await traverseObject([value, keyStructure?.structure ?? {}], Array.isArray(existingValue) ? {} : existingValue ?? {}, tabSize + 2);
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${isValueArray ? ']' : '}'},\n`);
-                }
-            }
-        }
-    };
-    await traverseObject(baseline, targetObject, 2);
-    await (isRoot
-        ? fs.appendFile(targetFilePath, '} satisfies DeepPartial<LocalePhrase>;\n\n')
-        : fs.appendFile(targetFilePath, '};\n\n'));
-    await fs.appendFile(targetFilePath, `export default Object.freeze(${identifier});\n`);
-};
-/* eslint-enable no-await-in-loop */
-export const syncPhraseKeysAndFileStructure = async (baseline, targetLocale, targetDirectory) => {
-    const targetEntrypoint = path.join(targetDirectory, 'index.ts');
-    const isTargetLocaleExist = existsSync(targetEntrypoint);
-    const targetObject = isTargetLocaleExist ? parseLocaleFiles(targetEntrypoint)[0] : {};
-    const backupDirectory = targetDirectory + '.bak';
-    if (isTargetLocaleExist) {
-        await fs.rename(targetDirectory, backupDirectory);
-    }
-    else {
-        consoleLog.warn(`Cannot find ${targetLocale} entrypoint, creating one`);
-    }
-    await tryThat(traverseNode(baseline, targetObject, path.join(targetDirectory, 'index.ts'), true), (error) => {
-        consoleLog.plain();
-        consoleLog.error(error);
-        consoleLog.plain();
-        consoleLog.fatal(`Failed to sync keys for ${targetLocale}, the backup is at ${backupDirectory} for recovery`);
-    });
-    if (isTargetLocaleExist) {
-        await fs.rm(backupDirectory, { recursive: true });
-    }
-};

package/lib/commands/translate/sync.d.ts

@@ -1,10 +0,0 @@
-import type { CommandModule } from 'yargs';
-declare const sync: CommandModule<{
-    path?: string;
-    skipCoreCheck?: boolean;
-}, {
-    path?: string;
-    skipCoreCheck?: boolean;
-    package: string;
-}>;
-export default sync;

package/lib/commands/translate/sync.js

@@ -1,44 +0,0 @@
-import { languages } from '@logto/language-kit';
-import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
-import PQueue from 'p-queue';
-import { inquireInstancePath, lintLocaleFiles } from '../../utils.js';
-import { baseLanguage, syncTranslation } from './utils.js';
-const sync = {
-    command: ['sync'],
-    describe: 'Translate all untranslated phrases using ChatGPT. Note the environment variable `OPENAI_API_KEY` is required to work.',
-    builder: (yargs) => yargs.option('package', {
-        alias: 'pkg',
-        type: 'string',
-        describe: 'The package name of the phrases, e.g. `phrases` or `phrases-experience`',
-        default: 'phrases',
-    }),
-    handler: async ({ path: inputPath, skipCoreCheck, package: packageName }) => {
-        const queue = new PQueue({ concurrency: 10 });
-        const instancePath = await inquireInstancePath(inputPath, skipCoreCheck);
-        const packages = packageName ? [packageName] : ['phrases', 'phrases-experience'];
-        for (const languageTag of Object.keys(languages)) {
-            if (languageTag === baseLanguage) {
-                continue;
-            }
-            const baseOptions = {
-                instancePath,
-                verbose: false,
-                queue,
-            };
-            for (const packageName of packages) {
-                /* eslint-disable no-await-in-loop */
-                if (isPhrasesBuiltInLanguageTag(languageTag)) {
-                    await syncTranslation({
-                        ...baseOptions,
-                        packageName,
-                        languageTag,
-                    });
-                }
-                /* eslint-enable no-await-in-loop */
-            }
-        }
-        await queue.onIdle();
-        void lintLocaleFiles(instancePath, packageName);
-    },
-};
-export default sync;

package/lib/commands/translate/utils.d.ts

@@ -1,14 +0,0 @@
-import { type LanguageTag } from '@logto/language-kit';
-import PQueue from 'p-queue';
-export declare const baseLanguage = "en";
-export declare const readLocaleFiles: (directory: string) => Promise<string[]>;
-export declare const readBaseLocaleFiles: (directory: string) => Promise<string[]>;
-export type TranslationOptions = {
-    instancePath: string;
-    packageName: string;
-    languageTag: LanguageTag;
-    verbose?: boolean;
-    queue?: PQueue;
-};
-export declare const createFullTranslation: ({ instancePath, packageName, languageTag, verbose, queue, }: TranslationOptions) => Promise<void>;
-export declare const syncTranslation: ({ instancePath, packageName, languageTag, verbose, queue, }: TranslationOptions) => Promise<void>;