normalize-metrics 0.1.0

package/dist/index.js

@@ -0,0 +1,220 @@
+import { basename, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { HELP, modeOf, parseArgs } from "./args.js";
+import { emptyConfig, findConfig, mergeConfig } from "./config.js";
+import { discover, discoverFromInclude } from "./discover.js";
+import { runEngine } from "./engine.js";
+import { formatOffset, outputPath } from "./paths.js";
+import { formatReports } from "./report.js";
+import { ProgressStack } from "./progress.js";
+import { EULA, invocationDir, packageVersion, resolvePython } from "./runtime.js";
+import { pathExists } from "./fs-exists.js";
+function phaseFromEngine(phase) {
+    if (phase === "rewriting")
+        return "rewriting";
+    if (phase === "writing" || phase === "done")
+        return "writing";
+    return "analyzing";
+}
+function destLabel(dest) {
+    return basename(dest);
+}
+async function processFile(file, options) {
+    const dest = outputPath(file, options.config, options.inPlace);
+    if (file.kind === "ttc") {
+        const reason = "TTC collections are skipped in v1";
+        options.stack.update(file.abs, { percent: 0, phase: "skipped", detail: reason });
+        return { status: "skipped", reason };
+    }
+    options.stack.update(file.abs, { percent: 4, phase: "analyzing", detail: "analyzing" });
+    try {
+        const inspect = options.mode !== "write";
+        const result = await runEngine({
+            python: options.python,
+            input: file.abs,
+            output: inspect ? undefined : dest,
+            inspect,
+            skipIfGood: options.mode === "write",
+            onProgress: (event) => {
+                options.stack.update(file.abs, {
+                    percent: event.percent,
+                    phase: phaseFromEngine(event.phase),
+                    detail: event.phase,
+                });
+            },
+        });
+        if (result.skip) {
+            options.stack.update(file.abs, { percent: 0, phase: "skipped", detail: result.skip });
+            return { status: "skipped", reason: result.skip };
+        }
+        return finishResult(file.abs, dest, result, options.mode, options.stack);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message.split("\n").at(-1) || "failed" : "failed";
+        options.stack.update(file.abs, { percent: 0, phase: "failed", detail: message });
+        return { status: "failed", message };
+    }
+}
+function alreadyGoodDetail(result) {
+    return `already good  ${formatOffset(result.before?.offset ?? result.after?.offset)}`;
+}
+function finishResult(id, dest, result, mode, stack) {
+    const offset = formatOffset(result.before?.offset);
+    if (result.off === false) {
+        stack.update(id, { percent: 100, phase: "ok", detail: alreadyGoodDetail(result) });
+        return { status: "ok", result };
+    }
+    if (mode === "check") {
+        stack.update(id, { percent: 100, phase: "off", detail: `off  ${offset}` });
+        return { status: "off", result };
+    }
+    if (mode === "dry-run") {
+        stack.update(id, {
+            percent: 100,
+            phase: "done",
+            detail: `→ ${destLabel(dest)}  ${offset} → ${formatOffset(result.after?.offset)}`,
+        });
+        return { status: "would-write", dest, result };
+    }
+    stack.update(id, {
+        percent: 100,
+        phase: "done",
+        detail: `→ ${destLabel(dest)}`,
+    });
+    return { status: "wrote", dest, result };
+}
+function summarize(outcomes, mode) {
+    const counts = {
+        wrote: outcomes.filter((item) => item.status === "wrote").length,
+        would: outcomes.filter((item) => item.status === "would-write").length,
+        ok: outcomes.filter((item) => item.status === "ok").length,
+        off: outcomes.filter((item) => item.status === "off").length,
+        skipped: outcomes.filter((item) => item.status === "skipped").length,
+        failed: outcomes.filter((item) => item.status === "failed").length,
+    };
+    const parts = [];
+    if (mode === "write") {
+        parts.push(`${counts.wrote} wrote`);
+        if (counts.ok)
+            parts.push(`${counts.ok} already good`);
+    }
+    if (mode === "dry-run") {
+        parts.push(`${counts.would} would write`);
+        if (counts.ok)
+            parts.push(`${counts.ok} already good`);
+    }
+    if (mode === "check") {
+        parts.push(`${counts.off} off`);
+        parts.push(`${counts.ok} ok`);
+    }
+    if (counts.skipped)
+        parts.push(`${counts.skipped} skipped`);
+    if (counts.failed)
+        parts.push(`${counts.failed} failed`);
+    return parts.join(" · ");
+}
+function exitCode(outcomes, mode) {
+    if (outcomes.some((item) => item.status === "failed"))
+        return 1;
+    if (mode === "check" && outcomes.some((item) => item.status === "off"))
+        return 1;
+    if (outcomes.length === 0)
+        return 1;
+    return 0;
+}
+async function resolveTargets(args, cwd, config) {
+    if (args.path) {
+        const target = resolve(cwd, args.path);
+        if (!(await pathExists(target))) {
+            throw new Error(`Not found: ${args.path}`);
+        }
+        return discover(target, config);
+    }
+    if (config.include.length) {
+        return discoverFromInclude(cwd, config);
+    }
+    throw new Error("Point it at a file or a folder. See --help.");
+}
+export async function main(argv = process.argv.slice(2)) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        return 2;
+    }
+    if (args.help) {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (args.version) {
+        process.stdout.write(`${await packageVersion()}\n`);
+        return 0;
+    }
+    const cwd = invocationDir();
+    let config = emptyConfig();
+    try {
+        config = mergeConfig(await findConfig(cwd, args.configPath), args, cwd);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        return 2;
+    }
+    if (!config.suffix && !args.inPlace) {
+        console.error("A suffix is required unless you pass --in-place. Default is -normalized.");
+        return 2;
+    }
+    let files;
+    try {
+        files = await resolveTargets(args, cwd, config);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        return 1;
+    }
+    if (!files.length) {
+        console.error("No .otf, .ttf, .woff, or .woff2 files found.");
+        return 1;
+    }
+    let python;
+    try {
+        python = await resolvePython();
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        return 1;
+    }
+    const mode = modeOf(args);
+    const stack = new ProgressStack();
+    const onInterrupt = () => {
+        stack.restore();
+        process.exit(130);
+    };
+    process.on("SIGINT", onInterrupt);
+    process.on("SIGTERM", onInterrupt);
+    stack.identify(files.map((file) => ({ id: file.abs, label: files.length > 1 ? file.rel : file.name })), EULA);
+    const outcomes = [];
+    for (const file of files) {
+        outcomes.push(await processFile(file, { python, mode, inPlace: args.inPlace, config, stack }));
+    }
+    await stack.finish();
+    process.off("SIGINT", onInterrupt);
+    process.off("SIGTERM", onInterrupt);
+    const reports = formatReports(outcomes);
+    if (reports)
+        process.stdout.write(`\n${reports}\n`);
+    const summary = summarize(outcomes, mode);
+    if (summary) {
+        const stream = process.stderr.isTTY ? process.stderr : process.stdout;
+        stream.write(`\n${summary}\n`);
+    }
+    return exitCode(outcomes, mode);
+}
+const invoked = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invoked) {
+    main().then((code) => process.exit(code), (error) => {
+        console.error(error instanceof Error ? error.message : error);
+        process.exit(1);
+    });
+}

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/paths.js

