@wyze/rio/bin/index.js

A utility to compile Node modules.

#!/usr/bin/env node
'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var meow = _interopDefault(require('meow'));
var rollup = require('rollup');
var bucklescript = _interopDefault(require('rollup-plugin-bucklescript'));
var builtins = _interopDefault(require('builtins'));
var commonjs = _interopDefault(require('@rollup/plugin-commonjs'));
var json = _interopDefault(require('@rollup/plugin-json'));
var readPkg = _interopDefault(require('read-pkg'));
var resolve = _interopDefault(require('@rollup/plugin-node-resolve'));
var sucrase = _interopDefault(require('@rollup/plugin-sucrase'));

function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }








const whenMatch = (match, plugin) =>
  match ? plugin() : undefined;

const maybeAddScript = (input) =>
  whenMatch(/\.m?(j|t)sx?$/.test(input), () =>
    sucrase({
      exclude: ['node_modules/**'],
      transforms: [whenMatch(/\.tsx?/.test(input), () => 'typescript')],
    })
  );

const maybeAddReason = (input) =>
  whenMatch(/\.(ml|re)$/.test(input), bucklescript);

const options = {
  inlineDynamicImports: false,
  input: '', // Will be overwritten in build function
};

const build = async (input, flags) => {
  const { binary, externals } = flags;
  const banner = _nullishCoalesce(flags.banner, () => ( (binary ? '#!/usr/bin/env node' : undefined)));
  const file = _nullishCoalesce(flags.output, () => ( (binary ? 'bin/index.js' : undefined)));
  const format = flags.format; 
  const plugins = [
    json(),
    maybeAddScript(input),
    maybeAddReason(input),
    commonjs({
      include: 'node_modules/**',
    }),
    resolve({
      extensions: ['.mjs', '.js', '.json', '.ts'],
    }),
  ].filter(Boolean);
  const external = builtins()
    .concat(
      binary ? Object.keys((await readPkg()).dependencies || {}) : undefined
    )
    .concat(externals !== undefined ? externals.split(',') : undefined)
    .filter(Boolean);

  const bundle = await rollup.rollup({ ...options, external, input, plugins });

  await bundle.write({ banner, file, format });
};

const cli = meow(
  `
  Usage
    $ rio [options] <input>

  Options
    --banner,    -b   Add banner to top of output file
    --binary          Pass good defaults for binary files
    --externals, -e   Add external files that shouldn't be bundled
    --format,    -f   Output file format (esm, umd, etc.)
    --output,    -o   Output file

  Examples
    $ rio -o out.js in.ts
    $ rio -o out.js -f esm in.ts
    $ rio -o out.js -e chalk,debug in.ts
    $ rio -o out.js -b '#!/usr/bin/env node' in.ts
    $ rio --binary in.ts
`,
  {
    flags: {
      banner: {
        alias: 'b',
        type: 'string',
      },
      binary: {
        type: 'boolean',
      },
      externals: {
        alias: 'e',
        type: 'string',
      },
      format: {
        alias: 'f',
        type: 'string',
        default: 'cjs',
      },
      output: {
        alias: 'o',
        type: 'string',
      },
    },
  }
);

const { input, flags, showHelp } = cli;

if (input.length === 0) {
  showHelp(0);
}

build(input[0], flags);