bytecut 0.0.0-stage → 0.0.1

package/dist/optimize-UXM6JEDA.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import {
+  package_default
+} from "./chunk-G53LNJ5O.js";
+import {
+  formatFindings,
+  formatPlan,
+  formatSummary,
+  optimize
+} from "./chunk-CEZK3RQJ.js";
+import "./chunk-3DBJKHOD.js";
+import {
+  isPlaceholderKind,
+  parsePlan,
+  serializePlan
+} from "./chunk-5R7LR5BB.js";
+import {
+  sharpImageEngine
+} from "./chunk-XFJ3HW4X.js";
+import "./chunk-NAKV7HS5.js";
+import {
+  configArg,
+  createVideoEngine,
+  ffmpegInstallText,
+  makeScorerFactory
+} from "./chunk-4XOB3C34.js";
+import "./chunk-M6ZDSATP.js";
+import "./chunk-WE7AEDVI.js";
+import {
+  resolveConfig
+} from "./chunk-YBEC5QGV.js";
+import "./chunk-LHTI3JMC.js";
+import {
+  guarded
+} from "./chunk-J2XJO4JZ.js";
+import {
+  BytecutError,
+  loadConfig
+} from "./chunk-TWI2OZJZ.js";
+
+// src/cli/commands/optimize.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { availableParallelism } from "os";
+import { resolve } from "path";
+import { defineCommand } from "citty";
+var FRAMEWORK_NAMES = {
+  next: "Next.js",
+  astro: "Astro",
+  vite: "Vite",
+  static: "a static site"
+};
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var optimize_default = defineCommand({
+  meta: {
+    name: "optimize",
+    description: "Optimize images into the output folder (sources are never modified)"
+  },
+  args: {
+    ...configArg,
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Write outputs; without it only the plan is printed"
+    },
+    "dry-run": { type: "boolean", description: "Print the plan and write nothing" },
+    json: { type: "boolean", description: "With --dry-run: print the plan as JSON on stdout" },
+    plan: { type: "string", description: "Execute a plan saved with --dry-run --json" },
+    force: {
+      type: "boolean",
+      description: "Re-encode unchanged files and overwrite outputs bytecut does not own"
+    },
+    "out-dir": {
+      type: "string",
+      description: "Output folder (default: from the detected framework)"
+    },
+    "public-path": { type: "string", description: "URL prefix for outputs (default: /_bytecut)" },
+    preset: {
+      type: "string",
+      description: "Force a preset (images: photo, hero, icon; video: background-video, content-video, gif-to-video)"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder to record in the manifest: dominant-color (default), lqip, blurhash or none"
+    },
+    ffmpeg: {
+      type: "string",
+      description: "Path to the ffmpeg binary (otherwise BYTECUT_FFMPEG, then PATH)"
+    },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" },
+    ssimulacra2: {
+      type: "string",
+      description: "Path to a native ssimulacra2 for quality searches (otherwise BYTECUT_SSIMULACRA2, then PATH, then the built-in scorer)"
+    }
+  },
+  run: guarded(async ({ args }) => {
+    const inputs = args._.map(String);
+    const planFile = args.plan;
+    const dryRun = Boolean(args["dry-run"]) || !args.yes;
+    if (planFile && (inputs.length > 0 || args["out-dir"] || args["public-path"])) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "--plan already fixes the sources, output folder and public path; don't combine it with paths, --out-dir or --public-path."
+      );
+    }
+    if (planFile && args.preset) {
+      throw new BytecutError("BAD_ARGUMENTS", "--plan already fixes each file's preset.");
+    }
+    if (args.json && !dryRun) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "--json is only supported with --dry-run for now (stdout would mix two formats)."
+      );
+    }
+    let savedPlan;
+    if (planFile) {
+      const text = await readFile(resolve(planFile), "utf8").catch(() => {
+        throw new BytecutError("INPUT_NOT_FOUND", `Cannot read plan file: ${planFile}`);
+      });
+      savedPlan = parsePlan(text, planFile);
+    }
+    let placeholder;
+    if (args.placeholder !== void 0) {
+      const wanted = String(args.placeholder);
+      if (wanted !== "none" && !isPlaceholderKind(wanted)) {
+        throw new BytecutError(
+          "BAD_ARGUMENTS",
+          `Unknown placeholder "${wanted}". Use dominant-color, lqip, blurhash or none.`
+        );
+      }
+      placeholder = wanted;
+    }
+    const controller = new AbortController();
+    const onSigint = () => controller.abort();
+    if (!dryRun) process.once("SIGINT", onSigint);
+    const projectRoot = process.cwd();
+    const config = await resolveConfig(projectRoot, await loadConfig(projectRoot, args.config));
+    const project = config.project;
+    placeholder ??= config.placeholder;
+    let scanInputs = inputs;
+    if (!savedPlan && inputs.length === 0) {
+      scanInputs = project.include.filter((p) => existsSync(resolve(projectRoot, p)));
+      if (scanInputs.length === 0) {
+        console.error(
+          `bytecut optimize: no asset folder found (looked for ${project.include.join(", ")}). Pass files or folders.`
+        );
+        process.exitCode = 2;
+        return;
+      }
+      console.error(
+        `Detected ${FRAMEWORK_NAMES[project.framework]}: scanning ${scanInputs.join(", ")} \u2192 ${args["out-dir"] ?? project.outDir}`
+      );
+    }
+    const outcome = await optimize({
+      projectRoot,
+      engine: sharpImageEngine,
+      toolVersion: package_default.version,
+      ...savedPlan ? { savedPlan } : { inputs: scanInputs },
+      outDir: savedPlan?.outDir ?? args["out-dir"] ?? project.outDir,
+      staticRoot: project.staticRoot,
+      publicPath: args["public-path"] ?? project.publicPath,
+      policy: config.policy,
+      exclude: config.exclude,
+      makeScorer: makeScorerFactory(args.ssimulacra2, config),
+      ...args.preset ? { presetOverride: args.preset } : {},
+      ...placeholder ? { placeholder } : {},
+      execute: !dryRun,
+      force: Boolean(args.force),
+      concurrency: config.concurrency ?? Math.min(4, availableParallelism()),
+      videoEngine: createVideoEngine({ ffmpeg: args.ffmpeg, ffprobe: args.ffprobe }, config),
+      needsFfmpeg: ffmpegInstallText(),
+      signal: controller.signal,
+      onItemDone: (item, done, total) => console.error(`[${done}/${total}] ${item.source}`),
+      onVideoItemDone: (item, done, total) => console.error(`[video ${done}/${total}] ${item.source}`)
+    });
+    process.off("SIGINT", onSigint);
+    for (const file of outcome.unsupported) {
+      console.warn(`Skipping ${file}: not a supported image (JPEG, PNG, WebP, AVIF).`);
+    }
+    if (outcome.svgs.length > 0) {
+      console.warn(
+        `Skipping ${plural(outcome.svgs.length, "SVG file")}: SVG output is not implemented yet (see \`bytecut audit\`).`
+      );
+    }
+    if (outcome.plan.items.length === 0 && (outcome.plan.videos ?? []).length === 0) {
+      console.log("No images or videos found.");
+      return;
+    }
+    const findings = formatFindings(outcome.findings);
+    for (const note of outcome.notes) console.error(`Note: ${note}`);
+    if (dryRun) {
+      if (args.json) {
+        process.stdout.write(serializePlan(outcome.plan));
+        if (findings) console.error(findings);
+        return;
+      }
+      console.log(formatPlan(outcome.plan, outcome.cache));
+      if (findings) console.log(`
+${findings}`);
+      console.log("\nDry run: nothing written. Re-run with -y to write these outputs.");
+      return;
+    }
+    const result = outcome.result;
+    console.log(formatSummary(result));
+    for (const warning of result.warnings) console.warn(`warning: ${warning}`);
+    if (findings) console.log(`
+${findings}`);
+    if (result.cancelled) process.exitCode = 130;
+    else if (result.items.some((i) => i.status === "failed") || (result.videos ?? []).some((v) => v.status === "failed")) {
+      process.exitCode = 1;
+    }
+  })
+});
+export {
+  optimize_default as default
+};

