How to use minimist - 10 common examples

function masterArgsParse(): MasterProgramArgs {
  let { _: _paths, verbose, timeout, statusFile, testDir } = minimist(process.argv.slice(2), {
    string: ["statusFile", "testDir"],
    boolean: ["verbose"],
    default: {
      testDir: ["..", "test", "test262"].join(path.sep),
      verbose: process.stdout instanceof tty.WriteStream ? false : true,
      statusFile: "",
      timeout: 10,
    },
  });

  // Test paths can be provided as "built-ins/Array", "language/statements/class", etc.
  let paths = _paths.map(p => path.join("test", p));
  if (typeof verbose !== "boolean") {
    throw new Error("verbose must be a boolean (either --verbose or not)");
  }
  if (typeof timeout !== "number") {

// allows overriding the default configuration 
// using `[project_folder]/configuration.js` file
// (if the file exists)
const specific_configuration_path = path.resolve(__dirname, '../../configuration.js')
if (fs.existsSync(specific_configuration_path))
{
	const specific_configuration = require(specific_configuration_path)
	Object.extend(configuration, specific_configuration)
}

export default configuration

// можно будет использовать этот файл в shell'овых скриптах
// (команда: node configuration.coffee --path="...")

const process_arguments = minimist(process.argv.slice(2))

if (process_arguments.path)
{
	console.log(Object.path(configuration, process_arguments.path))
	process.exit()
}

//@flow

import webpack from "webpack";
import path from "path";
import fs from "fs";
import chalk from "chalk";
import minimist from "minimist";
import findUp from "find-up";
import logger from "./logger";
import config from "./webpack.config.js";
import { spawn } from "child_process"

const {
  _: [inputPath],
  middleware
} = minimist(process.argv.slice(2));

if (typeof inputPath !== "string") {
  logger.error("You must provide a valid path to your root App component");
  process.exit(1);
}
// $FlowFixMe - for some reason flow isn't picking up the process.exit above
const appPath = path.resolve(process.cwd(), inputPath);
if (!fs.existsSync(appPath)) {
  logger.error(`${appPath} is not a valid filepath 😿`);
  process.exit(1);
}

let middlewarePath;
if (middleware) {
  middlewarePath = path.resolve(process.cwd(), middleware);
  if (!fs.existsSync(middlewarePath)) {

#!/usr/bin/env node
var express = require('express')
var serveStatic = require('serve-static')
var serveIndex = require('serve-index')
var SocketServer = require('ws').Server
var fs = require('fs')
var chokidar = require('chokidar')
var child = require('child_process')
var PORT = require('minimist')(process.argv.slice(2)).port || 3989

// set up express static server with a websocket
var server = express()
  .get('*', injectHTML)
  .use(serveStatic('./'))
  .use('/', serveIndex('./'))
  .listen(PORT)
  .on('listening', () => {
    child.exec('open http://localhost:' + PORT)
    console.log('hot-server http://localhost:' + PORT)
  })
  
process.on('uncaughtException', (err => 
  err.errno == 'EADDRINUSE' ? server.listen(++PORT) : 0)) //inc PORT if in use

// append websocket/injecter script to all html pages served

const gulp = require('gulp');
const type = require('minimist')(process.argv.slice(2)).type;
const tasks = require('require-dir')('./tasks', {
	recurse: true,
	filter(fullPath) {
		// 如果是非开发环境则过滤掉watch的task
		return type === 'dev' || !/watch\.js$/.test(fullPath);
	}
});

let taskNames = [];

(function install(taskObj, parent = '') {

	for (let taskName in taskObj) {
		let taskItem = taskObj[taskName];
		let taskFullName = parent + taskName;

export async function exec (argv2) { // eslint-disable-line complexity
  const argv = minimist(argv2, {
    boolean: [ 'b', 'build', 'bytecode', 'd', 'debug',
      'h', 'help', 'public', 'v', 'version' ],
    string: [ '_', 'c', 'config', 'o', 'options', 'output',
      'outdir', 'out-dir', 'out-path', 'public-packages',
      't', 'target', 'targets' ],
    default: { bytecode: true }
  });

  if (argv.h || argv.help) {
    help();
    return;
  }

  // version

  if (argv.v || argv.version) {

import minimist from 'minimist';

const argv = minimist(process.argv.slice(2));

// eslint-disable-next-line import/prefer-default-export
export const isProduction = argv.prod;

Cli.prototype.parse = function (argv, next) {
  this.errors = [] // clear errors
  var options = parseArgs(argv, this.options)
  if (options.version) {
    this.message = '' + pkg.version
    next(null, this.message)
  } else if (options.help) {
    this.message = this.helpMessage.join('\n')
    next(null, this.message)
  } else {
    options.files = options._

    if (!options.files.length) {
      this.errors.push(new Error('You must specify at least one source file.'))
    }

    // ensure that parameter-expecting options have parameters
    ;['outputDir', 'outputSuffix', 'phantomPath', 'sequenceConfig', 'ganttConfig', 'css'].forEach(function (i) {
      if (typeof options[i] !== 'undefined') {

// import installExtension, { REACT_DEVELOPER_TOOLS } from 'electron-devtools-installer'

// app: control application file.
// BrowserWindow: create native browser window.

import { app, BrowserWindow }  from 'electron'
import path from 'path'

let isProd = path.basename(process.argv[0]).indexOf('ratpack') === 0

let startsWith = require('minimist')(process.argv.slice(1))._[ isProd ? 0 : 1]
let startedOnce = false
let mainWindow

app.on('open-file', (e, filepath) => {
  if(!mainWindow ) {
    startsWith = filepath
    if(!startedOnce) {      
      return
    }    
    createWindow()    
    return 
  }    
})
 
// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.

// if we are running in electron
// we must hack around busted timers
if (process.versions.electron) {
  require('../../timers/parent').fix()
}

require('graceful-fs').gracefulify(require('fs'))
require('@packages/coffee/register')
require && require.extensions && delete require.extensions['.litcoffee']
require && require.extensions && delete require.extensions['.coffee.md']

const ipc = require('../util').wrapIpc(process)
const backgroundFile = require('minimist')(process.argv.slice(2)).file

require('./run_background')(process, ipc, backgroundFile)