jscrewit 2.41.0 → 3.1.0

package/screw.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
-/* eslint-env node */
-
 'use strict';
 
+const cli = require('./tools/cli');
+
 function fail()
 {
     process.exit(1);
@@ -11,21 +11,21 @@ function fail()
 
 function getBasename()
 {
-    var path = require('path');
-    var basename = path.basename(process.argv[1]);
+    const path = require('node:path');
+    const basename = path.basename(process.argv[1]);
     return basename;
 }
 
 function printErrorMessage(errorMessage)
 {
-    var basename = getBasename();
+    const basename = getBasename();
     console.error
     ('%s: %s.\nTry "%s --help" for more information.', basename, errorMessage, basename);
 }
 
 function printHelpMessage()
 {
-    var message =
+    const message =
     'Usage: %s [OPTION]... [SOURCE [DESTINATION]]\n' +
     'Encodes JavaScript with JScrewIt.\n' +
     '\n' +
@@ -55,14 +55,14 @@ function printHelpMessage()
     '  none                    (none available)\n' +
     '\n' +
     'See the JScrewIt feature documentation for a list of all supported features.\n';
-    var basename = getBasename();
+    const basename = getBasename();
     console.log(message, basename);
 }
 
 function printVersion()
 {
-    var version = require('./package.json').version;
-    console.log('JScrewIt ' + version);
+    const { version } = require('./package.json');
+    console.log(`JScrewIt ${version}`);
 }
 
 function prompt()
@@ -70,114 +70,98 @@ function prompt()
     process.stdout.write('SCREW> ');
 }
 
-(function ()
+let command;
+try
 {
-    var cli = require('./tools/cli');
-
-    var command;
-    try
-    {
-        command = cli.parseCommandLine(process.argv);
-    }
-    catch (error)
-    {
-        printErrorMessage(error.message);
-        fail();
-    }
-    if (command === 'help')
-    {
-        printHelpMessage();
-        return;
-    }
-    if (command === 'version')
-    {
-        printVersion();
-        return;
-    }
-
-    var inputFileName   = command.inputFileName;
-    var outputFileName  = command.outputFileName;
-    var options         = command.options;
+    command = cli.parseCommandLine(process.argv);
+}
+catch (error)
+{
+    printErrorMessage(error.message);
+    fail();
+}
+if (command === 'help')
+{
+    printHelpMessage();
+    return;
+}
+if (command === 'version')
+{
+    printVersion();
+    return;
+}
 
-    var JScrewIt = require('./'); // '.' doesn't work in Node.js 0.10.
+const { inputFileName, outputFileName, options } = command;
+const JScrewIt = require('.');
 
-    if (inputFileName == null)
-    {
-        var tryEncode =
-        function (input)
-        {
-            var output;
-            try
-            {
-                output = JScrewIt.encode(input, options);
-            }
-            catch (error)
-            {
-                console.error('%s', error.message);
-            }
-            return output;
-        };
-        if (tryEncode('') == null) // validate options
-            fail();
-        var readline = require('readline');
-        var rl = readline.createInterface({ input: process.stdin, terminal: false });
-        rl.on
-        (
-            'line',
-            function (input)
-            {
-                if (input)
-                {
-                    var output = tryEncode(input);
-                    if (output != null)
-                        console.log(output);
-                }
-                prompt();
-            }
-        );
-        prompt();
-    }
-    else
+if (inputFileName == null)
+{
+    const tryEncode =
+    input =>
     {
-        var fs = require('fs');
-        var timeUtils = require('./tools/time-utils');
-
-        var input;
-        var output;
-        var encodingTime;
+        let output;
         try
         {
-            input = fs.readFileSync(inputFileName);
-            encodingTime =
-            timeUtils.timeThis
-            (
-                function ()
-                {
-                    output = JScrewIt.encode(input, options);
-                }
-            );
-            if (outputFileName != null)
-                fs.writeFileSync(outputFileName, output);
-            else
-                console.log(output);
+            output = JScrewIt.encode(input, options);
         }
         catch (error)
         {
             console.error('%s', error.message);
-            fail();
         }
-        if (outputFileName != null)
+        return output;
+    };
+    if (tryEncode('') == null) // validate options
+        fail();
+    const { createInterface } = require('node:readline');
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    rl.on
+    (
+        'line',
+        input =>
         {
-            var perfInfo = options.perfInfo;
-            var perfLog = perfInfo && perfInfo.perfLog;
-            if (perfLog)
+            if (input)
             {
-                var diagnosticReport = cli.createDiagnosticReport(perfLog);
-                console.log(diagnosticReport);
+                const output = tryEncode(input);
+                if (output != null)
+                    console.log(output);
             }
-            var report = cli.createReport(input.length, output.length, encodingTime);
-            console.log(report);
+            prompt();
+        },
+    );
+    prompt();
+}
+else
+{
+    const fs = require('node:fs');
+    const timeUtils = require('./tools/time-utils');
+
+    let input;
+    let output;
+    let encodingTime;
+    try
+    {
+        input = fs.readFileSync(inputFileName);
+        encodingTime =
+        timeUtils.timeThis(() => { output = JScrewIt.encode(input, options); });
+        if (outputFileName != null)
+            fs.writeFileSync(outputFileName, output);
+        else
+            console.log(output);
+    }
+    catch (error)
+    {
+        console.error('%s', error.message);
+        fail();
+    }
+    if (outputFileName != null)
+    {
+        const perfLog = options.perfInfo?.perfLog;
+        if (perfLog)
+        {
+            const diagnosticReport = cli.createDiagnosticReport(perfLog);
+            console.log(diagnosticReport);
         }
+        const report = cli.createReport(input.length, output.length, encodingTime);
+        console.log(report);
     }
 }
-)();