package/dist/snippet-2WVGMCNV.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import {
+  buildSnippet,
+  originalUrl,
+  snippetFormatFor
+} from "./chunk-U4KJMKI5.js";
+import "./chunk-3DBJKHOD.js";
+import {
+  MANIFEST_FILE,
+  parseManifest
+} from "./chunk-5R7LR5BB.js";
+import {
+  configArg,
+  discover
+} from "./chunk-4XOB3C34.js";
+import "./chunk-M6ZDSATP.js";
+import {
+  toPosix
+} from "./chunk-WE7AEDVI.js";
+import "./chunk-YBEC5QGV.js";
+import {
+  guarded
+} from "./chunk-J2XJO4JZ.js";
+import {
+  BytecutError
+} from "./chunk-TWI2OZJZ.js";
+
+// src/cli/commands/snippet.ts
+import { readFile } from "fs/promises";
+import { relative, resolve } from "path";
+import { defineCommand } from "citty";
+var snippet_default = defineCommand({
+  meta: {
+    name: "snippet",
+    description: "Print the <picture> / <video> markup for files that have been optimized"
+  },
+  args: {
+    ...configArg,
+    format: { type: "string", description: "html or jsx (default: from the detected framework)" },
+    alt: { type: "string", description: "Alt text for images (default: empty, i.e. decorative)" },
+    sizes: { type: "string", description: 'The sizes attribute (default: "100vw")' },
+    class: { type: "string", description: "A class (className in JSX) to add to the element" },
+    priority: {
+      type: "boolean",
+      description: 'Mark as the main image: fetchpriority="high", no lazy loading'
+    },
+    lazy: { type: "boolean", description: "Lazy-load even a priority image" },
+    "out-dir": { type: "string", description: "Output folder (default: from the framework)" },
+    json: { type: "boolean", description: "Print structured data instead of markup" }
+  },
+  run: guarded(async ({ args }) => {
+    const inputs = args._.map(String);
+    if (inputs.length === 0) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "Name at least one optimized file, e.g. `bytecut snippet public/img/hero.jpg`."
+      );
+    }
+    const found = await discover([], args["out-dir"], args.config);
+    const format = args.format ?? snippetFormatFor(found.project);
+    if (format !== "html" && format !== "jsx") {
+      throw new BytecutError("BAD_ARGUMENTS", `--format must be html or jsx, not "${format}".`);
+    }
+    let manifestText;
+    try {
+      manifestText = await readFile(
+        resolve(found.projectRoot, found.outDir, MANIFEST_FILE),
+        "utf8"
+      );
+    } catch {
+      throw new BytecutError(
+        "INPUT_NOT_FOUND",
+        `No manifest at ${found.outDir}/${MANIFEST_FILE}. Run \`bytecut optimize -y\` first.`
+      );
+    }
+    const manifest = parseManifest(manifestText);
+    const results = [];
+    for (const input of inputs) {
+      const source = toPosix(relative(found.projectRoot, resolve(found.projectRoot, input)));
+      const snippet = buildSnippet(
+        manifest,
+        { source, originalUrl: originalUrl(source, found.project.staticRoot) },
+        {
+          format,
+          ...args.alt !== void 0 ? { alt: String(args.alt) } : {},
+          ...args.sizes ? { sizes: String(args.sizes) } : {},
+          ...args.class ? { className: String(args.class) } : {},
+          ...args.priority ? { priority: true } : {},
+          ...args.lazy ? { lazy: true } : {}
+        }
+      );
+      if (!snippet) {
+        throw new BytecutError(
+          "INPUT_NOT_FOUND",
+          `${source} has not been optimized yet. Run \`bytecut optimize -y ${input}\` first.`
+        );
+      }
+      results.push(snippet);
+    }
+    if (args.json) {
+      process.stdout.write(
+        `${JSON.stringify({ version: 1, format, snippets: results }, null, 2)}
+`
+      );
+      return;
+    }
+    console.log(results.map((s) => s.code).join("\n\n"));
+    for (const s of results)
+      for (const hint of s.hints) console.error(`Note (${s.source}): ${hint}`);
+  })
+});
+export {
+  snippet_default as default
+};