create-pkgbld 1.3.0 → 1.4.0

package/dist/get-git-root.d.ts

@@ -0,0 +1 @@
+export default function getGitRoot(): Promise<string>;

package/dist/index.cjs

@@ -6,70 +6,95 @@ var path = require('path');
 var fs = require('fs/promises');
 var userName = require('git-user-name');
 var gitConfig = require('parse-git-config');
-var minimist = require('minimist');
+var cleye = require('cleye');
 var kleur = require('kleur');
+require('typia');
+var stringArgv = require('string-argv');
+var childProcess = require('node:child_process');
+var util = require('node:util');
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
+async function getGitRoot() {
+    const exec = util.promisify(childProcess.exec);
+    const { stdout } = await exec('git rev-parse --show-toplevel');
+    return stdout.trim();
+}
+
+const done = Symbol('done');
+const formats = ['amd', 'cjs', 'es', 'iife', 'system', 'umd'];
+const pkgbldBinaries = ['pkgbld', 'pkgbld-internal', 'node ../pkgbld/dist/index.js'];
 async function execute() {
-    await reportVersion();
-    const targetDir = getTargetDir();
+    const version = await reportVersion();
+    const args = cleye.cli({
+        name: 'create-pkgbld',
+        version,
+        parameters: [
+            '[package name]'
+        ],
+        flags: {
+            quite: {
+                type: Boolean,
+                description: 'Quite mode',
+                default: false
+            }
+        }
+    });
+    args.showVersion();
+    const targetDir = path.join(process.cwd(), args._.packageName ?? '.');
     console.log(kleur.grey(pad16plus('Target Directory', 0)) + kleur.white(targetDir));
     const pkg = await readPackage(targetDir);
     console.log(kleur.grey(pad16plus('Mode', 0)) + kleur.white(pkg.mode));
     const packageName = path.basename(targetDir);
     let cancelled = false;
-    const options = getBasicOptions(packageName);
-    options.push(...await getGitOptions(packageName));
+    const options = getBasicOptions(packageName, pkg);
+    options.push(...await getGitOptions(targetDir));
+    options.push(...getPkgbldOptions(pkg.pkg));
     const state = getOptionsValue(options);
-    for (;;) {
-        const topLevelAction = await prompts({
-            type: 'select',
-            name: 'value',
-            message: 'Select an option to change, Done to execute, Ctrl+C to cancel',
-            choices: [
-                { title: kleur.green('Done'), description: `${pkg.mode === 'update' ? 'Update' : 'Create'} package`, value: 'done' },
-                ...options.map(mapOption(state))
-            ],
-            initial: 0
-        }, { onCancel });
-        if (cancelled) {
-            process.exit(-1);
-        }
-        if (topLevelAction.value === 'done') {
-            break;
-        }
-        let option = options.find(item => item.field === topLevelAction.value);
-        let mutateObject = state;
-        if ('items' in option) {
-            const nextLevelAction = await prompts([{
-                    type: 'select',
-                    name: 'value',
-                    message: option.title,
-                    choices: option.items.map(mapOption(state[option.field]))
-                }], { onCancel });
+    if (!args.flags.quite) {
+        for (;;) {
+            const topLevelAction = await prompts({
+                type: 'select',
+                name: 'value',
+                message: 'Select an option to change, Done to execute, Escape to cancel',
+                choices: [
+                    { title: kleur.green('Done'), description: `${pkg.mode === 'update' ? 'Update' : 'Create'} package`, value: done },
+                    ...options.map(mapOption(state))
+                ],
+                initial: 0
+            }, { onCancel });
             if (cancelled) {
                 process.exit(-1);
             }
-            if (option.mutateInnerObject) {
-                mutateObject = state[option.field];
+            if (topLevelAction.value === done) {
+                break;
             }
-            option = option.items.find(item => item.field === nextLevelAction.value);
+            let option = options.find(item => item.field === topLevelAction.value);
+            let mutateObject = state;
+            while ('items' in option) {
+                const nextLevelAction = await prompts([{
+                        type: 'select',
+                        name: 'value',
+                        message: option.title,
+                        choices: option.items.map(mapOption(option.mutateInnerObject ? state[option.field] : state))
+                    }], { onCancel });
+                if (cancelled) {
+                    process.exit(-1);
+                }
+                if (option.mutateInnerObject) {
+                    mutateObject = state[option.field];
+                }
+                option = option.items.find(item => item.field === nextLevelAction.value);
+            }
+            const action = await prompts(getPromptOption(option, mutateObject), { onCancel });
+            if (cancelled) {
+                process.exit(-1);
+            }
+            mutateObject[option.field] = action[option.field];
         }
-        const action = await prompts([{
-                type: 'text',
-                name: option.field,
-                message: option.title,
-                initial: state[option.field]
-            }], { onCancel });
         if (cancelled) {
             process.exit(-1);
         }
-        mutateObject[option.field] = action[option.field];
-    }
-    if (cancelled) {
-        process.exit(-1);
     }
-    Object.assign(pkg.pkg, state);
+    updatePackage(pkg, state);
     pkg.readme ??= `# ${state.name}`;
     await writePackage(targetDir, pkg);
     function onCancel() {
@@ -77,121 +102,430 @@ async function execute() {
     }
 }
 execute();
+function updatePackage(pkg, options) {
+    const order = new Set([
+        'private',
+        'type',
+        'version',
+        'name',
+        'description',
+        'license',
+        'author',
+        'bin',
+        'main',
+        'module',
+        'exports',
+        'types',
+        'typings',
+        'files',
+        'engines',
+        'repository',
+        'bugs',
+        'homepage',
+        'keywords',
+        'scripts',
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+        'publishConfig'
+    ]);
+    const newPkg = {};
+    for (const key of order) {
+        if (key in options || key in pkg.pkg) {
+            newPkg[key] = treatKey(key);
+        }
+    }
+    for (const key in pkg.pkg) {
+        if (!order.has(key)) {
+            newPkg[key] = pkg.pkg[key];
+        }
+    }
+    pkg.pkg = newPkg;
+    function treatKey(key) {
+        if (key === 'scripts') {
+            ({ ...pkg.pkg.scripts });
+            console.log(options);
+            getScriptValue(options.pkgbld);
+        }
+        return options[key] ?? pkg.pkg[key];
+    }
+}
+function getScriptValue(pkgbld) {
+    const binary = pkgbld.pkgbldBinary;
+    const extraArgs = pkgbld.extraParameters;
+    const pkgBldCopy = { ...pkgbld };
+    delete pkgBldCopy['pkgbldBinary'];
+    delete pkgBldCopy['extraParameters'];
+    return `${binary} ${asCommandLineArgs(pkgBldCopy)} ${extraArgs}`;
+}
+function getPromptOption(option, mutateObject) {
+    const value = mutateObject[option.field];
+    const type = option.type ?? 'text';
+    const promptOption = {
+        type,
+        name: option.field,
+        message: option.title,
+        initial: (Array.isArray(value) ? value.join(',') : value) ?? ''
+    };
+    if (type === 'multiselect') {
+        promptOption.choices = 'list' in option ? option.list.map(item => ({
+            title: item,
+            value: item,
+            selected: value.includes(item)
+        })) : [];
+    }
+    if (type === 'select') {
+        promptOption.choices = 'list' in option ? option.list.map(item => ({
+            title: item,
+            value: item
+        })) : [];
+        promptOption.initial = promptOption.choices.findIndex(item => item.value === promptOption.initial);
+    }
+    return promptOption;
+}
 function mapOption(state) {
     return (option) => {
         const fieldValue = state[option.field];
         return {
-            title: pad16plus(option.title) + kleur.magenta('items' in option ? viewObject(option.items, fieldValue) : fieldValue),
+            title: pad16plus(option.title) + kleur.grey('items' in option ? getPrintString(option.items, (option.mutateInnerObject ? fieldValue : state)) : fieldValue ?? ''),
             value: option.field
         };
     };
 }
-function viewObject(items, json) {
+function getPrintString(items, json) {
     return items
-        .map(item => kleur.grey(item.title) + ' ' + kleur.white(json[item.field]))
+        .filter(item => item.field in json && json[item.field] && (Array.isArray(json[item.field]) ? json[item.field].length > 0 : true))
+        .map(item => kleur.grey(item.title) + ' ' + (kleur.white('items' in item ?
+        `[${getPrintString(item.items, (item.mutateInnerObject ? json[item.field] :
+            json))}]` : json[item.field])))
         .join(', ');
 }
 function getOptionsValue(options) {
-    return options.reduce((accumulator, item) => ({
-        ...accumulator,
-        [item.field]: 'items' in item ? getOptionsValue(item.items) : item.initialValue
-    }), {});
+    const result = {};
+    for (const item of options) {
+        if ('items' in item) {
+            const value = getOptionsValue(item.items);
+            if (item.mutateInnerObject) {
+                result[item.field] = value;
+            }
+            else {
+                Object.assign(result, value);
+            }
+        }
+        else {
+            result[item.field] = item.initialValue;
+        }
+    }
+    return result;
 }
 async function reportVersion() {
     const createPkgBldPackage = await readPackage(path.resolve(__dirname, '..'));
-    console.log(kleur.grey(pad16plus('create-pkgbld', 0)) + kleur.white('v' + createPkgBldPackage.pkg.version));
+    const version = createPkgBldPackage.pkg.version ?? '<unknown>';
+    return version;
 }
-function getTargetDir() {
-    const parsedArgs = minimist(process.argv.slice(2));
-    const targetDir = path.join(process.cwd(), parsedArgs._[0] ?? '.');
-    return targetDir;
-}
-async function getGitOptions(packageName) {
-    const options = [];
+async function getGitOptions(targetDir) {
     try {
         const gitCfg = await gitConfig();
         if (gitCfg) {
             const url = gitCfg['remote "origin"'].url;
-            options.push({
-                title: 'Homepage',
-                field: 'homepage',
-                initialValue: url.replace('.git', `/blob/main/${packageName}/README.md`)
-            });
-            options.push({
-                title: 'Repository',
-                field: 'repository',
-                items: [{
-                        title: 'Type',
-                        field: 'type',
-                        initialValue: 'git'
-                    }, {
-                        title: 'Url',
-                        field: 'url',
-                        initialValue: `git+${url}`
-                    }],
-                mutateInnerObject: true
-            });
-            options.push({
-                title: 'Bugs',
-                field: 'bugs',
-                initialValue: url.replace('.git', '/issues')
-            });
+            const root = await getGitRoot();
+            const directory = path.relative(root, targetDir);
+            return [{
+                    title: 'Git',
+                    field: 'git',
+                    mutateInnerObject: false,
+                    items: [{
+                            title: 'Homepage',
+                            field: 'homepage',
+                            initialValue: url.replace('.git', `/blob/main${directory ? '/' + directory : ''}/README.md`)
+                        }, {
+                            title: 'Repository',
+                            field: 'repository',
+                            items: [{
+                                    title: 'Type',
+                                    field: 'type',
+                                    initialValue: 'git'
+                                }, {
+                                    title: 'Url',
+                                    field: 'url',
+                                    initialValue: `git+${url}`
+                                }, {
+                                    title: 'Directory',
+                                    field: 'directory',
+                                    initialValue: directory || undefined
+                                }],
+                            mutateInnerObject: true
+                        }, {
+                            title: 'Bugs',
+                            field: 'bugs',
+                            initialValue: url.replace('.git', '/issues')
+                        }]
+                }];
         }
     }
     catch (e) {
         /* ignore */
     }
-    return options;
+    return [];
 }
-function getBasicOptions(packageName) {
+function getPkgbldOptions(pkg) {
+    let args = {
+        formats: ['es', 'cjs'],
+        umd: [],
+        compress: ['umd'],
+        sourcemaps: ['umd'],
+        preprocess: [],
+        dir: 'dist',
+        sourceDir: 'src',
+        bin: undefined,
+        includeExternals: false,
+        eject: false,
+        noTsConfig: false,
+        noUpdatePackageJson: false
+    };
+    function CommaSeparatedString(value) {
+        return value.split(',').map((arg) => arg.trim());
+    }
+    const cmd = pkg.scripts?.build ?? '';
+    let binary = 'pkgbld';
+    if (cmd) {
+        if (cmd.startsWith('pkgbld-internal')) {
+            binary = 'pkgbld-internal';
+        }
+        else if (cmd.startsWith('node ../pkgbld/dist/index.js')) {
+            binary = 'node ../pkgbld/dist/index.js';
+        }
+        else if (!cmd.startsWith('pkgbld')) {
+            const naiveArgs = cmd.split(' ');
+            if (naiveArgs.length > 1 && naiveArgs[0] === 'node') {
+                binary = naiveArgs[0] + ' ' + naiveArgs[1];
+            }
+            else if (naiveArgs.length > 0) {
+                binary = naiveArgs[0]; // ?????
+            }
+        }
+        const parsedArgs = cleye.cli({
+            help: false,
+            flags: {
+                umd: {
+                    type: CommaSeparatedString,
+                    default: args.umd
+                },
+                compress: {
+                    type: CommaSeparatedString,
+                    default: args.compress
+                },
+                sourcemaps: {
+                    type: CommaSeparatedString,
+                    default: args.sourcemaps
+                },
+                formats: {
+                    type: CommaSeparatedString,
+                    default: args.formats
+                },
+                preprocess: {
+                    type: CommaSeparatedString,
+                    default: args.preprocess
+                },
+                dir: {
+                    type: String,
+                    default: args.dir
+                },
+                sourceDir: {
+                    type: String,
+                    default: args.sourceDir
+                },
+                bin: {
+                    type: CommaSeparatedString,
+                    default: args.bin
+                },
+                includeExternals: {
+                    type: Boolean,
+                    default: args.includeExternals
+                },
+                eject: {
+                    type: Boolean,
+                    default: args.eject
+                },
+                noTsConfig: {
+                    type: Boolean,
+                    default: args.noTsConfig
+                },
+                noUpdatePackageJson: {
+                    type: Boolean,
+                    default: args.noUpdatePackageJson
+                }
+            }
+        }, undefined, stringArgv.parseArgsStringToArgv(cmd));
+        args = parsedArgs.flags;
+        args.extraParameters = asCommandLineArgs(parsedArgs.unknownFlags);
+    }
     return [{
-            title: 'Package Name',
-            field: 'name',
-            initialValue: packageName
-        }, {
-            title: 'Version',
-            field: 'version',
-            initialValue: '0.0.1'
-        }, {
-            title: 'Description',
-            field: 'description',
-            initialValue: ''
-        }, {
-            title: 'License',
-            field: 'license',
-            initialValue: 'MIT'
-        }, {
-            title: 'Author',
-            field: 'author',
-            initialValue: userName() ?? ''
-        }, {
-            title: 'Destination folder',
-            field: 'dest',
-            initialValue: 'dest'
-        }, {
-            title: 'Source folder',
-            field: 'src',
-            initialValue: 'src'
+            title: 'pkgbld',
+            field: 'pkgbld',
+            mutateInnerObject: true,
+            items: [{
+                    title: 'Destination folder',
+                    field: 'dest',
+                    initialValue: args.dir
+                }, {
+                    title: 'Source folder',
+                    field: 'src',
+                    initialValue: args.sourceDir
+                }, {
+                    title: 'UMD exports',
+                    field: 'umd',
+                    initialValue: args.umd,
+                    type: 'list'
+                }, {
+                    title: 'Compress formats',
+                    field: 'compress',
+                    initialValue: args.compress,
+                    type: 'multiselect',
+                    list: formats
+                }, {
+                    title: 'Sorcemaps formats',
+                    field: 'sourcemaps',
+                    initialValue: args.sourcemaps,
+                    type: 'multiselect',
+                    list: formats
+                }, {
+                    title: 'Formats',
+                    field: 'formats',
+                    initialValue: args.formats,
+                    type: 'multiselect',
+                    list: formats
+                }, {
+                    title: 'Preprocess formats',
+                    field: 'preprocess',
+                    initialValue: args.preprocess,
+                    type: 'multiselect',
+                    list: formats
+                }, {
+                    title: 'Binaries',
+                    field: 'bin',
+                    initialValue: args.bin,
+                    type: 'list'
+                }, {
+                    title: 'Include externals',
+                    field: 'includeExternals',
+                    type: 'toggle',
+                    initialValue: args.includeExternals
+                }, {
+                    title: 'Eject config',
+                    field: 'eject',
+                    type: 'toggle',
+                    initialValue: args.eject
+                }, {
+                    title: 'Create tsconfig',
+                    field: 'tsConfig',
+                    type: 'toggle',
+                    initialValue: !args.noTsConfig
+                }, {
+                    title: 'Update package.json',
+                    field: 'updatePackageJson',
+                    type: 'toggle',
+                    initialValue: !args.noUpdatePackageJson
+                }, {
+                    title: 'Extra parameters',
+                    field: 'extraParameters',
+                    type: 'text',
+                    initialValue: args.extraParameters
+                }, {
+                    title: 'Pkgbld Binary',
+                    field: 'pkgbldBinary',
+                    type: 'select',
+                    list: pkgbldBinaries.includes(binary) ? pkgbldBinaries : [...pkgbldBinaries, binary],
+                    initialValue: binary
+                }]
         }];
 }
+function asCommandLineArgs(parsedArgs) {
+    return Object.entries(parsedArgs)
+        .flatMap(([key, value]) => asArray(value)
+        .filter(Boolean)
+        .map(value => `--${key}${typeof value === 'string' ? `=${value}` : ''}`)).join(' ');
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+function getBasicOptions(packageName, pkg) {
+    return [{
+            title: 'General',
+            field: 'general',
+            items: [{
+                    title: 'Package Name',
+                    field: 'name',
+                    initialValue: chooseValue(pkg.pkg.name, packageName)
+                }, {
+                    title: 'Version',
+                    field: 'version',
+                    initialValue: chooseValue(pkg.pkg.version, '0.0.1')
+                }, {
+                    title: 'Description',
+                    field: 'description',
+                    initialValue: chooseValue(pkg.pkg.description, '')
+                }, {
+                    title: 'License',
+                    field: 'license',
+                    initialValue: chooseValue(pkg.pkg.license, 'MIT')
+                }, {
+                    title: 'Author',
+                    field: 'author',
+                    initialValue: chooseValue(pkg.pkg.author, userName() ?? '')
+                }],
+            mutateInnerObject: false
+        }];
+    function chooseValue(pkgValue, defaultValue) {
+        return pkg.mode === 'update' ? pkgValue : defaultValue;
+    }
+}
 function pad16plus(value, indent = 4, offset = 3) {
     return value + ''.padEnd(offset - Math.floor((value.length + indent) / 8), '\t');
 }
 async function readPackage(dir) {
     const packageFileName = path.resolve(dir, 'package.json');
     const readmeFileName = path.resolve(dir, 'README.md');
+    const defaultPkg = {};
     try {
         const pkgFile = await fs.readFile(packageFileName);
         const readmeFile = await fs.readFile(readmeFileName);
+        const pkg = JSON.parse(pkgFile.toString());
+        const isValidPackageJson = (input => {
+            const $io0 = input => (undefined === input.private || "boolean" === typeof input.private) && (undefined === input.version || "string" === typeof input.version) && (undefined === input.name || "string" === typeof input.name) && (undefined === input.license || "string" === typeof input.license) && (undefined === input.author || "string" === typeof input.author) && (undefined === input.description || "string" === typeof input.description) && (undefined === input.scripts || "object" === typeof input.scripts && null !== input.scripts && false === Array.isArray(input.scripts) && $io1(input.scripts)) && (undefined === input.dependencies || "object" === typeof input.dependencies && null !== input.dependencies && false === Array.isArray(input.dependencies) && $io2(input.dependencies)) && (undefined === input.devDependencies || "object" === typeof input.devDependencies && null !== input.devDependencies && false === Array.isArray(input.devDependencies) && $io2(input.devDependencies)) && (undefined === input.peerDependencies || "object" === typeof input.peerDependencies && null !== input.peerDependencies && false === Array.isArray(input.peerDependencies) && $io2(input.peerDependencies)) && Object.keys(input).every(key => {
+                if (["private", "version", "name", "license", "author", "description", "scripts", "dependencies", "devDependencies", "peerDependencies"].some(prop => key === prop))
+                    return true;
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                if (RegExp(/(.*)/).test(key))
+                    return true;
+                return true;
+            });
+            const $io1 = input => (undefined === input.build || "string" === typeof input.build) && (undefined === input.lint || "string" === typeof input.lint);
+            const $io2 = input => Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                if (RegExp(/(.*)/).test(key))
+                    return "string" === typeof value;
+                return true;
+            });
+            return "object" === typeof input && null !== input && false === Array.isArray(input) && $io0(input);
+        })(pkg);
+        if (!isValidPackageJson) {
+            console.error('Invalid package.json');
+        }
         return {
-            pkg: JSON.parse(pkgFile.toString()),
+            pkg: isValidPackageJson ? pkg : defaultPkg,
             readme: readmeFile.toString(),
             mode: 'update'
         };
     }
     catch (e) { /**/ }
     return {
-        pkg: {},
+        pkg: defaultPkg,
         readme: '',
         mode: 'create'
     };