@tolgee/cli 1.4.0 → 2.0.0

package/dist/commands/push.js

@@ -1,9 +1,25 @@
-import { join } from 'path';
+import { extname, join } from 'path';
 import { readdir, readFile, stat } from 'fs/promises';
 import { Command, Option } from 'commander';
-import { HttpError } from '../client/errors.js';
+import { glob } from 'glob';
+import { loading, success, error, warn, exitWithError, } from '../utils/logger.js';
 import { askString } from '../utils/ask.js';
-import { loading, success, warn, error } from '../utils/logger.js';
+import { mapImportFormat } from '../utils/mapImportFormat.js';
+import { handleLoadableError } from '../client/TolgeeClient.js';
+async function allInPattern(pattern) {
+    const files = [];
+    const items = await glob(pattern);
+    for (const item of items) {
+        if ((await stat(item)).isDirectory()) {
+            files.push(...(await readDirectory(item)));
+        }
+        else {
+            const blob = await readFile(item);
+            files.push({ name: item, data: blob });
+        }
+    }
+    return files;
+}
 async function readDirectory(directory, base = '') {
     const files = [];
     const dir = await readdir(directory);
@@ -21,100 +37,102 @@ async function readDirectory(directory, base = '') {
     }
     return files;
 }
-function getConflictingLanguages(result) {
-    const conflicts = [];
-    const languages = result.result?._embedded?.languages;
-    if (languages) {
-        for (const l of languages) {
-            if (l.conflictCount) {
-                conflicts.push(l.id);
-            }
-        }
-    }
-    return conflicts;
-}
 async function promptConflicts(opts) {
-    const projectId = opts.client.getProjectId();
-    const resolveUrl = new URL(`/projects/${projectId}/import`, opts.apiUrl).href;
-    if (opts.forceMode === 'NO') {
-        error(`There are conflicts in the import. You can resolve them and complete the import here: ${resolveUrl}.`);
-        process.exit(1);
+    if (opts.forceMode === 'NO_FORCE') {
+        exitWithError(`There are conflicts in the import and the force mode is set to "NO_FORCE". Set it to "KEEP" or "OVERRIDE" to continue.`);
     }
     if (opts.forceMode) {
         return opts.forceMode;
     }
     if (!process.stdout.isTTY) {
-        error(`There are conflicts in the import. Please specify a --force-mode, or resolve them in your browser at ${resolveUrl}.`);
-        process.exit(1);
+        exitWithError(`There are conflicts in the import. Please specify a --force-mode.`);
     }
     warn('There are conflicts in the import. What do you want to do?');
     const resp = await askString('Type "KEEP" to preserve the version on the server, "OVERRIDE" to use the version from the import, and nothing to abort: ');
     if (resp !== 'KEEP' && resp !== 'OVERRIDE') {
-        error(`Aborting. You can resolve the conflicts and complete the import here: ${resolveUrl}`);
-        process.exit(1);
+        exitWithError(`Aborting.`);
     }
     return resp;
 }
-async function prepareImport(client, files) {
-    return loading('Deleting import...', client.import.deleteImportIfExists()).then(() => loading('Uploading files...', client.import.addFiles({ files: files })));
-}
-async function resolveConflicts(client, locales, method) {
-    for (const locale of locales) {
-        if (method === 'KEEP') {
-            await client.import.conflictsKeepExistingAll(locale);
-        }
-        else {
-            await client.import.conflictsOverrideAll(locale);
-        }
-    }
+async function importData(client, data) {
+    return loading('Uploading files...', client.import.import(data));
 }
-async function applyImport(client) {
-    try {
-        await loading('Applying changes...', client.import.applyImport());
-    }
-    catch (e) {
-        if (e instanceof HttpError && e.response.statusCode === 400) {
-            error("Some of the imported languages weren't recognized. Please create a language with corresponding tag in the Tolgee Platform.");
-            return;
-        }
-        throw e;
+async function readRecords(matchers) {
+    const result = [];
+    for (const matcher of matchers) {
+        const files = await allInPattern(matcher.path);
+        files.forEach((file) => {
+            result.push({
+                ...matcher,
+                data: file.data,
+                name: file.name,
+            });
+        });
     }
+    return result;
 }
-async function pushHandler(path) {
+const pushHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    try {
-        const stats = await stat(path);
-        if (!stats.isDirectory()) {
-            error('The specified path is not a directory.');
-            process.exit(1);
-        }
+    if (!config.push?.files) {
+        throw new Error('Missing option `push.files` in configuration file.');
     }
-    catch (e) {
-        if (e.code === 'ENOENT') {
-            error('The specified path does not exist.');
-            process.exit(1);
+    const filteredMatchers = config.push.files.filter((r) => {
+        if (opts.languages && !opts.languages.includes(r.language)) {
+            return false;
         }
-        throw e;
-    }
-    const files = await loading('Reading files...', readDirectory(path));
+        if (opts.namespaces && !opts.namespaces.includes(r.namespace ?? '')) {
+            return false;
+        }
+        return true;
+    });
+    const files = await loading('Reading files...', readRecords(filteredMatchers));
     if (files.length === 0) {
         error('Nothing to import.');
         return;
     }
-    const result = await prepareImport(opts.client, files);
-    const conflicts = getConflictingLanguages(result);
-    if (conflicts.length) {
-        const resolveMethod = await promptConflicts(opts);
-        await loading('Resolving conflicts...', resolveConflicts(opts.client, conflicts, resolveMethod));
+    const params = {
+        forceMode: opts.forceMode,
+        overrideKeyDescriptions: opts.overrideKeyDescriptions,
+        convertPlaceholdersToIcu: opts.convertPlaceholdersToIcu,
+        tagNewKeys: opts.tagNewKeys ?? [],
+        fileMappings: files.map((f) => {
+            const format = mapImportFormat(opts.format, extname(f.name));
+            return {
+                fileName: f.name,
+                format: format,
+                languageTag: f.language,
+                namespace: f.namespace ?? '',
+            };
+        }),
+        removeOtherKeys: opts.removeOtherKeys,
+    };
+    const attempt1 = await loading('Importing...', importData(opts.client, {
+        files,
+        params,
+    }));
+    if (attempt1.error) {
+        if (attempt1.error.code !== 'conflict_is_not_resolved') {
+            handleLoadableError(attempt1);
+        }
+        const forceMode = await promptConflicts(opts);
+        const attempt2 = await loading('Overriding...', importData(opts.client, {
+            files,
+            params: { ...params, forceMode },
+        }));
+        handleLoadableError(attempt2);
     }
-    await applyImport(opts.client);
     success('Done!');
-}
-export default new Command()
+};
+export default (config) => new Command()
     .name('push')
     .description('Pushes translations to Tolgee')
-    .argument('<path>', 'Path to the files to push to Tolgee')
     .addOption(new Option('-f, --force-mode <mode>', 'What should we do with possible conflicts? If unspecified, the user will be prompted interactively, or the command will fail when in non-interactive')
-    .choices(['OVERRIDE', 'KEEP', 'NO'])
+    .choices(['OVERRIDE', 'KEEP', 'NO_FORCE'])
     .argParser((v) => v.toUpperCase()))
-    .action(pushHandler);
+    .addOption(new Option('--override-key-descriptions', 'Override existing key descriptions from local files (only relevant for some formats).').default(config.push?.overrideKeyDescriptions ?? true))
+    .addOption(new Option('--convert-placeholders-to-icu', 'Convert placeholders in local files to ICU format.').default(config.push?.convertPlaceholdersToIcu ?? true))
+    .addOption(new Option('-l, --languages <languages...>', 'Specifies which languages should be pushed (see push.files in config).').default(config.push?.languages))
+    .addOption(new Option('-n, --namespaces <namespaces...>', 'Specifies which namespaces should be pushed (see push.files in config).').default(config.push?.namespaces))
+    .addOption(new Option('--tag-new-keys <tags...>', 'Specify tags that will be added to newly created keys.').default(config.push?.tagNewKeys))
+    .addOption(new Option('--remove-other-keys', 'Remove keys which are not present in the import.').default(false))
+    .action(pushHandler(config));

package/dist/commands/sync/compare.js

@@ -3,15 +3,20 @@ import ansi from 'ansi-colors';
 import { compareKeys, printKey } from './syncUtils.js';
 import { extractKeysOfFiles, filterExtractionResult, } from '../../extractor/runner.js';
 import { dumpWarnings } from '../../extractor/warnings.js';
-import { EXTRACTOR } from '../../options.js';
-import { loading } from '../../utils/logger.js';
-import { FILE_PATTERNS } from '../../arguments.js';
-async function compareHandler(filesPatterns) {
+import { exitWithError, loading } from '../../utils/logger.js';
+import { handleLoadableError } from '../../client/TolgeeClient.js';
+const asyncHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(filesPatterns, opts.extractor));
+    const patterns = opts.patterns?.length ? opts.patterns : config.patterns;
+    if (!patterns?.length) {
+        exitWithError('Missing argument <patterns>');
+    }
+    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
     dumpWarnings(rawKeys);
     const localKeys = filterExtractionResult(rawKeys);
-    const remoteKeys = await opts.client.project.fetchAllKeys();
+    const loadable = await opts.client.GET('/v2/projects/{projectId}/all-keys', { params: { path: { projectId: opts.client.getProjectId() } } });
+    handleLoadableError(loadable);
+    const remoteKeys = loadable.data._embedded.keys ?? [];
     const diff = compareKeys(localKeys, remoteKeys);
     if (!diff.added.length && !diff.removed.length) {
         console.log(ansi.green('Your code project is in sync with the associated Tolgee project!'));
@@ -37,10 +42,8 @@ async function compareHandler(filesPatterns) {
         console.log('');
     }
     console.log('Run `tolgee sync` to synchronize the projects.');
-}
-export default new Command()
+};
+export default (config) => new Command()
     .name('compare')
     .description('Compares the keys in your code project and in the Tolgee project.')
-    .addArgument(FILE_PATTERNS)
-    .addOption(EXTRACTOR)
-    .action(compareHandler);
+    .action(asyncHandler(config));

package/dist/commands/sync/sync.js

@@ -3,59 +3,70 @@ import ansi from 'ansi-colors';
 import { extractKeysOfFiles, filterExtractionResult, } from '../../extractor/runner.js';
 import { dumpWarnings } from '../../extractor/warnings.js';
 import { compareKeys, printKey } from './syncUtils.js';
-import { overwriteDir } from '../../utils/overwriteDir.js';
+import { prepareDir } from '../../utils/prepareDir.js';
 import { unzipBuffer } from '../../utils/zip.js';
 import { askBoolean } from '../../utils/ask.js';
-import { loading, error } from '../../utils/logger.js';
-import { EXTRACTOR } from '../../options.js';
-import { FILE_PATTERNS } from '../../arguments.js';
+import { loading, exitWithError } from '../../utils/logger.js';
+import { handleLoadableError, } from '../../client/TolgeeClient.js';
 async function backup(client, dest) {
-    const blob = await client.export.export({
+    const loadable = await client.export.export({
         format: 'JSON',
+        supportArrays: false,
         filterState: ['UNTRANSLATED', 'TRANSLATED', 'REVIEWED'],
         structureDelimiter: '',
     });
+    handleLoadableError(loadable);
+    const blob = loadable.data;
     await unzipBuffer(blob, dest);
 }
 async function askForConfirmation(keys, operation) {
     if (!process.stdout.isTTY) {
-        error('You must run this command interactively, or specify --yes to proceed.');
-        process.exit(1);
+        exitWithError('You must run this command interactively, or specify --yes to proceed.');
     }
     const str = `The following keys will be ${operation}:`;
     console.log(operation === 'created' ? ansi.bold.green(str) : ansi.bold.red(str));
     keys.forEach((k) => printKey(k, operation === 'deleted'));
     const shouldContinue = await askBoolean('Does this look correct?', true);
     if (!shouldContinue) {
-        error('Aborting.');
-        process.exit(1);
+        exitWithError('Aborting.');
     }
 }
-async function syncHandler(filesPatterns) {
+const syncHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(filesPatterns, opts.extractor));
+    const patterns = opts.patterns?.length ? opts.patterns : config.patterns;
+    if (!patterns?.length) {
+        exitWithError('Missing argument <patterns>');
+    }
+    const rawKeys = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
     const warnCount = dumpWarnings(rawKeys);
     if (!opts.continueOnWarning && warnCount) {
         console.log(ansi.bold.red('Aborting as warnings have been emitted.'));
         process.exit(1);
     }
     const localKeys = filterExtractionResult(rawKeys);
-    const remoteKeys = await opts.client.project.fetchAllKeys();
+    const allKeysLoadable = await opts.client.GET('/v2/projects/{projectId}/all-keys', {
+        params: { path: { projectId: opts.client.getProjectId() } },
+    });
+    handleLoadableError(allKeysLoadable);
+    const remoteKeys = allKeysLoadable.data?._embedded?.keys ?? [];
     const diff = compareKeys(localKeys, remoteKeys);
     if (!diff.added.length && !diff.removed.length) {
         console.log(ansi.green('Your code project is in sync with the associated Tolgee project!'));
         process.exit(0);
     }
     // Load project settings. We're interested in the default locale here.
-    const { baseLanguage } = await opts.client.project.fetchProjectInformation();
+    const projectLoadable = await opts.client.GET('/v2/projects/{projectId}', {
+        params: { path: { projectId: opts.client.getProjectId() } },
+    });
+    handleLoadableError(projectLoadable);
+    const baseLanguage = projectLoadable.data.baseLanguage;
     if (!baseLanguage) {
         // I'm highly unsure how we could reach this state, but this is what the OAI spec tells me ¯\_(ツ)_/¯
-        error('Your project does not have a base language!');
-        process.exit(1);
+        exitWithError('Your project does not have a base language!');
     }
     // Prepare backup
     if (opts.backup) {
-        await overwriteDir(opts.backup, opts.yes);
+        await prepareDir(opts.backup, opts.yes);
         await loading('Backing up Tolgee project', backup(opts.client, opts.backup));
     }
     // Create new keys
@@ -70,7 +81,11 @@ async function syncHandler(filesPatterns) {
                 ? { [baseLanguage.tag]: key.defaultValue }
                 : {},
         }));
-        await loading('Creating missing keys...', opts.client.project.createBulkKey(keys));
+        const loadable = await loading('Creating missing keys...', opts.client.POST('/v2/projects/{projectId}/keys/import', {
+            params: { path: { projectId: opts.client.getProjectId() } },
+            body: { keys },
+        }));
+        handleLoadableError(loadable);
     }
     if (opts.removeUnused) {
         // Delete unused keys.
@@ -79,7 +94,11 @@ async function syncHandler(filesPatterns) {
                 await askForConfirmation(diff.removed, 'deleted');
             }
             const ids = await diff.removed.map((k) => k.id);
-            await loading('Deleting unused keys...', opts.client.project.deleteBulkKeys(ids));
+            const loadable = await loading('Deleting unused keys...', opts.client.DELETE('/v2/projects/{projectId}/keys', {
+                params: { path: { projectId: opts.client.getProjectId() } },
+                body: { ids },
+            }));
+            handleLoadableError(loadable);
         }
     }
     console.log(ansi.bold.green('Sync complete!'));
@@ -93,14 +112,12 @@ async function syncHandler(filesPatterns) {
     if (opts.backup) {
         console.log(ansi.blueBright(`A backup of the project prior to the synchronization has been dumped in ${opts.backup}.`));
     }
-}
-export default new Command()
+};
+export default (config) => new Command()
     .name('sync')
     .description('Synchronizes the keys in your code project and in the Tolgee project, by creating missing keys and optionally deleting unused ones. For a dry-run, use `tolgee compare`.')
-    .addArgument(FILE_PATTERNS)
-    .addOption(EXTRACTOR)
-    .option('-B, --backup <path>', 'Path where a backup should be downloaded before performing the sync. If something goes wrong, the backup can be used to restore the project to its previous state.')
+    .option('-B, --backup <path>', 'Store translation files backup (only translation files, not states, comments, tags, etc.). If something goes wrong, the backup can be used to restore the project to its previous state.')
     .option('--continue-on-warning', 'Set this flag to continue the sync if warnings are detected during string extraction. By default, as warnings may indicate an invalid extraction, the CLI will abort the sync.')
     .option('-Y, --yes', 'Skip prompts and automatically say yes to them. You will not be asked for confirmation before creating/deleting keys.')
     .option('--remove-unused', 'Also delete unused keys from the Tolgee project.')
-    .action(syncHandler);
+    .action(syncHandler(config));

package/dist/commands/tag.js

@@ -0,0 +1,49 @@
+import { Command, Option } from 'commander';
+import { handleLoadableError } from '../client/TolgeeClient.js';
+import { exitWithError, loading, success } from '../utils/logger.js';
+import { extractKeysOfFiles } from '../extractor/runner.js';
+const tagHandler = (config) => async function () {
+    const opts = this.optsWithGlobals();
+    let extractedKeys;
+    if (opts.filterExtracted || opts.filterNotExtracted) {
+        if (opts.filterExtracted && opts.filterNotExtracted) {
+            exitWithError('Use either "--filter-extracted" or "--filter-not-extracted", not both');
+        }
+        const patterns = opts.patterns;
+        if (!patterns?.length) {
+            exitWithError('Missing option --patterns or config.patterns option');
+        }
+        const extracted = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
+        const keys = [...extracted.values()].flatMap((item) => item.keys);
+        extractedKeys = keys.map((key) => ({
+            name: key.keyName,
+            namespace: key.namespace,
+        }));
+    }
+    const loadable = await loading('Tagging...', opts.client.PUT('/v2/projects/{projectId}/tag-complex', {
+        params: { path: { projectId: opts.client.getProjectId() } },
+        body: {
+            filterTag: opts.filterTag,
+            filterTagNot: opts.filterNoTag,
+            tagFiltered: opts.tag,
+            tagOther: opts.tagOther,
+            untagFiltered: opts.untag,
+            untagOther: opts.untagOther,
+            filterKeys: opts.filterExtracted ? extractedKeys : undefined,
+            filterKeysNot: opts.filterNotExtracted ? extractedKeys : undefined,
+        },
+    }));
+    handleLoadableError(loadable);
+    success('Done!');
+};
+export default (config) => new Command('tag')
+    .description('Update tags in your project.')
+    .addOption(new Option('--filter-extracted', 'Extract keys from code and filter by it.'))
+    .addOption(new Option('--filter-not-extracted', 'Extract keys from code and filter them out.'))
+    .addOption(new Option('--filter-tag <tags...>', 'Filter only keys with tag. Use * as a wildcard.'))
+    .addOption(new Option('--filter-no-tag <tags...>', 'Filter only keys without tag. Use * as a wildcard.'))
+    .addOption(new Option('--tag <tags...>', 'Add tag to filtered keys.'))
+    .addOption(new Option('--tag-other <tags...>', 'Tag keys which are not filtered.'))
+    .addOption(new Option('--untag <tags...>', 'Remove tag from filtered keys. Use * as a wildcard.'))
+    .addOption(new Option('--untag-other <tags...>', 'Remove tag from keys which are not filtered. Use * as a wildcard.'))
+    .action(tagHandler(config));

package/dist/config/tolgeerc.js

@@ -1,61 +1,84 @@
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
-import { resolve } from 'path';
+import { Validator } from 'jsonschema';
+import { readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+import { error, exitWithError } from '../utils/logger.js';
 import { existsSync } from 'fs';
-import { SDKS } from '../constants.js';
 const explorer = cosmiconfig('tolgee', {
     loaders: {
         noExt: defaultLoaders['.json'],
     },
 });
-function parseConfig(rc) {
-    if (typeof rc !== 'object' || Array.isArray(rc)) {
-        throw new Error('Invalid config: config is not an object.');
-    }
-    const cfg = {};
-    if ('apiUrl' in rc) {
-        if (typeof rc.apiUrl !== 'string') {
-            throw new Error('Invalid config: apiUrl is not a string');
-        }
+function parseConfig(input, configDir) {
+    const rc = { ...input };
+    if (rc.apiUrl !== undefined) {
         try {
-            cfg.apiUrl = new URL(rc.apiUrl);
+            new URL(rc.apiUrl);
         }
         catch (e) {
             throw new Error('Invalid config: apiUrl is an invalid URL');
         }
     }
-    if ('projectId' in rc) {
-        cfg.projectId = Number(rc.projectId); // Number("") returns 0
-        if (!Number.isInteger(cfg.projectId) || cfg.projectId <= 0) {
+    if (rc.projectId !== undefined) {
+        const projectId = Number(rc.projectId); // Number("") returns 0
+        if (!Number.isInteger(projectId) || projectId <= 0) {
             throw new Error('Invalid config: projectId should be an integer representing your project Id');
         }
     }
-    if ('sdk' in rc) {
-        if (!SDKS.includes(rc.sdk)) {
-            throw new Error(`Invalid config: invalid sdk. Must be one of: ${SDKS.join(' ')}`);
+    if (rc.extractor !== undefined) {
+        rc.extractor = resolve(configDir, rc.extractor);
+        if (!existsSync(rc.extractor)) {
+            throw new Error(`Invalid config: extractor points to a file that does not exists (${rc.extractor})`);
         }
-        cfg.sdk = rc.sdk;
     }
-    if ('extractor' in rc) {
-        if (typeof rc.extractor !== 'string') {
-            throw new Error('Invalid config: extractor is not a string');
+    if (rc.delimiter !== undefined) {
+        rc.delimiter = rc.delimiter || '';
+    }
+    // convert relative paths in config to absolute
+    // so it's always relative to config location
+    if (rc.push?.files) {
+        rc.push.files = rc.push.files.map((r) => ({
+            ...r,
+            path: resolve(configDir, r.path),
+        }));
+    }
+    if (rc.pull?.path !== undefined) {
+        rc.pull.path = resolve(configDir, rc.pull.path);
+    }
+    if (rc.patterns !== undefined) {
+        rc.patterns = rc.patterns.map((pattern) => resolve(configDir, pattern));
+    }
+    return rc;
+}
+async function getSchema() {
+    const path = join(fileURLToPath(new URL('.', import.meta.url)), '..', '..', 'schema.json');
+    return JSON.parse((await readFile(path)).toString());
+}
+export default async function loadTolgeeRc(path) {
+    let res;
+    if (path) {
+        try {
+            res = await explorer.load(path);
         }
-        const extractorPath = resolve(rc.extractor);
-        if (!existsSync(extractorPath)) {
-            throw new Error(`Invalid config: extractor points to a file that does not exists (${extractorPath})`);
+        catch (e) {
+            error(e.message);
+            throw new Error(`Can't open config file on path "${path}"`);
         }
-        cfg.extractor = extractorPath;
     }
-    if ('delimiter' in rc) {
-        if (typeof rc.delimiter !== 'string' && rc.delimiter !== null) {
-            throw new Error('Invalid config: delimiter is not a string');
-        }
-        cfg.delimiter = rc.delimiter || '';
+    else {
+        res = await explorer.search();
     }
-    return cfg;
-}
-export default async function loadTolgeeRc() {
-    const res = await explorer.search();
     if (!res || res.isEmpty)
         return null;
-    return parseConfig(res.config);
+    const config = parseConfig(res.config, dirname(path || '.'));
+    const validator = new Validator();
+    const schema = await getSchema();
+    const result = validator.validate(config, schema);
+    if (result.errors.length) {
+        const { message, property } = result.errors[0];
+        const errMessage = `Tolgee config: '${property.replace('instance.', '')}' ${message}`;
+        exitWithError(errMessage);
+    }
+    return config;
 }

package/dist/constants.js

@@ -8,4 +8,3 @@ export const USER_AGENT = `Tolgee-CLI/${VERSION} (+https://github.com/tolgee/tol
 export const DEFAULT_API_URL = new URL('https://app.tolgee.io');
 export const API_KEY_PAT_PREFIX = 'tgpat_';
 export const API_KEY_PAK_PREFIX = 'tgpak_';
-export const SDKS = ['react', 'vue', 'svelte'];

package/dist/extractor/machines/vue/decoder.js

@@ -17,7 +17,7 @@ export default createMachine({
         setup: [],
         script: [],
         template: [],
-        scriptSetupConsumed: false,
+        scriptSetupConsumed: false, // <script setup>
         invalidSetup: null,
         depth: 0,
         memoizedDepth: 0,

package/dist/options.js

@@ -1,7 +1,6 @@
 import { existsSync } from 'fs';
 import { resolve } from 'path';
 import { Option, InvalidArgumentError } from 'commander';
-import { DEFAULT_API_URL } from './constants.js';
 function parseProjectId(v) {
     const val = Number(v);
     if (!Number.isInteger(val) || val < 1) {
@@ -25,10 +24,35 @@ function parsePath(v) {
     return path;
 }
 export const API_KEY_OPT = new Option('-ak, --api-key <key>', 'Tolgee API Key. Can be a Project API Key or a Personal Access Token.').env('TOLGEE_API_KEY');
-export const PROJECT_ID_OPT = new Option('-p, --project-id <id>', 'Project ID. Only required when using a Personal Access Token.')
-    .default(-1)
-    .argParser(parseProjectId);
-export const API_URL_OPT = new Option('-au, --api-url <url>', 'The url of Tolgee API.')
-    .default(DEFAULT_API_URL)
-    .argParser(parseUrlArgument);
+export const PROJECT_ID_OPT = new Option('-p, --project-id <id>', 'Project ID. Only required when using a Personal Access Token.').argParser(parseProjectId);
+export const API_URL_OPT = new Option('-au, --api-url <url>', 'The url of Tolgee API.').argParser(parseUrlArgument);
 export const EXTRACTOR = new Option('-e, --extractor <extractor>', `A path to a custom extractor to use instead of the default one.`).argParser(parsePath);
+export const CONFIG_OPT = new Option('-c, --config [config]', 'A path to tolgeerc config file.').argParser(parsePath);
+export const FORMAT_OPT = new Option('--format <format>', 'Localization files format.').choices([
+    'JSON_TOLGEE',
+    'JSON_ICU',
+    'JSON_JAVA',
+    'JSON_PHP',
+    'JSON_RUBY',
+    'JSON_C',
+    'PO_PHP',
+    'PO_C',
+    'PO_JAVA',
+    'PO_ICU',
+    'PO_RUBY',
+    'APPLE_STRINGS',
+    'APPLE_XLIFF',
+    'PROPERTIES_ICU',
+    'PROPERTIES_JAVA',
+    'ANDROID_XML',
+    'FLUTTER_ARB',
+    'YAML_RUBY',
+    'YAML_JAVA',
+    'YAML_ICU',
+    'YAML_PHP',
+    'XLIFF_ICU',
+    'XLIFF_JAVA',
+    'XLIFF_PHP',
+    'XLIFF_RUBY',
+]);
+export const FILE_PATTERNS = new Option('-pt, --patterns <patterns...>', 'File glob patterns to include (hint: make sure to escape it in quotes, or your shell might attempt to unroll some tokens like *)');

package/dist/utils/checkPathNotAFile.js

@@ -0,0 +1,16 @@
+import { stat } from 'fs/promises';
+import { exitWithError } from './logger.js';
+export async function checkPathNotAFile(path) {
+    try {
+        const stats = await stat(path);
+        if (!stats.isDirectory()) {
+            exitWithError('The specified path already exists and is not a directory.');
+        }
+    }
+    catch (e) {
+        // Ignore "file doesn't exist" error
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+    }
+}

package/dist/utils/getSingleOption.js

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+/**
+ * Get single option from arguments, without parsing the rest
+ */
+export function getSingleOption(option, args) {
+    const findOne = new Command();
+    findOne.allowUnknownOption().helpOption(false).addOption(option);
+    findOne.parse(args);
+    return findOne.opts()[option.name()];
+}

package/dist/utils/getStackTrace.js

@@ -0,0 +1,7 @@
+export const getStackTrace = () => {
+    const obj = {};
+    Error.captureStackTrace(obj, getStackTrace);
+    const stack = obj.stack;
+    const parts = stack.split('\n');
+    return parts.slice(2).join('\n');
+};