package/tools/cli.js

@@ -1,66 +1,56 @@
-/* eslint-env node */
-/* global padLeft, padRight, repeat */
-
 'use strict';
 
-require('./text-utils');
-var timeUtils = require('./time-utils');
+const { parseArgs } = require('node:util');
+const timeUtils     = require('./time-utils');
 
 function byteCount(size, width)
 {
-    var str = padLeft(size, width) + (size === 1 ? ' byte' : ' bytes');
+    const str = `${String(size).padStart(width)}${size === 1 ? ' byte' : ' bytes'}`;
     return str;
 }
 
 function createDiagnosticReport(perfLog)
 {
-    var report =
-    '\nStrategy                    Status         Length  Time (ms)\n' +
-    repeat('─', 60) + '\n' +
-    perfLog.reduce
-    (
-        function (str, perfInfoList)
-        {
-            str += formatPerfInfoList(perfInfoList, '', ['', '']);
-            return str;
-        },
-        ''
-    );
+    const reportParts =
+    perfLog.map(perfInfoList => formatPerfInfoList(perfInfoList, '', ['', '']));
+    reportParts.unshift
+    (`\nStrategy                    Status         Length  Time (ms)\n${'─'.repeat(60)}\n`);
+    const report = reportParts.join('');
     return report;
 }
 
 function createReport(originalSize, screwedSize, encodingTime)
 {
-    var width = Math.max(widthOf(originalSize), widthOf(screwedSize));
-    var expansionFactorStr = originalSize ? (screwedSize / originalSize).toFixed(2) : '-';
-    var encodingTimeStr = timeUtils.formatDuration(encodingTime);
-    var report =
-    'Original size:    ' + byteCount(originalSize, width) +
-    '\nScrewed size:     ' + byteCount(screwedSize, width) +
-    '\nExpansion factor: ' + expansionFactorStr +
-    '\nEncoding time:    ' + encodingTimeStr;
+    const width = Math.max(widthOf(originalSize), widthOf(screwedSize));
+    const expansionFactorStr = originalSize ? (screwedSize / originalSize).toFixed(2) : '-';
+    const encodingTimeStr = timeUtils.formatDuration(encodingTime);
+    const report =
+    `Original size:    ${byteCount(originalSize, width)
+    }\nScrewed size:     ${byteCount(screwedSize, width)
+    }\nExpansion factor: ${expansionFactorStr
+    }\nEncoding time:    ${encodingTimeStr}`;
     return report;
 }
 
 function formatCodingLog(perfLog, padding, nextCodingLog)
 {
     padding += nextCodingLog ? '│' : ' ';
-    var str = '';
-    var count = perfLog.length;
-    for (var index = 0; index < count; ++index)
+    let str = '';
+    const count = perfLog.length;
+    for (let index = 0; index < count; ++index)
     {
-        var perfInfoList = perfLog[index];
-        var nextPerfInfoList = index < count - 1;
+        const perfInfoList = perfLog[index];
+        const nextPerfInfoList = index < count - 1;
         str += formatPerfInfoList(perfInfoList, padding, nextPerfInfoList ? '├│' : '└ ');
     }
     if (nextCodingLog)
-        str += padding + '\n';
+        str += `${padding}\n`;
     return str;
 }
 
 function formatInt(int)
 {
-    var str = int === undefined ? '-' : int;
+    const str = int === undefined ? '-' : String(int);
     return str;
 }
 