@@ -0,0 +1,22 @@
+import { basename, dirname, extname, join } from "node:path";
+export function outputPath(file, config, inPlace) {
+    if (inPlace)
+        return file.abs;
+    const ext = extname(file.name);
+    const stem = basename(file.name, ext);
+    const named = `${stem}${config.suffix}${ext}`;
+    if (config.outDir) {
+        return join(config.outDir, dirname(file.rel), named);
+    }
+    return join(dirname(file.abs), named);
+}
+export function formatOffset(value) {
+    if (value == null || Number.isNaN(value))
+        return "";
+    const abs = Math.abs(value).toFixed(1);
+    if (value > 0)
+        return `+${abs}‰`;
+    if (value < 0)
+        return `−${abs}‰`;
+    return "0‰";
+}

package/dist/progress.js

@@ -0,0 +1,184 @@
+import { styleText } from "node:util";
+const BAR_WIDTH = 20;
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+const CLEAR_LINE = "\x1b[2K";
+export function renderBar(percent, width = BAR_WIDTH) {
+    const clamped = Math.max(0, Math.min(100, percent));
+    const filled = Math.round((clamped / 100) * width);
+    return "-".repeat(filled) + "·".repeat(width - filled);
+}
+export function formatPercent(percent) {
+    return `${String(Math.round(Math.max(0, Math.min(100, percent)))).padStart(3, " ")}%`;
+}
+function truncate(value, width) {
+    if (value.length <= width)
+        return value;
+    if (width <= 1)
+        return "…";
+    return `${value.slice(0, width - 1)}…`;
+}
+function paint(text, phase, tty) {
+    if (!tty)
+        return text;
+    if (phase === "queued" || phase === "skipped")
+        return styleText("dim", text);
+    if (phase === "failed" || phase === "off")
+        return styleText("red", text);
+    if (phase === "done" || phase === "ok")
+        return styleText("green", text);
+    return text;
+}
+export function formatRow(row, nameWidth, columns, tty = false) {
+    const name = truncate(row.label, nameWidth).padEnd(nameWidth, " ");
+    const budget = Math.max(40, columns);
+    if (row.phase === "skipped" || row.phase === "failed") {
+        const detail = truncate(row.detail, Math.max(8, budget - nameWidth - 12));
+        return paint(`${name}  ${row.phase.padEnd(7, " ")}  ${detail}`, row.phase, tty);
+    }
+    const bar = renderBar(row.percent);
+    const pct = formatPercent(row.percent);
+    const used = nameWidth + 2 + BAR_WIDTH + 2 + pct.length;
+    const detail = row.detail ? `  ${truncate(row.detail, Math.max(0, budget - used - 2))}` : "";
+    return paint(`${name}  ${bar}  ${pct}${detail}`, row.phase, tty);
+}
+function nameWidthOf(rows, columns) {
+    const longest = rows.reduce((max, row) => Math.max(max, row.label.length), 0);
+    const usable = Math.max(columns, 80);
+    return Math.min(Math.max(longest, 8), Math.max(16, usable - BAR_WIDTH - 16));
+}
+export class ProgressStack {
+    rows = new Map();
+    order = [];
+    stream;
+    tty;
+    painted = 0;
+    timer = null;
+    displayed = new Map();
+    targets = new Map();
+    warning = "";
+    constructor(stream = process.stderr) {
+        this.stream = stream;
+        this.tty = Boolean(stream.isTTY);
+    }
+    columns() {
+        const reported = this.stream.columns ?? 0;
+        return reported >= 60 ? reported : 80;
+    }
+    identify(files, warning) {
+        this.warning = warning;
+        for (const file of files) {
+            this.order.push(file.id);
+            this.rows.set(file.id, {
+                id: file.id,
+                label: file.label,
+                percent: 0,
+                phase: "queued",
+                detail: "",
+            });
+            this.displayed.set(file.id, 0);
+            this.targets.set(file.id, 0);
+        }
+        if (this.tty) {
+            this.stream.write(HIDE_CURSOR);
+            if (this.warning)
+                this.stream.write(`${styleText("dim", this.warning)}\n\n`);
+            this.paint(true);
+            this.timer = setInterval(() => this.tick(), 50);
+        }
+        else if (this.warning) {
+            this.stream.write(`${this.warning}\n`);
+        }
+    }
+    update(id, patch) {
+        const row = this.rows.get(id);
+        if (!row)
+            return;
+        if (patch.phase)
+            row.phase = patch.phase;
+        if (patch.detail != null)
+            row.detail = patch.detail;
+        if (patch.percent != null) {
+            row.percent = patch.percent;
+            this.targets.set(id, patch.percent);
+            if (!this.tty)
+                this.displayed.set(id, patch.percent);
+        }
+        if (this.tty)
+            this.paint(false);
+        else if (patch.phase && ["done", "skipped", "failed", "off", "ok"].includes(patch.phase)) {
+            this.stream.write(`${formatRow({ ...row, percent: this.displayed.get(id) ?? row.percent }, row.label.length, 80, false)}\n`);
+        }
+    }
+    async finish() {
+        if (!this.tty)
+            return;
+        const started = Date.now();
+        while (Date.now() - started < 800 && this.needsEase()) {
+            this.tick();
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        for (const id of this.order) {
+            const row = this.rows.get(id);
+            if (row)
+                this.displayed.set(id, row.percent);
+        }
+        this.paint(false);
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        this.stream.write(SHOW_CURSOR);
+    }
+    restore() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        if (this.tty)
+            this.stream.write(SHOW_CURSOR);
+    }
+    needsEase() {
+        return this.order.some((id) => {
+            const shown = this.displayed.get(id) ?? 0;
+            const target = this.targets.get(id) ?? 0;
+            return Math.abs(target - shown) > 0.6;
+        });
+    }
+    tick() {
+        let moved = false;
+        for (const id of this.order) {
+            const shown = this.displayed.get(id) ?? 0;
+            const target = this.targets.get(id) ?? 0;
+            if (Math.abs(target - shown) < 0.4) {
+                if (shown !== target) {
+                    this.displayed.set(id, target);
+                    moved = true;
+                }
+                continue;
+            }
+            const next = shown + (target - shown) * 0.28;
+            this.displayed.set(id, next);
+            moved = true;
+        }
+        if (moved)
+            this.paint(false);
+    }
+    snapshot() {
+        return this.order.map((id) => {
+            const row = this.rows.get(id);
+            return { ...row, percent: this.displayed.get(id) ?? row.percent };
+        });
+    }
+    paint(first) {
+        const columns = this.columns();
+        const rows = this.snapshot();
+        const nameWidth = nameWidthOf(rows, columns);
+        const lines = rows.map((row) => formatRow(row, nameWidth, columns, true));
+        if (!first && this.painted > 0) {
+            this.stream.write(`\x1b[${this.painted}A`);
+        }
+        for (const line of lines) {
+            this.stream.write(`${CLEAR_LINE}${line}\n`);
+        }
+        this.painted = lines.length;
+    }
+}

