@oxog/port-terminator
Version:
Cross-platform utility to terminate processes on ports with zero dependencies
246 lines • 7.51 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CommandParser = void 0;
const validators_1 = require("./validators");
class CommandParser {
constructor(args = process.argv.slice(2)) {
this.parsed = [];
this.args = args;
}
parse() {
this.parsed = this.parseArguments();
const options = {};
const ports = [];
for (const arg of this.parsed) {
switch (arg.name) {
case 'help':
case 'h':
options.help = true;
break;
case 'version':
case 'v':
options.version = true;
break;
case 'force':
case 'f':
options.force = true;
break;
case 'silent':
case 's':
options.silent = true;
break;
case 'dry-run':
case 'n':
options.dryRun = true;
break;
case 'json':
case 'j':
options.json = true;
break;
case 'timeout':
case 't':
if (typeof arg.value === 'number') {
options.timeout = arg.value;
}
break;
case 'graceful-timeout':
case 'g':
if (typeof arg.value === 'number') {
options.gracefulTimeout = arg.value;
}
break;
case 'method':
case 'm':
if (typeof arg.value === 'string') {
options.method = arg.value;
}
break;
case 'range':
case 'r':
if (typeof arg.value === 'string') {
options.range = arg.value;
const rangePorts = (0, validators_1.parsePortRange)(arg.value);
ports.push(...rangePorts);
}
break;
case 'port':
if (typeof arg.value === 'number') {
ports.push(arg.value);
}
break;
}
}
if (ports.length > 0) {
options.ports = ports;
}
return options;
}
parseArguments() {
const parsed = [];
for (let i = 0; i < this.args.length; i++) {
const arg = this.args[i];
if (arg.startsWith('--')) {
const longArg = this.parseLongArgument(arg, i);
parsed.push(longArg.argument);
if (longArg.skipNext) {
i++;
}
}
else if (arg.startsWith('-') && arg.length > 1) {
const shortArgs = this.parseShortArguments(arg, i);
parsed.push(...shortArgs.arguments);
if (shortArgs.skipNext) {
i++;
}
}
else {
const portValue = this.parsePortValue(arg);
if (portValue !== null) {
parsed.push({
name: 'port',
value: portValue,
hasValue: true,
});
}
}
}
return parsed;
}
parseLongArgument(arg, index) {
const name = arg.substring(2);
const equalIndex = name.indexOf('=');
if (equalIndex !== -1) {
const argName = name.substring(0, equalIndex);
const argValue = name.substring(equalIndex + 1);
return {
argument: {
name: argName,
value: this.parseValue(argValue),
hasValue: true,
},
skipNext: false,
};
}
if (this.isBooleanFlag(name)) {
return {
argument: {
name,
value: true,
hasValue: false,
},
skipNext: false,
};
}
const nextArg = this.args[index + 1];
if (nextArg && !nextArg.startsWith('-')) {
return {
argument: {
name,
value: this.parseValue(nextArg),
hasValue: true,
},
skipNext: true,
};
}
return {
argument: {
name,
value: true,
hasValue: false,
},
skipNext: false,
};
}
parseShortArguments(arg, index) {
const flags = arg.substring(1);
const parsedArgs = [];
let skipNext = false;
for (let i = 0; i < flags.length; i++) {
const flag = flags[i];
const flagName = this.getShortFlagName(flag);
if (i === flags.length - 1 && !this.isBooleanFlag(flagName)) {
const nextArg = this.args[index + 1];
if (nextArg && !nextArg.startsWith('-')) {
parsedArgs.push({
name: flagName,
value: this.parseValue(nextArg),
hasValue: true,
});
skipNext = true;
}
else {
parsedArgs.push({
name: flagName,
value: true,
hasValue: false,
});
}
}
else {
parsedArgs.push({
name: flagName,
value: true,
hasValue: false,
});
}
}
return { arguments: parsedArgs, skipNext };
}
parseValue(value) {
if (value === 'true')
return true;
if (value === 'false')
return false;
const numValue = Number(value);
if (!isNaN(numValue) && isFinite(numValue)) {
return numValue;
}
return value;
}
parsePortValue(value) {
try {
return (0, validators_1.validatePort)(value);
}
catch {
return null;
}
}
isBooleanFlag(name) {
const booleanFlags = [
'help',
'h',
'version',
'v',
'force',
'f',
'silent',
's',
'dry-run',
'n',
'json',
'j',
];
return booleanFlags.includes(name);
}
getShortFlagName(flag) {
const shortFlagMap = {
h: 'help',
v: 'version',
f: 'force',
s: 'silent',
n: 'dry-run',
j: 'json',
t: 'timeout',
g: 'graceful-timeout',
m: 'method',
r: 'range',
};
return shortFlagMap[flag] || flag;
}
static parseArgs(args) {
const parser = new CommandParser(args);
return parser.parse();
}
}
exports.CommandParser = CommandParser;
//# sourceMappingURL=command-parser.js.map