@@ -68,141 +58,82 @@ function formatPerfInfoList(perfInfoList, padding, paddingChars)
 {
     // In the current implementation, perfInfoList.name can be either undefined, a unit path or
     // "legend".
-    var str = padding + paddingChars[0] + (perfInfoList.name || '(default)') + '\n';
+    let str = `${padding}${paddingChars[0]}${perfInfoList.name || '(default)'}\n`;
     padding += paddingChars[1];
-    var count = perfInfoList.length;
-    var paddingLength = padding.length;
-    var perfLog;
-    for (var index = 0; index < count; ++index)
+    const count = perfInfoList.length;
+    const paddingLength = padding.length;
+    for (let index = 0; index < count; ++index)
     {
-        var perfInfo = perfInfoList[index];
-        var next = index < count - 1;
+        const perfInfo = perfInfoList[index];
+        const next = index < count - 1;
         str +=
-        padding + (next ? '├' : '└') +
-        padRight(perfInfo.strategyName, 27 - paddingLength) +
-        padRight(perfInfo.status, 10) +
-        padLeft(formatInt(perfInfo.outputLength), 11) +
-        padLeft(formatInt(perfInfo.time), 11) +
-        '\n';
-        perfLog = perfInfo.perfLog;
+        `${padding
+        }${next ? '├' : '└'
+        }${perfInfo.strategyName.padEnd(27 - paddingLength)
+        }${perfInfo.status.padEnd(10)
+        }${formatInt(perfInfo.outputLength).padStart(11)
+        }${formatInt(perfInfo.time).padStart(11)
+        }\n`;
+        const { perfLog } = perfInfo;
         if (perfLog)
             str += formatCodingLog(perfLog, padding, next);
     }
     return str;
 }
 