package/dist/report.js

@@ -0,0 +1,45 @@
+const COL = 32;
+function usedHeight(metrics) {
+    return metrics.ascent + Math.abs(metrics.descent) + metrics.lineGap;
+}
+function formatPercent(value) {
+    const rounded = Math.round(Math.abs(value) * 10) / 10;
+    return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+}
+function leadingChange(before, after) {
+    const from = usedHeight(before);
+    const to = usedHeight(after);
+    if (from <= 0 || Math.abs(to - from) / from < 0.0005) {
+        return "Leading change: unchanged";
+    }
+    const percent = ((to - from) / from) * 100;
+    const label = percent > 0 ? "bigger" : "smaller";
+    return `Leading change: ${formatPercent(percent)}% ${label}`;
+}
+function row(left, right) {
+    return `${left.padEnd(COL, " ")}|    ${right}`;
+}
+export function formatReport(result) {
+    const before = result.before;
+    const after = result.after;
+    if (!before || !after)
+        return null;
+    const name = result.family?.trim() || "Font";
+    return [
+        name,
+        row("Before", "After"),
+        row(`Centered: ${before.centered}%`, `Centered: ${after.centered}%`),
+        leadingChange(before, after),
+    ].join("\n");
+}
+export function formatReports(outcomes) {
+    const blocks = [];
+    for (const item of outcomes) {
+        if (!("result" in item) || !item.result)
+            continue;
+        const block = formatReport(item.result);
+        if (block)
+            blocks.push(block);
+    }
+    return blocks.join("\n\n");
+}

package/dist/runtime.js

@@ -0,0 +1,49 @@
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFile } from "node:fs/promises";
+export const EULA = "Rewriting a licensed font and redistributing the result may violate the EULA. This tool does not legalize the file.";
+export function packageRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+/** Directory the user ran the command from. npm scripts otherwise start at the package root. */
+export function invocationDir() {
+    return process.env.INIT_CWD || process.cwd();
+}
+export function enginePath() {
+    return join(packageRoot(), "lib", "engine.py");
+}
+export async function packageVersion() {
+    const raw = await readFile(join(packageRoot(), "package.json"), "utf8");
+    return JSON.parse(raw).version ?? "0.0.0";
+}
+function run(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+export async function resolvePython() {
+    for (const command of ["python3", "python"]) {
+        try {
+            const probe = await run(command, ["-c", "import fontTools, sys; print(sys.executable)"]);
+            if (probe.code === 0 && probe.stdout.trim())
+                return command;
+        }
+        catch {
+            // try the next name
+        }
+    }
+    throw new Error("The engine needs python3 with fontTools (implementation detail — not a pip product install).");
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};