@esgettext/tools 1.2.0 → 1.3.1

package/dist/commands/init.js

@@ -0,0 +1,743 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Init = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util = __importStar(require("util"));
+const child_process = __importStar(require("child_process"));
+const mkdirp = __importStar(require("mkdirp"));
+const prompts_1 = require("@inquirer/prompts");
+const glob_1 = require("glob");
+const runtime_1 = require("@esgettext/runtime");
+const configuration_1 = require("../configuration");
+const package_json_1 = __importDefault(require("@npmcli/package-json"));
+const package_1 = require("../package");
+const optspec_1 = require("../optspec");
+const gtx = runtime_1.Textdomain.getInstance('com.cantanea.esgettext-tools');
+class Init {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(configuration) {
+        this.options = undefined;
+        this.packageJson = undefined;
+        this.configuration = configuration;
+    }
+    synopsis() {
+        return '';
+    }
+    description() {
+        return gtx._('Prepare a package to use esgettext.');
+    }
+    aliases() {
+        return [];
+    }
+    args() {
+        return {
+            force: {
+                alias: 'f',
+                type: 'boolean',
+                describe: gtx._('Overwrite existing files.'),
+            },
+            'dry-run': {
+                alias: 'n',
+                type: 'boolean',
+                describe: gtx._('Just print what would be done without writing anything; implies --verbose.'),
+            },
+            verbose: {
+                alias: 'V',
+                type: 'boolean',
+                describe: gtx._('Enable verbose output'),
+            },
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    additional(_) { }
+    init(argv) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = argv;
+            this.packageJson = yield configuration_1.ConfigurationFactory.getPackageJson();
+            this.options = options;
+            if (this.options.dryRun)
+                this.options.verbose = true;
+        });
+    }
+    setPrograms(config, setup) {
+        var _a, _b, _c, _d;
+        var _e, _f, _g, _h;
+        if (!config.programs)
+            config.programs = {};
+        const msgmergeOptions = setup.msgmergeOptions
+            .split(/ +/)
+            .map(option => option.replace(/^-+/, ''));
+        const msgfmtOptions = setup.msgfmtOptions
+            .split(/ +/)
+            .map(option => option.replace(/^-+/, ''));
+        if (setup.msgmerge !== 'msgmerge') {
+            (_a = (_e = config.programs).msgmerge) !== null && _a !== void 0 ? _a : (_e.msgmerge = {});
+            config.programs.msgmerge.path = setup.msgmerge;
+        }
+        else if (this.options.verbose) {
+            console.log(gtx._x("The tool '{tool}' is in your $PATH. No need to" +
+                ' save it in the configuration.', { tool: 'msgmerge' }));
+        }
+        if (msgmergeOptions.length > 0) {
+            (_b = (_f = config.programs).msgmerge) !== null && _b !== void 0 ? _b : (_f.msgmerge = {});
+            config.programs.msgmerge.options = msgmergeOptions;
+        }
+        if (setup.msgfmt !== 'msgfmt') {
+            (_c = (_g = config.programs).msgfmt) !== null && _c !== void 0 ? _c : (_g.msgfmt = {});
+            config.programs.msgfmt.path = setup.msgfmt;
+        }
+        else if (this.options.verbose) {
+            console.log(gtx._x("The tool '{tool}' is in your $PATH. No need to" +
+                ' save it in the configuration.', { tool: 'msgfmt' }));
+        }
+        if (msgfmtOptions.length > 0) {
+            (_d = (_h = config.programs).msgfmt) !== null && _d !== void 0 ? _d : (_h.msgfmt = {});
+            config.programs.msgfmt.options = msgfmtOptions;
+        }
+    }
+    getConfiguration(setup) {
+        var _a, _b;
+        const pkg = this.packageJson;
+        const verbose = this.options.verbose;
+        if (verbose) {
+            console.log(gtx._('Setting configuration values.'));
+        }
+        // We could actually initialize this in a smarter manner by setting
+        // all properties to empty objects.  But that does not compile because
+        // all of them are optiona.
+        const config = {};
+        if (!config.package)
+            config.package = {};
+        if (typeof pkg.name === 'undefined') {
+            config.package.name = setup.textdomain;
+        }
+        else {
+            config.package.name = pkg.name;
+        }
+        config.package.version = pkg.version;
+        config.package.textdomain = setup.textdomain;
+        let msgidBugsAddressFile = gtx._('Your input');
+        if (typeof ((_a = this.configuration.package) === null || _a === void 0 ? void 0 : _a['msgid-bugs-address']) !== 'undefined') {
+            config.package['msgid-bugs-address'] =
+                this.configuration.package['msgid-bugs-address'];
+            msgidBugsAddressFile = 'package.json: bugs';
+        }
+        let copyrightHolderFile = gtx._('Your input');
+        if (typeof ((_b = this.configuration.package) === null || _b === void 0 ? void 0 : _b['copyright-holder']) !== 'undefined') {
+            config.package['copyright-holder'] =
+                this.configuration.package['copyright-holder'];
+            copyrightHolderFile = 'package.json: people.author';
+        }
+        if (!config.po)
+            config.po = {};
+        config.po.directory = setup.poDirectory;
+        config.po.locales = [];
+        if (!config.install)
+            config.install = {};
+        config.install.directory = setup.localeDirectory;
+        this.setPrograms(config, setup);
+        if (this.options.verbose) {
+            console.log(gtx._('Validating the configuration.'));
+        }
+        if (!configuration_1.ConfigurationFactory.validate(config, {
+            jsConfigFile: gtx._('your input'),
+            msgidBugsAddressFile: msgidBugsAddressFile,
+            copyrightHolderFile: copyrightHolderFile,
+            versionFile: 'package.json',
+            nameFile: 'package.json',
+        }, runtime_1.Textdomain.locale)) {
+            this.error(gtx._('Please try again with option --verbose to see the origin of the above errors.'));
+            process.exit(1);
+        }
+        return config;
+    }
+    getJsonConfig(config, indent) {
+        return JSON.stringify(config, null, indent);
+    }
+    getJsConfig(config, setup, indent) {
+        var _a;
+        const header = setup.configFile === 'esgettext.config.mjs'
+            ? 'export default '
+            : 'module.exports = ';
+        const comment = gtx._x('Configuration for esgettext, created by {package} {version}.', {
+            package: package_1.Package.getName(),
+            version: 'v' + package_1.Package.getVersion(),
+        });
+        const body = util.inspect(config, {
+            depth: null,
+            maxArrayLength: null,
+            maxStringLength: null,
+        });
+        const bodyLines = body.split('\n');
+        const match = bodyLines[1].match(/^(\t| *)/);
+        const bodyIndent = (_a = match === null || match === void 0 ? void 0 : match.groups) === null || _a === void 0 ? void 0 : _a[1];
+        const indentedBody = body;
+        const code = `// ${comment}\n${header} ${indentedBody}`;
+        return code.replace(new RegExp(`^${bodyIndent}`, 'gm'), indent);
+    }
+    createPODirectory(setup) {
+        if (!fs.existsSync(setup.poDirectory)) {
+            console.log(gtx._x("Creating PO directory '{directory}'."));
+            if (!this.options.dryRun) {
+                mkdirp.sync(setup.poDirectory);
+            }
+        }
+        else if (this.options.verbose) {
+            console.log(gtx._x("PO directory '{directory}' already exists."));
+        }
+    }
+    writeFiles(config, setup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            this.createPODirectory(setup);
+            const pkg = yield package_json_1.default.load(process.cwd());
+            const content = pkg.content;
+            const newline = content[Symbol.for('newline')];
+            const indent = content[Symbol.for('indent')];
+            let serialized;
+            if (setup.configFile === 'package.json') {
+                content.esgettext = config;
+            }
+            else if (setup.configFile === 'esgettext.config.json') {
+                serialized = this.getJsonConfig(config, indent);
+            }
+            else {
+                serialized = this.getJsConfig(config, setup, indent);
+            }
+            if (this.options.verbose) {
+                console.log(gtx._x("Writing configuration to '{filename}'.", {
+                    filename: setup.configFile,
+                }));
+            }
+            if (typeof serialized !== 'undefined' && !this.options.dryRun) {
+                const data = serialized.replace('\n', newline);
+                fs.writeFileSync(setup.configFile, data);
+            }
+            if (this.options.verbose) {
+                console.log(gtx._x("Adding package '{package}' version '{version}' as a dependency.", {
+                    package: '@esgettext/runtime',
+                    version: `^${package_1.Package.getVersion()}`,
+                }));
+            }
+            const dependencies = Object.assign(Object.assign({}, pkg.content.dependencies), { '@esgettext/runtime': `^${package_1.Package.getVersion()}` });
+            if (this.options.verbose) {
+                console.log(gtx._x("Adding package '{package}' version {version} as a development dependencyy.", { package: '@esgettext/tools', version: `^${package_1.Package.getVersion()}` }));
+            }
+            const devDependencies = Object.assign(Object.assign({}, pkg.content.devDependencies), { '@esgettext/tools': `^${package_1.Package.getVersion()}` });
+            if (!((_a = pkg.content.devDependencies) === null || _a === void 0 ? void 0 : _a['npm-run-all']) &&
+                !((_b = pkg.content.dependencies) === null || _b === void 0 ? void 0 : _b['npm-run-all'])) {
+                if (this.options.verbose) {
+                    console.log(gtx._x("Adding package '{package}' version {version} as a development dependencyy.", { package: 'npm-run-all', version: package_1.Package.getNpmRunAllVersion() }));
+                }
+                devDependencies['npm-run-all'] = package_1.Package.getNpmRunAllVersion();
+            }
+            const potfilesOptions = this.potfilesOptions(setup).join(' ');
+            let directory = setup.poDirectory;
+            if (directory.includes(' ') || directory.includes('"')) {
+                directory = `"${directory.replace(/([\\""])/g, '\\$1')}"`;
+            }
+            const scripts = Object.assign(Object.assign({}, pkg.content.scripts), { esgettext: 'npm-run-all esgettext:potfiles esgettext:extract esgettext:update-po esgettext:update-mo esgettext:install', 'esgettext:potfiles': `esgettext potfiles ${potfilesOptions} >${setup.poDirectory}/POTFILES`, 'esgettext:extract': `esgettext extract --directory ${directory} --files-from=${directory}/POTFILES`, 'esgettext:update-po': `esgettext msgmerge-all`, 'esgettext:update-mo': `esgettext msgfmt-all`, 'esgettext:install': `esgettext install`, 'esgettext:addlang': `esgettext msginit` });
+            const peerDependencies = (_c = pkg.content.peerDependencies) !== null && _c !== void 0 ? _c : undefined;
+            const optionalDependencies = (_d = pkg.content.optionalDependencies) !== null && _d !== void 0 ? _d : undefined;
+            pkg.update({
+                scripts,
+                dependencies,
+                devDependencies,
+                peerDependencies,
+                optionalDependencies,
+            });
+            if (this.options.verbose) {
+                console.log(gtx._x("Writing updated '{filename}'.", { filename: 'package.json' }));
+            }
+            if (!this.options.dryRun) {
+                yield pkg.save();
+            }
+        });
+    }
+    installDependencies(setup) {
+        const command = `${setup.packageManager} install`;
+        if (this.options.verbose) {
+            console.log(gtx._x("Run '{command}'.", { command }));
+        }
+        if (!this.options.dryRun) {
+            child_process.execSync(command, {
+                stdio: ['ignore', process.stdout, process.stderr],
+                encoding: 'utf-8',
+            });
+        }
+    }
+    nextSteps(setup) {
+        if (this.options.verbose) {
+            console.log('');
+        }
+        console.log(gtx._('The next steps are:'));
+        console.log(gtx._('1) Mark translatable strings in your code like this "gtx._(\'Hello, world!\')".'));
+        console.log(gtx._x("2) Extract strings with '{command}' into '{filename}'.", {
+            command: 'npm run esgettext:update-po',
+            filename: `${setup.poDirectory}/${setup.textdomain}.pot`,
+        }));
+        console.log(gtx._x("3) Create a translation file with '{command}' (replace 'xy' with a language code like 'de' or 'pt_BR').", {
+            command: `msginit -l xy -i ${setup.poDirectory}/${setup.textdomain}.pot -o po/xy.po`,
+        }));
+        console.log(gtx._x('4) Translate the message with a PO editor of your choice.', {
+            command: `msginit -l xy -i ${setup.poDirectory}/${setup.textdomain}.pot -o po/xy.po`,
+        }));
+        console.log(gtx._x("5) Install the translation with '{command}'.", {
+            command: 'npm run esgettext:install',
+        }));
+        console.log();
+        console.log(gtx._x("The command '{command}' executes all steps of the translation workflow at once.", { command: 'npm run esgettext' }));
+    }
+    getGitFiles() {
+        try {
+            return child_process
+                .execSync('git ls-files', {
+                stdio: 'pipe',
+                encoding: 'utf-8',
+            })
+                .split(/[\r\n]+/);
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    potfilesOptions(setup) {
+        const hasNodeModules = fs.existsSync('node_modules');
+        let exclude = [];
+        if (hasNodeModules) {
+            exclude.push('node_modules');
+        }
+        if (this.options.verbose) {
+            console.log(gtx._('Analyzing source files.'));
+        }
+        if (typeof this.packageJson.main !== 'undefined' &&
+            this.packageJson.main.length) {
+            const dir = path.dirname(this.packageJson.main);
+            if (dir != '.') {
+                exclude.push(path.dirname(this.packageJson.main));
+            }
+        }
+        if (typeof this.packageJson.module !== 'undefined' &&
+            this.packageJson.module.length) {
+            const dir = path.dirname(this.packageJson.module);
+            if (dir != '.') {
+                exclude.push(path.dirname(this.packageJson.module));
+            }
+        }
+        if (typeof this.packageJson.browser !== 'undefined' &&
+            this.packageJson.browser.length) {
+            const dir = path.dirname(this.packageJson.browser);
+            if (dir != '.') {
+                exclude.push(path.dirname(this.packageJson.browser));
+            }
+        }
+        // sort | uniq for JavaScript.
+        exclude = exclude
+            .sort()
+            .filter((item, index) => {
+            return index === 0 || item !== exclude[index - 1];
+        })
+            .map(name => `${name}/**/*`);
+        let candidates = (0, glob_1.globSync)('./**/*.{js,mjs,cjs,jsx,ts,tsx}', {
+            ignore: exclude,
+        });
+        const gitFiles = this.getGitFiles();
+        if (gitFiles) {
+            if (this.options.verbose) {
+                console.log(gtx._('This is a git repo.  We will only translate files under version control.'));
+            }
+            candidates = candidates.filter(filename => gitFiles.includes(filename));
+        }
+        let hasTestDir = false;
+        let hasSpec = false;
+        for (const candidate of candidates) {
+            const parts = candidate.split('/');
+            if (!hasTestDir && parts[0].match(/^tests?$/)) {
+                if (this.options.verbose) {
+                    console.log(gtx._x('Looks like you have test files under {directory}. We will not translate them.'));
+                }
+                exclude.push(`${parts[0]}/*/**`);
+                hasTestDir = true;
+            }
+            if (!hasSpec && parts[parts.length - 1].match(/\.spec\./)) {
+                exclude.push(`**/*.spec.*`);
+                hasSpec = true;
+            }
+        }
+        const extenders = {};
+        let topLevelDirectories = candidates.map(name => {
+            var _a;
+            const parts = name.split('/');
+            const filename = parts[parts.length - 1];
+            const fparts = filename.split('.');
+            let tld;
+            if (parts.length === 1) {
+                tld = '.';
+            }
+            else {
+                tld = parts[0];
+            }
+            (_a = extenders[tld]) !== null && _a !== void 0 ? _a : (extenders[tld] = []);
+            extenders[tld].push(fparts[fparts.length - 1]);
+            return tld;
+        });
+        // And make them unique.
+        topLevelDirectories = topLevelDirectories.sort().filter((item, index) => {
+            return index === 0 || item !== topLevelDirectories[index - 1];
+        });
+        const options = [`--directory=${setup.poDirectory}`];
+        if (gitFiles) {
+            options.push('--git');
+        }
+        for (const pattern of exclude) {
+            options.push(`--exclude="${pattern}"`);
+        }
+        if (!topLevelDirectories.length) {
+            this.error(gtx._x("Warning! Could not find any source files.  Will use the pattern './src/**/*.{js,jsx,ts,tsx}."));
+            options.push('"./src/**/*.{js,jsx,ts,tsx}"');
+        }
+        else {
+            for (const tld in extenders) {
+                let x = extenders[tld];
+                x = x.sort().filter((item, index) => {
+                    return index === 0 || item !== x[index - 1];
+                });
+                if (x.length > 1) {
+                    options.push(`"./${tld}/**/*.{${x.join(',')}}"`);
+                }
+                else {
+                    options.push(`"./${tld}/**/*.${x[0]}"`);
+                }
+            }
+        }
+        if (this.options.verbose) {
+            console.log(gtx._x('Command-line options for extracting source files are: {options}', { options: options.join(' ') }));
+        }
+        return options;
+    }
+    checkOverwrite(setup) {
+        if (this.options.force)
+            return true;
+        // The po directory are already checked.
+        const filename = setup.configFile;
+        if (filename !== 'package.json' && fs.existsSync(filename)) {
+            this.error(gtx._x("Error: The file '{filename}' already exists!", {
+                filename,
+            }));
+            this.error(gtx._x("Will not overwrite without option '{option}'.", {
+                option: '--force',
+            }));
+            return false;
+        }
+        const pkg = this.packageJson;
+        if (pkg.scripts) {
+            const esgettextScripts = [
+                'esgettext',
+                'esgettext:potfiles',
+                'esgettext:extract',
+                'esgettext:update-po',
+                'esgettext:update-mo',
+                'esgettext:install',
+            ];
+            for (const script of esgettextScripts) {
+                if (Object.prototype.hasOwnProperty.call(pkg.scripts, script)) {
+                    this.error(gtx._x("Error: The file '{filename}' already defines a script '{script}'.", { filename: 'package.json' }));
+                    this.error(gtx._x("Will not overwrite without option '{option}'.", {
+                        option: '--force',
+                    }));
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    escapePath(name) {
+        if (name.includes(' ') || name.includes('"')) {
+            return `"${name.replace(/([\\""])/g, '\\$1')}"`;
+        }
+        else {
+            return name;
+        }
+    }
+    checkTool(name) {
+        return new Promise(resolve => {
+            const command = this.escapePath(name) + ' --version';
+            try {
+                child_process.execSync(command, {
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                });
+                return resolve(true);
+            }
+            catch (error) {
+                return resolve(gtx._x('The command {command} did not work.' + ' Error: {error}.', {
+                    command,
+                    error,
+                }));
+            }
+        });
+    }
+    doRun(argv) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.init(argv);
+            const setup = yield this.promptUser();
+            if (!this.checkOverwrite(setup)) {
+                return 1;
+            }
+            const configuration = this.getConfiguration(setup);
+            try {
+                yield this.writeFiles(configuration, setup);
+                this.installDependencies(setup);
+            }
+            catch (error) {
+                this.error(gtx._('Error writing output:'));
+                this.error(error);
+                return 1;
+            }
+            this.nextSteps(setup);
+            return 0;
+        });
+    }
+    run(argv) {
+        return new Promise(resolve => {
+            if (!(0, optspec_1.coerceOptions)(argv, this.args())) {
+                return resolve(1);
+            }
+            this.doRun(argv)
+                .then(() => {
+                resolve(0);
+            })
+                .catch(() => {
+                resolve(1);
+            });
+        });
+    }
+    nonEmpty(answer) {
+        return new Promise(resolve => {
+            if (answer.trim().length === 0) {
+                resolve(gtx._('Please enter a string with at least one character!'));
+            }
+            else {
+                resolve(true);
+            }
+        });
+    }
+    checkTextdomain(textdomain) {
+        return this.nonEmpty(textdomain)
+            .then(notEmpty => {
+            if (typeof notEmpty === 'string') {
+                return notEmpty;
+            }
+            if (textdomain.trim().match(/[/\\:]/)) {
+                return gtx._x('A valid textdomain must not contain a' +
+                    " slash ('{slash}'), backslash ('{backslash}', or" +
+                    " colon ('{colon}').", {
+                    slash: '/',
+                    backslash: '\\',
+                    colon: ':',
+                });
+            }
+            else {
+                return true;
+            }
+        })
+            .catch((error) => {
+            return gtx._x('An unknown error occurred: {error}!', { error });
+        });
+    }
+    checkDirectory(answer) {
+        return new Promise(resolve => {
+            const directory = answer.trim();
+            if (directory.length === 0) {
+                return resolve(gtx._('Please enter a string with at least one character!'));
+            }
+            if (!this.options.force) {
+                if (fs.existsSync(directory)) {
+                    return resolve(gtx._x("The directory '{directory}' already exists!", {
+                        directory,
+                    }) +
+                        ' ' +
+                        gtx._x("Will not overwrite without option '{option}'.", {
+                            option: '--force',
+                        }));
+                }
+            }
+            return resolve(true);
+        });
+    }
+    guessTextdomain() {
+        var _a, _b;
+        if ((_a = this.configuration.package) === null || _a === void 0 ? void 0 : _a.name) {
+            return (_b = this.configuration.package) === null || _b === void 0 ? void 0 : _b.name.replace(/^@(.+)\/(.+)/, '$1-$2');
+        }
+    }
+    guessPackageManager() {
+        if (fs.existsSync('package-lock.json')) {
+            return 'npm';
+        }
+        else if (fs.existsSync('yarn.lock')) {
+            return 'yarn';
+        }
+        else if (fs.existsSync('pnpm-lock.yaml')) {
+            return 'pnpm';
+        }
+        else if (fs.existsSync('bun.lockb')) {
+            return 'bun';
+        }
+        else {
+            return 'npm';
+        }
+    }
+    guessLocaleDir() {
+        if (fs.existsSync('assets')) {
+            return 'assets/locale';
+        }
+        else if (fs.existsSync('src')) {
+            return 'src/locale';
+        }
+        else {
+            return 'assets/locale';
+        }
+    }
+    guessConfigFile() {
+        if (this.packageJson.type === 'module' || this.packageJson.module) {
+            return 'esgettext.config.mjs';
+        }
+        else if (this.packageJson.type === 'commonjs') {
+            return 'esgettext.config.cjs';
+        }
+        else {
+            return 'esgettext.config.json';
+        }
+    }
+    promptUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('⚡ ' +
+                gtx._("We'll prepare your package for esgettext in a few seconds."));
+            console.log('🤔 ¯\\_(ツ)_/¯ ' + gtx._('In doubt, just hit return!'));
+            console.log();
+            return {
+                textdomain: yield (0, prompts_1.input)({
+                    message: gtx._('Textdomain of your package'),
+                    default: this.guessTextdomain(),
+                    validate: answer => this.checkTextdomain(answer),
+                }),
+                msgmerge: yield (0, prompts_1.input)({
+                    message: gtx._x("The '{tool}' program to use:", { tool: 'msgmerge' }),
+                    default: 'msgmerge',
+                    validate: answer => this.checkTool(answer),
+                }),
+                msgmergeOptions: yield (0, prompts_1.input)({
+                    message: gtx._x("(Boolean) options to invoke '{tool}' with", {
+                        tool: 'msgmerge',
+                    }),
+                    default: '--verbose',
+                }),
+                msgfmt: yield (0, prompts_1.input)({
+                    message: gtx._x("The '{tool}' program to use:", { tool: 'msgfmt' }),
+                    default: 'msgfmt',
+                    validate: answer => this.checkTool(answer),
+                }),
+                msgfmtOptions: yield (0, prompts_1.input)({
+                    message: gtx._x("Options to invoke '{tool}' with", { tool: 'msgfmt' }),
+                    default: '--check --statistics --verbose',
+                }),
+                poDirectory: yield (0, prompts_1.input)({
+                    message: gtx._('Where to store translation files'),
+                    default: 'po',
+                    validate: answer => this.checkDirectory(answer),
+                }),
+                localeDirectory: yield (0, prompts_1.input)({
+                    message: gtx._('Where to store compiled translations'),
+                    default: this.guessLocaleDir(),
+                    validate: answer => this.checkDirectory(answer),
+                }),
+                packageManager: yield (0, prompts_1.select)({
+                    message: gtx._('Which package manager should be used'),
+                    choices: [
+                        {
+                            name: 'npm',
+                            value: 'npm',
+                        },
+                        {
+                            name: 'yarn',
+                            value: 'yarn',
+                        },
+                        {
+                            name: 'pnpm',
+                            value: 'pnpm',
+                        },
+                        {
+                            name: 'bun',
+                            value: 'bun',
+                        },
+                    ],
+                    default: this.guessPackageManager(),
+                }),
+                configFile: yield (0, prompts_1.select)({
+                    message: gtx._('Where do you want to put configuration'),
+                    choices: [
+                        {
+                            name: 'esgettext.config.mjs',
+                            value: 'esgettext.config.mjs',
+                        },
+                        {
+                            name: 'esgettext.config.cjs',
+                            value: 'esgettext.config.cjs',
+                        },
+                        {
+                            name: 'esgettext.config.json',
+                            value: 'esgettext.config.json',
+                        },
+                        {
+                            name: 'package.json',
+                            value: 'package.json',
+                        },
+                    ],
+                    default: this.guessConfigFile(),
+                }),
+            };
+        });
+    }
+    error(...args) {
+        const redOn = '\x1b[31m';
+        const redOff = '\x1b[0m';
+        console.error(redOn, ...args, redOff);
+    }
+}
+exports.Init = Init;