-function parseCommandLine(argv)
+function parseCommandLine([,, ...args])
 {
-    function parseFeatures()
-    {
-        var arg2 = argv[++index];
-        if (arg2 === undefined)
-            throw Error('option ' + quote(arg) + ' requires an argument');
-        options.features = arg2.trim().split(/(?:\s+|\s*,\s*)/);
-    }
-
-    function parseFlag(char)
-    {
-        switch (char)
-        {
-        case 'c':
-        case 'w':
-            wrapMode = 'call';
-            break;
-        case 'd':
-            options.perfInfo = { };
-            break;
-        case 'e':
-            wrapMode = 'eval';
-            break;
-        case 't':
-            options.trimCode = true;
-            break;
-        case 'x':
-            express = true;
-            break;
-        default:
-            throw Error('unrecognized flag ' + quote(char));
-        }
-    }
-
-    function parseRunAs()
-    {
-        var arg2 = argv[++index];
-        if (arg2 === undefined)
-            throw Error('option ' + quote(arg) + ' requires an argument');
-        options.runAs = arg2;
-    }
-
-    var inputFileName;
-    var outputFileName;
-    var options = { };
-    var arg;
-    var express;
-    var wrapMode;
-
-    for (var index = 2; index < argv.length; ++index)
-    {
-        arg = argv[index];
-        var flag;
-        if (/^--/.test(arg))
+    const parsed =
+    parseArgs
+    (
         {
-            flag = arg.slice(2);
-            switch (flag)
+            args,
+            options:
             {
-            case 'diagnostic':
-                options.perfInfo = { };
-                break;
-            case 'features':
-                parseFeatures();
-                break;
-            case 'help':
-            case 'version':
-                return flag;
-            case 'run-as':
-            case 'wrap-with':
-                parseRunAs();
-                break;
-            case 'trim-code':
-                options.trimCode = true;
-                break;
-            default:
-                throw Error('unrecognized option ' + quote(arg));
-            }
-        }
-        else if (/^-/.test(arg))
-        {
-            flag = arg.slice(1);
-            if (flag === 'f')
-                parseFeatures();
-            else if (flag === 'r')
-                parseRunAs();
-            else
-                flag.split('').forEach(parseFlag);
-        }
-        else
-        {
-            if (outputFileName != null)
-                throw Error('unexpected argument ' + quote(arg));
-            if (inputFileName != null)
-                outputFileName = arg;
-            else
-                inputFileName = arg;
-        }
-    }
-    if (!options.runAs)
+                'call':         { type: 'boolean', short: 'c' },
+                'diagnostic':   { type: 'boolean', short: 'd' },
+                'eval-flag':    { type: 'boolean', short: 'e' },
+                'express':      { type: 'boolean', short: 'x' },
+                'features':     { type: 'string',  short: 'f' },
+                'help':         { type: 'boolean' },
+                'run-as':       { type: 'string',  short: 'r' },
+                'trim-code':    { type: 'boolean', short: 't' },
+                'version':      { type: 'boolean', short: 'v' },
+                'wrap':         { type: 'boolean', short: 'w' },
+            },
+            allowPositionals:   true,
+            strict:             true,
+        },
+    );
+    const { values, positionals } = parsed;
+    if (values.help)
+        return 'help';
+    if (values.version)
+        return 'version';
+    if (positionals.length > 2)
+        throw Error(`Unexpected argument "${positionals[2]}"`);
+    const [inputFileName, outputFileName] = positionals;
+    const options = { };
+    if (values.diagnostic)
+        options.perfInfo = { };
+    const { features } = values;
+    if (features != null)
+        options.features = features.trim().split(/(?:\s+|\s*,\s*)/);
+    if (values['trim-code'])
+        options.trimCode = true;
+    const runAs = values['run-as'];
+    if (runAs != null)
+        options.runAs = runAs;
+    else
     {
-        var runAs = (express ? ['express'] : []).concat(wrapMode || []).join('-');
+        const { express } = values;
+        const wrapMode =
+        values.call ?? values.wrap ? 'call' : values['eval-flag'] ? 'eval' : undefined;
+        const runAs = (express ? ['express'] : []).concat(wrapMode ?? []).join('-');
         if (runAs)
             options.runAs = runAs;
     }
-    var result = { inputFileName: inputFileName, outputFileName: outputFileName, options: options };
-    return result;
-}
-
-function quote(arg)
-{
-    return '"' + arg + '"';
+    return { inputFileName, outputFileName, options };
 }
 
 function widthOf(size)
@@ -210,9 +141,4 @@ function widthOf(size)
     return String(size).length;
 }
 
-module.exports =
-{
-    createDiagnosticReport: createDiagnosticReport,
-    createReport:           createReport,
-    parseCommandLine:       parseCommandLine,
-};
+module.exports = { createDiagnosticReport, createReport, parseCommandLine };

package/tools/time-utils.js

@@ -1,44 +1,28 @@
-/* eslint-env node */
-/* global Promise */
-
 'use strict';
 
 exports.formatDuration =
 function (duration)
 {
-    var str = duration < 5e-3 ? '< 0.01 s' : duration.toFixed(2) + ' s';
+    const str = duration < 5e-3 ? '< 0.01 s' : `${duration.toFixed(2)} s`;
     return str;
 };
 
 exports.timeThis =
 function (fn)
 {
-    var begin = process.hrtime();
+    const begin = process.hrtime();
     fn();
-    var time = process.hrtime(begin);
-    var duration = time[0] + time[1] / 1e9;
+    const time = process.hrtime(begin);
+    const duration = time[0] + time[1] / 1e9;
     return duration;
 };
 
 exports.timeThisAsync =
-function (fn)
+async function (fn)
 {
-    var begin = process.hrtime();
-    var executor =
-    function (resolve, reject)
-    {
-        fn()
-        .then
-        (
-            function ()
-            {
-                var time = process.hrtime(begin);
-                var duration = time[0] + time[1] / 1e9;
-                resolve(duration);
-            }
-        )
-        .catch(reject);
-    };
-    var promise = new Promise(executor);
-    return promise;
+    const begin = process.hrtime();
+    await fn();
+    const time = process.hrtime(begin);
+    const duration = time[0] + time[1] / 1e9;
+    return duration;
 };