158 lines
4.4 KiB
JavaScript
158 lines
4.4 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const wrap = require('module').wrap;
|
|
const spawnSync = require('child_process').spawnSync;
|
|
const bytenode = require('./index.js');
|
|
|
|
const args = process.argv.slice(2);
|
|
|
|
if (args.includes('-c')) {
|
|
args[args.indexOf('-c')] = '--compile';
|
|
}
|
|
|
|
if (args.includes('-o')) {
|
|
args[args.indexOf('-o')] = '--out';
|
|
}
|
|
|
|
if (args.includes('-h')) {
|
|
args[args.indexOf('-h')] = '--help';
|
|
}
|
|
|
|
if (args.includes('-v')) {
|
|
args[args.indexOf('-v')] = '--version';
|
|
}
|
|
|
|
if (args.includes('-n')) {
|
|
args[args.indexOf('-n')] = '--no-module';
|
|
}
|
|
|
|
if (args.includes('-e')) {
|
|
args[args.indexOf('-e')] = '--electron';
|
|
}
|
|
|
|
if (args.includes('-l')) {
|
|
args[args.indexOf('-l')] = '--loader';
|
|
}
|
|
|
|
let loaderFilename;
|
|
let createLoader = false;
|
|
|
|
if (args.includes('--loader')) {
|
|
createLoader = true;
|
|
const nextIndex = args.indexOf('--loader') + 1;
|
|
const nextItem = args[nextIndex];
|
|
if (nextItem && nextItem[0] !== '-') {
|
|
loaderFilename = nextItem;
|
|
// remove the loader filename from the args so it
|
|
// isn't mistaken for a file to compile
|
|
args.splice(nextIndex, 1);
|
|
}
|
|
}
|
|
|
|
if (args.includes('--no-loader')) {
|
|
createLoader = false;
|
|
}
|
|
|
|
const program = {
|
|
dirname: __dirname,
|
|
filename: __filename,
|
|
nodeBin: process.argv[0],
|
|
flags: args.filter(arg => arg[0] === '-'),
|
|
files: args.filter(arg => arg[0] !== '-' && arg[1] !== '-')
|
|
};
|
|
|
|
if (program.flags.includes('--compile')) {
|
|
program.files.forEach(async function (filename) {
|
|
filename = path.resolve(filename);
|
|
|
|
if (fs.existsSync(filename) && fs.statSync(filename).isFile()) {
|
|
const compileAsModule = !program.flags.includes('--no-module');
|
|
const electron = program.flags.includes('--electron');
|
|
|
|
try {
|
|
await bytenode.compileFile({ filename, compileAsModule, electron, createLoader, loaderFilename });
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
} else {
|
|
console.error(`Error: Cannot find file '${filename}'.`);
|
|
}
|
|
});
|
|
|
|
if (program.files.length === 0) {
|
|
let script = '';
|
|
|
|
process.stdin.setEncoding('utf-8');
|
|
|
|
process.stdin.on('readable', () => {
|
|
const data = process.stdin.read();
|
|
if (data !== null) {
|
|
script += data;
|
|
}
|
|
});
|
|
|
|
process.stdin.on('end', () => {
|
|
try {
|
|
if (program.flags.includes('--no-module')) {
|
|
process.stdout.write(bytenode.compileCode(script));
|
|
} else {
|
|
process.stdout.write(bytenode.compileCode(wrap(script)));
|
|
}
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
});
|
|
}
|
|
} else if (program.flags.includes('--help')) {
|
|
console.log(`
|
|
Usage: bytenode [option] [ FILE... | - ] [arguments]
|
|
|
|
Options:
|
|
-h, --help show help information.
|
|
-v, --version show bytenode version.
|
|
|
|
-c, --compile [ FILE... | - ] compile stdin, a file, or a list of files
|
|
-n, --no-module compile without producing commonjs module
|
|
-e, --electron compile for Electron
|
|
|
|
--no-loader do not create a loader file, conflicts with -l
|
|
-l, --loader [ FILE | PATTERN ] create a loader file and optionally define
|
|
loader filename or pattern using % as filename replacer
|
|
defaults to %.loader.js
|
|
|
|
Examples:
|
|
|
|
$ bytenode -c script.js compile \`script.js\` to \`script.jsc\`.
|
|
$ bytenode -c server.js app.js
|
|
$ bytenode -c src/*.js compile all \`.js\` files in \`src/\` directory.
|
|
|
|
$ bytenode script.jsc [arguments] run \`script.jsc\` with arguments.
|
|
$ bytenode open Node REPL with bytenode pre-loaded.
|
|
|
|
$ echo 'console.log("Hello");' | bytenode --compile - > hello.jsc
|
|
compile from stdin and save to \`hello.jsc\`
|
|
`);
|
|
} else if (program.flags.includes('--version') && program.flags.length === 1 && program.files.length === 0) {
|
|
const pkg = require('../package.json');
|
|
console.log(pkg.name, pkg.version);
|
|
console.log('Node', process.versions.node);
|
|
if (process.versions.electron) {
|
|
console.log('Electron', process.versions.electron);
|
|
}
|
|
} else {
|
|
try {
|
|
spawnSync(program.nodeBin, [
|
|
'-r',
|
|
path.resolve(__dirname, 'index.js')
|
|
].concat(args), {
|
|
stdio: 'inherit'
|
|
});
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
}
|