@vanhanit/pre-compress 1.0.1 → 1.0.2

package/dist/args.js

@@ -12,13 +12,18 @@ const OPTIONS = {
     version: { type: "boolean", short: "V" },
     help: { type: "boolean", short: "h" }
 };
-const HELP = [
-    ["-f, --files <files...>", "the files to compress, supports glob patterns to match multiple files"],
-    ["-d, --delete-larger", "delete compressed files that are not smaller than the source"],
-    ["-s, --skip-existing", "don't compress if the compressed version is newer than the source"],
-    ["-V, --version", "output the version number"],
-    ["-h, --help", "display help for command"]
-];
+const DESCRIPTIONS = {
+    files: "the files to compress, supports glob patterns to match multiple files",
+    "delete-larger": "delete compressed files that are not smaller than the source",
+    "skip-existing": "don't compress if the compressed version is newer than the source",
+    version: "output the version number",
+    help: "display help for command"
+};
+function flags(name) {
+    const option = OPTIONS[name];
+    const value = option.type === "string" ? ` <${name}...>` : "";
+    return `-${option.short}, --${name}${value}`;
+}
 function parse(args) {
     try {
         return parseArgs({ args: [...args], options: OPTIONS, allowPositionals: true });
@@ -40,20 +45,23 @@ export function parseArguments(args) {
     }
     const patterns = [...(values.files ?? []), ...positionals];
     if (patterns.length === 0) {
-        throw new ArgumentError("required option '-f, --files <files...>' not specified");
+        throw new ArgumentError(`required option '${flags("files")}' not specified`);
     }
     return {
         name: "compress",
         patterns,
-        deleteLarger: values["delete-larger"] ?? false,
-        skipExisting: values["skip-existing"] ?? false
+        options: {
+            deleteLarger: values["delete-larger"] ?? false,
+            skipExisting: values["skip-existing"] ?? false
+        }
     };
 }
 /**
  * Returns the help text.
  */
 export function usage(name, description) {
-    const width = Math.max(...HELP.map(([flags]) => flags.length));
-    const options = HELP.map(([flags, text]) => `  ${flags.padEnd(width)}  ${text}`);
+    const names = Object.keys(OPTIONS);
+    const width = Math.max(...names.map((option) => flags(option).length));
+    const options = names.map((option) => `  ${flags(option).padEnd(width)}  ${DESCRIPTIONS[option]}`);
     return [`Usage: ${name} [options]`, "", description, "", "Options:", ...options].join("\n");
 }

package/dist/cli.js

@@ -5,41 +5,29 @@ import { ArgumentError, parseArguments, usage } from "./args.js";
 import { compressFile, isCompressed } from "./compress.js";
 import { mapConcurrently } from "./concurrency.js";
 import { findFiles } from "./files.js";
-import { formatDuration, pluralize } from "./format.js";
 import { readPackageInfo } from "./package-info.js";
-function report({ file, size, outputs }, io) {
-    for (const output of outputs) {
-        if (output.status === "written") {
-            io.log(`Compressed file ${styleText("yellow", file)} to ${styleText("green", output.file)}`);
-        }
-        else if (output.status === "skipped") {
-            io.log(`Skipped file ${styleText("yellow", output.file)} because it is up to date`);
-        }
-        else {
-            io.log(`Deleted file ${styleText("red", output.file)} because ${output.size} byte(s) is not smaller than ${size} byte(s)`);
-        }
-    }
-}
-async function compress(command, io) {
+import { describeResult, summarize } from "./report.js";
+const consoleIo = {
+    log: (message) => console.log(message),
+    error: (message) => console.error(message),
+    style: (color, text) => styleText(color, text)
+};
+async function compress({ patterns, options }, io) {
     const startTime = performance.now();
-    const files = (await findFiles(command.patterns)).filter((file) => !isCompressed(file));
+    const files = (await findFiles(patterns)).filter((file) => !isCompressed(file));
     const results = await mapConcurrently(files, availableParallelism(), async (file) => {
-        const result = await compressFile(file, command);
-        report(result, io);
+        const result = await compressFile(file, options);
+        for (const line of describeResult(result, io.style)) {
+            io.log(line);
+        }
         return result;
     });
-    const timeTakenMs = performance.now() - startTime;
-    const outputs = results.flatMap((result) => result.outputs);
-    const count = (status) => outputs.filter((output) => output.status === status).length;
-    io.log(`Processed ${pluralize(files.length, "file")} in ${styleText("green", formatDuration(timeTakenMs))}: ` +
-        `${styleText("green", String(count("written")))} written, ` +
-        `${styleText("yellowBright", String(count("skipped")))} skipped, ` +
-        `${styleText("red", String(count("deleted")))} deleted`);
+    io.log(summarize(results, performance.now() - startTime, io.style));
 }
 /**
  * Runs the command line interface with the arguments, without the node and script paths, and returns the exit code.
  */
-export async function run(args, io = console) {
+export async function run(args, io = consoleIo) {
     const { command: name, version, description } = readPackageInfo();
     try {
         const command = parseArguments(args);

package/dist/main.js

@@ -1,3 +1,6 @@
 #!/usr/bin/env node
-import { run } from "./cli.js";
+import { configureThreadPool } from "./thread-pool.js";
+// The CLI is loaded afterwards, so nothing can use the thread pool before it is sized.
+configureThreadPool();
+const { run } = await import("./cli.js");
 process.exitCode = await run(process.argv.slice(2));

package/dist/report.js

@@ -0,0 +1,30 @@
+import { formatDuration, pluralize } from "./format.js";
+function describeOutput(file, size, output, style) {
+    switch (output.status) {
+        case "written":
+            return `Compressed file ${style("yellow", file)} to ${style("green", output.file)}`;
+        case "skipped":
+            return `Skipped file ${style("yellow", output.file)} because it is up to date`;
+        case "deleted":
+            return `Deleted file ${style("red", output.file)} because ${output.size} byte(s) is not smaller than ${size} byte(s)`;
+    }
+}
+/**
+ * Returns a line for every compressed file written, skipped or deleted for a source file.
+ */
+export function describeResult({ file, size, outputs }, style) {
+    return outputs.map((output) => describeOutput(file, size, output, style));
+}
+/**
+ * Returns a line counting what was done to the compressed files of all processed source files.
+ */
+export function summarize(results, milliseconds, style) {
+    const counts = { written: 0, skipped: 0, deleted: 0 };
+    for (const output of results.flatMap((result) => result.outputs)) {
+        counts[output.status]++;
+    }
+    return (`Processed ${pluralize(results.length, "file")} in ${style("green", formatDuration(milliseconds))}: ` +
+        `${style("green", String(counts.written))} written, ` +
+        `${style("yellowBright", String(counts.skipped))} skipped, ` +
+        `${style("red", String(counts.deleted))} deleted`);
+}

package/dist/thread-pool.js

@@ -0,0 +1,9 @@
+import { availableParallelism } from "node:os";
+const DEFAULT_SIZE = 4;
+/**
+ * Sizes libuv's thread pool, which runs the compression, to the available cores. Its default of 4 threads leaves the
+ * other cores idle. Takes effect only before the pool is first used, and keeps a size that is already set.
+ */
+export function configureThreadPool(env = process.env, cores = availableParallelism()) {
+    env.UV_THREADPOOL_SIZE ??= String(Math.max(DEFAULT_SIZE, cores));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanhanit/pre-compress",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Compress static files to be served by a web server.",
   "author": "Thomas Vanhaniemi",
   "type": "module",