imgtune 0.1.0 → 0.3.0

package/dist/media-prepare.js

@@ -0,0 +1,31 @@
+// Makes a media file readable by the pipeline and probes it: the shared step of `imgtune image` (media-file.ts) and the scan's
+// media phase (media-phase.ts). Kept apart from media-file.ts, which imports the scan's remote.ts helpers, so the phase can use
+// it without a cycle. A plain file is probed with ffprobe; an animated WebP is read frame by frame (webp-animation.ts), since
+// ffmpeg cannot read it, and its probe is taken from the animation.
+import { animationOf } from "./animated.js";
+import { probeMedia } from "./ffmpeg.js";
+import { WebpAnimation } from "./webp-animation.js";
+import { MAX_INPUT_PIXELS_FFMPEG } from "./media-limits.js";
+/** Longest a probe of one file may take, in ms. */
+export const PROBE_MS = 30_000;
+/** The frame rate of an animated WebP's constant-rate timeline. */
+export const WEBP_FPS = 30;
+/**
+ * Makes a file readable and probes it. An animated WebP is opened as a WebpAnimation (no frame is decoded here): its probe is its
+ * canvas size and its length. `framePixelLimit` is the per-frame pixel limit (MAX_INPUT_PIXELS_FFMPEG by default; a test lowers
+ * it). An APNG reports no length to ffprobe, so its animation length stands in. Throws with the reason when the file cannot be
+ * read, or is too large to score.
+ */
+export async function prepareMedia(path, buffer, _dir, framePixelLimit = MAX_INPUT_PIXELS_FFMPEG, _signal) {
+    const animation = animationOf(buffer);
+    if (animation?.format === "webp") {
+        const webp = new WebpAnimation(buffer, WEBP_FPS, framePixelLimit);
+        const probe = { durationS: webp.durationMs / 1000, width: webp.width, height: webp.height, fps: WEBP_FPS, videoCodec: "webp" };
+        return { source: webp, probe, animation };
+    }
+    const probe = await probeMedia(path, PROBE_MS);
+    if (!probe)
+        throw new Error("ffprobe could not read this file");
+    const sized = animation && !(probe.durationS > 0) ? { ...probe, durationS: animation.durationMs / 1000 } : probe;
+    return { source: path, probe: sized, animation };
+}

package/dist/px.js

@@ -0,0 +1,11 @@
+// Whole-px rounding of a proposed sizes value. A fitted length is rounded in the direction that keeps the chosen srcset
+// candidate covering the need: a length up, a plus offset up, and a minus offset down in magnitude (so the value is not
+// below the fit). A `sizes` value like 190.04px is never printed.
+/** A px length as whole px, rounded up (190.04 -> 191). */
+export function wholePx(px) {
+    return Math.ceil(px - 1e-9);
+}
+/** A signed px offset of a calc(): a plus offset rounded up, a minus offset rounded down in magnitude. */
+export function offsetPx(b) {
+    return b < 0 ? -Math.floor(-b + 1e-9) : Math.ceil(b - 1e-9);
+}

package/dist/recheck.js

@@ -6,11 +6,12 @@ import { resolve } from "node:path";
 import { launchChromium } from "./browser.js";
 import { DEFAULT_VIEWPORTS } from "./config.js";
 import { hasFix } from "./images.js";
-import { parseGpuDevice } from "./gpu.js";
+import { gpuSettingOf, gpuSettingOne } from "./gpu.js";
 import { parseViewports, safeText, scanOnce, scorerNote } from "./remote.js";
 import { settleLimit } from "./concurrency.js";
 import { cleanRecord } from "./locate-join.js";
 import { batchLine, rowLine } from "./recheck-rows.js";
+import { hiddenSummaryLine } from "./hints.js";
 import { parseAllowHosts, thirdPartyFromFlags } from "./third-party.js";
 /** Browser contexts (one per viewport loaded) a recheck keeps in flight over all its pages together. */
 export const RECHECK_CONTEXTS = 3;
@@ -46,7 +47,7 @@ export function parseRecheckArgs(argv) {
         if (arg === "--allow-third-party")
             continue;
         if (arg === "--gpu") {
-            gpu ??= { device: 0 };
+            gpu ??= gpuSettingOne(0);
             continue;
         }
         if (arg === "--no-cache") {
@@ -61,7 +62,7 @@ export function parseRecheckArgs(argv) {
             if (arg === "--recheck")
                 files.push(value);
             else if (arg === "--gpu-device")
-                gpu = { device: parseGpuDevice(value) };
+                gpu = gpuSettingOf(value);
             else if (arg === "--viewports")
                 viewports = parseViewports(value);
             else if (arg === "--allow-host")
@@ -210,7 +211,11 @@ export function compareImage(before, after, unchangedSrc, how = { ambiguous: 0 }
     const reused = unchangedSrc ? " (src unchanged: estimate reused)" : "";
     lines.push(`  hint   sizes ${sizesBefore} -> ${sizesAfter}  saves ${kb(savedBefore)} -> ${kb(savedAfter)}${reused}`);
     // Predicted (the hint, per view, averaged over viewports) next to measured (served bytes at the same viewports).
-    const split = before.fix.bytes.sizes !== undefined ? ` (sizes ${kb(before.fix.bytes.sizes)}, quality ${kb(before.fix.bytes.quality ?? 0)})` : "";
+    const split = before.fix.bytes.resize !== undefined
+        ? ` (sizes ${kb(before.fix.bytes.sizes ?? 0)}, resize ${kb(before.fix.bytes.resize)}, quality ${kb(before.fix.bytes.quality ?? 0)})`
+        : before.fix.bytes.sizes !== undefined
+            ? ` (sizes ${kb(before.fix.bytes.sizes)}, quality ${kb(before.fix.bytes.quality ?? 0)})`
+            : "";
     const predicted = `predicted ${saving(savedBefore)}/view${split}`;
     const mean = measured.length > 0 ? measured.reduce((sum, b) => sum + b, 0) / measured.length : undefined;
     if (mean !== undefined)
@@ -369,6 +374,9 @@ async function recheckPage(file, args, cwd, log, options) {
     if (details.length > 0)
         out.push("", "not passed:", ...details);
     out.push(batchLine(rows, seconds) + ` on ${safeText(target.href)} at ${viewports.length} viewport(s)`);
+    const hiddenLine = hiddenSummaryLine(fresh.hidden);
+    if (hiddenLine !== undefined)
+        out.push(hiddenLine);
     out.push(failures.length === 0 ? "ok: no image became undersized, and no bytes rose without a sharpness fix" : `FAILED: ${failures.length} check(s)`);
     for (const failure of failures)
         out.push(`  ${safeText(failure)}`);