towel-txt 0.1.0

package/dist/cli/assets.js

@@ -0,0 +1,50 @@
+import { copyFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { extractImageReferences } from "../parser/images.js";
+export async function copyLocalImageAssets(options) {
+    const inputDirectory = path.dirname(options.inputPath);
+    const outputDirectory = path.dirname(options.outputPath);
+    const imageReferences = extractImageReferences(options.markdown);
+    return Promise.all(imageReferences.map(async (reference) => {
+        if (reference.status === "skipped") {
+            return {
+                reason: reference.reason,
+                source: reference.source,
+                status: "skipped"
+            };
+        }
+        const { source } = reference;
+        const normalizedSource = source.replace(/\\/g, "/");
+        const targetSource = getTargetSource(normalizedSource, options.assetDirectory);
+        const sourcePath = path.resolve(inputDirectory, normalizedSource);
+        const targetPath = path.resolve(outputDirectory, targetSource);
+        if (sourcePath === targetPath) {
+            return {
+                reason: "already in output directory",
+                source,
+                status: "skipped",
+                targetSource
+            };
+        }
+        try {
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await copyFile(sourcePath, targetPath);
+            return { source, status: "copied", targetSource };
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : "Unable to copy image asset.",
+                source,
+                status: "missing",
+                targetSource
+            };
+        }
+    }));
+}
+function getTargetSource(source, assetDirectory) {
+    const normalizedSource = source.replace(/\\/g, "/");
+    if (!assetDirectory) {
+        return normalizedSource;
+    }
+    return `${assetDirectory}/${normalizedSource}`;
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,29 @@
+import { type OutputFormat } from "./args.js";
+import { type ThemeName } from "../theme/themes.js";
+export interface CliConfigDefaults {
+    assetDirectory?: string;
+    browserPath?: string;
+    cover?: boolean;
+    cssPath?: string;
+    format?: OutputFormat;
+    margin?: string;
+    minify?: boolean;
+    outputPath?: string;
+    pageSize?: string;
+    strict?: boolean;
+    subtitle?: string;
+    summaryJsonPath?: string;
+    tableOfContents?: boolean;
+    theme?: ThemeName;
+    title?: string;
+}
+export interface LoadedCliConfig {
+    defaults: CliConfigDefaults;
+    path: string;
+}
+export declare function loadCliConfig({ configPath, cwd, noConfig }: {
+    configPath: string | undefined;
+    cwd: string;
+    noConfig: boolean;
+}): Promise<LoadedCliConfig | undefined>;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/cli/config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEjE,MAAM,WAAW,iBAAiB;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd;AAyBD,wBAAsB,aAAa,CAAC,EAClC,UAAU,EACV,GAAG,EACH,QAAQ,EACT,EAAE;IACD,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAuBvC"}

package/dist/cli/config.js

@@ -0,0 +1,200 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { CliUsageError } from "./args.js";
+import { isThemeName } from "../theme/themes.js";
+const defaultConfigFilenames = [
+    "towel-txt.config.yaml",
+    "towel-txt.config.yml",
+    "towel-txt.config.json"
+];
+const supportedFields = new Set([
+    "assetDir",
+    "browser",
+    "cover",
+    "css",
+    "format",
+    "margin",
+    "minify",
+    "output",
+    "pageSize",
+    "strict",
+    "subtitle",
+    "summaryJson",
+    "tableOfContents",
+    "theme",
+    "title"
+]);
+export async function loadCliConfig({ configPath, cwd, noConfig }) {
+    if (configPath && noConfig) {
+        throw new CliUsageError("Do not pass --config with --no-config.");
+    }
+    if (noConfig) {
+        return undefined;
+    }
+    const resolvedConfigPath = configPath
+        ? path.resolve(cwd, configPath)
+        : await findDefaultConfig(cwd);
+    if (!resolvedConfigPath) {
+        return undefined;
+    }
+    const rawConfig = await readConfigFile(resolvedConfigPath);
+    return {
+        defaults: normalizeConfig(rawConfig, path.dirname(resolvedConfigPath)),
+        path: resolvedConfigPath
+    };
+}
+function normalizeConfig(value, configDirectory) {
+    if (!isPlainRecord(value)) {
+        throw new CliUsageError("Config file must contain a mapping.");
+    }
+    const unknownFields = Object.keys(value).filter((field) => !supportedFields.has(field));
+    if (unknownFields.length > 0) {
+        throw new CliUsageError(`Unsupported config field: ${unknownFields.join(", ")}.`);
+    }
+    return {
+        assetDirectory: getOptionalAssetDirectory(value.assetDir, "assetDir"),
+        browserPath: getOptionalPath(value.browser, configDirectory, {
+            allowBareCommand: true,
+            fieldName: "browser"
+        }),
+        cover: getOptionalBoolean(value.cover, "cover"),
+        cssPath: getOptionalPath(value.css, configDirectory, {
+            allowBareCommand: false,
+            fieldName: "css"
+        }),
+        format: getOptionalFormat(value.format),
+        margin: getOptionalString(value.margin, "margin"),
+        minify: getOptionalBoolean(value.minify, "minify"),
+        outputPath: getOptionalPath(value.output, configDirectory, {
+            allowBareCommand: false,
+            fieldName: "output"
+        }),
+        pageSize: getOptionalString(value.pageSize, "pageSize"),
+        strict: getOptionalBoolean(value.strict, "strict"),
+        subtitle: getOptionalString(value.subtitle, "subtitle"),
+        summaryJsonPath: getOptionalPath(value.summaryJson, configDirectory, {
+            allowBareCommand: false,
+            fieldName: "summaryJson"
+        }),
+        tableOfContents: getOptionalBoolean(value.tableOfContents, "tableOfContents"),
+        theme: getOptionalTheme(value.theme),
+        title: getOptionalString(value.title, "title")
+    };
+}
+function getOptionalString(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new CliUsageError(`Config field "${fieldName}" must be a string.`);
+}
+function getOptionalAssetDirectory(value, fieldName) {
+    const directory = getOptionalString(value, fieldName)?.trim();
+    if (!directory) {
+        return undefined;
+    }
+    if (directory.includes("?") ||
+        directory.includes("#") ||
+        /^[a-z][a-z0-9+.-]*:/iu.test(directory) ||
+        directory.startsWith("/") ||
+        directory.startsWith("\\")) {
+        throw new CliUsageError(`Config field "${fieldName}" must be a safe relative directory.`);
+    }
+    const normalizedDirectory = directory.replace(/\\/g, "/");
+    const parts = normalizedDirectory.split("/");
+    if (parts.includes("..") || parts.includes("")) {
+        throw new CliUsageError(`Config field "${fieldName}" must be a safe relative directory.`);
+    }
+    return normalizedDirectory;
+}
+function getOptionalPath(value, configDirectory, { allowBareCommand, fieldName }) {
+    const configValue = getOptionalString(value, fieldName);
+    if (!configValue) {
+        return undefined;
+    }
+    if (path.isAbsolute(configValue) || (allowBareCommand && isBareCommand(configValue))) {
+        return configValue;
+    }
+    return path.resolve(configDirectory, configValue);
+}
+function getOptionalBoolean(value, fieldName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    throw new CliUsageError(`Config field "${fieldName}" must be a boolean.`);
+}
+function getOptionalFormat(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (value === "html" || value === "pdf") {
+        return value;
+    }
+    throw new CliUsageError('Config field "format" must be "html" or "pdf".');
+}
+function getOptionalTheme(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (isThemeName(value)) {
+        return value;
+    }
+    throw new CliUsageError('Config field "theme" must be "default", "compact", or "report".');
+}
+async function readConfigFile(configPath) {
+    let content;
+    try {
+        content = await readFile(configPath, "utf8");
+    }
+    catch (error) {
+        if (isFileNotFound(error)) {
+            throw new CliUsageError(`Config file not found: ${configPath}.`);
+        }
+        throw error;
+    }
+    try {
+        return parseYaml(content) ?? {};
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid config file.";
+        throw new CliUsageError(`Invalid config file: ${message}`);
+    }
+}
+async function findDefaultConfig(cwd) {
+    for (const filename of defaultConfigFilenames) {
+        const candidate = path.resolve(cwd, filename);
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (isFileNotFound(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function isFileNotFound(error) {
+    const code = error instanceof Error && "code" in error ? error.code : undefined;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+function isBareCommand(value) {
+    return !value.includes("/") && !value.includes("\\");
+}
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/cli/exit-codes.d.ts

@@ -0,0 +1,8 @@
+export declare const cliExitCodes: {
+    readonly renderError: 1;
+    readonly strictWarnings: 3;
+    readonly success: 0;
+    readonly usageError: 2;
+};
+export type CliExitCode = (typeof cliExitCodes)[keyof typeof cliExitCodes];
+//# sourceMappingURL=exit-codes.d.ts.map

package/dist/cli/exit-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-codes.d.ts","sourceRoot":"","sources":["../../src/cli/exit-codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/dist/cli/exit-codes.js

@@ -0,0 +1,6 @@
+export const cliExitCodes = {
+    renderError: 1,
+    strictWarnings: 3,
+    success: 0,
+    usageError: 2
+};

package/dist/cli/pdf.d.ts

@@ -0,0 +1,9 @@
+export interface PdfPrintOptions {
+    basePath?: string;
+    browserPath?: string;
+    html: string;
+    outputPath: string;
+}
+export declare function printHtmlToPdf({ basePath, browserPath, html, outputPath }: PdfPrintOptions): Promise<void>;
+export declare function addBaseHref(html: string, basePath: string | undefined): string;
+//# sourceMappingURL=pdf.d.ts.map

package/dist/cli/pdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf.d.ts","sourceRoot":"","sources":["../../src/cli/pdf.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,cAAc,CAAC,EACnC,QAAQ,EACR,WAAW,EACX,IAAI,EACJ,UAAU,EACX,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBjC;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAS9E"}

package/dist/cli/pdf.js

@@ -0,0 +1,164 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { CliUsageError } from "./args.js";
+export async function printHtmlToPdf({ basePath, browserPath, html, outputPath }) {
+    const browserExecutable = browserPath ?? (await findBrowserExecutable());
+    if (!browserExecutable) {
+        throw new CliUsageError("No supported browser found. Install Chrome, Edge, or Chromium, or pass --browser <path>.");
+    }
+    const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), "towel-txt-pdf-"));
+    const temporaryHtmlPath = path.join(temporaryDirectory, "document.html");
+    try {
+        await writeFile(temporaryHtmlPath, addBaseHref(html, basePath), "utf8");
+        await runBrowserPrint(browserExecutable, temporaryHtmlPath, outputPath);
+        await assertPdfWasCreated(outputPath);
+    }
+    finally {
+        await rm(temporaryDirectory, { force: true, recursive: true });
+    }
+}
+export function addBaseHref(html, basePath) {
+    if (!basePath) {
+        return html;
+    }
+    const baseHref = pathToFileURL(`${path.resolve(basePath)}${path.sep}`).href;
+    const baseElement = `<base href="${escapeHtmlAttribute(baseHref)}">`;
+    return html.replace(/<head>/i, `<head>\n    ${baseElement}`);
+}
+async function findBrowserExecutable() {
+    const configuredBrowser = process.env.TOWEL_TXT_BROWSER?.trim();
+    if (configuredBrowser) {
+        return configuredBrowser;
+    }
+    for (const candidate of getBrowserCandidates()) {
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    for (const commandName of getBrowserCommandNames()) {
+        const executable = await findOnPath(commandName);
+        if (executable) {
+            return executable;
+        }
+    }
+    return undefined;
+}
+function getBrowserCandidates() {
+    if (process.platform === "win32") {
+        return [
+            getOptionalPath(process.env.ProgramFiles, "Microsoft", "Edge", "Application", "msedge.exe"),
+            getOptionalPath(process.env["ProgramFiles(x86)"], "Microsoft", "Edge", "Application", "msedge.exe"),
+            getOptionalPath(process.env.ProgramFiles, "Google", "Chrome", "Application", "chrome.exe"),
+            getOptionalPath(process.env["ProgramFiles(x86)"], "Google", "Chrome", "Application", "chrome.exe"),
+            getOptionalPath(process.env.LOCALAPPDATA, "Google", "Chrome", "Application", "chrome.exe")
+        ].filter((candidate) => Boolean(candidate));
+    }
+    if (process.platform === "darwin") {
+        return [
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            "/Applications/Chromium.app/Contents/MacOS/Chromium"
+        ];
+    }
+    return [];
+}
+function getBrowserCommandNames() {
+    if (process.platform === "win32") {
+        return ["msedge", "chrome", "chromium"];
+    }
+    if (process.platform === "darwin") {
+        return ["google-chrome", "microsoft-edge", "chromium"];
+    }
+    return [
+        "google-chrome",
+        "google-chrome-stable",
+        "microsoft-edge",
+        "chromium",
+        "chromium-browser"
+    ];
+}
+function getOptionalPath(...parts) {
+    if (parts.some((part) => !part)) {
+        return undefined;
+    }
+    return path.join(...parts);
+}
+async function findOnPath(commandName) {
+    const pathEntries = process.env.PATH?.split(path.delimiter).filter(Boolean) ?? [];
+    const executableNames = getExecutableNames(commandName);
+    for (const pathEntry of pathEntries) {
+        for (const executableName of executableNames) {
+            const candidate = path.join(pathEntry, executableName);
+            if (await fileExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+function getExecutableNames(commandName) {
+    if (process.platform !== "win32" || path.extname(commandName)) {
+        return [commandName];
+    }
+    const pathExtensions = process.env.PATHEXT?.split(";").filter(Boolean) ?? [
+        ".COM",
+        ".EXE",
+        ".BAT",
+        ".CMD"
+    ];
+    return pathExtensions.map((extension) => `${commandName}${extension.toLowerCase()}`);
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        const code = error instanceof Error && "code" in error ? error.code : undefined;
+        if (code === "ENOENT" || code === "ENOTDIR") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function assertPdfWasCreated(outputPath) {
+    if (await fileExists(outputPath)) {
+        return;
+    }
+    throw new Error("Browser PDF export completed without creating the output file.");
+}
+function runBrowserPrint(browserExecutable, htmlPath, outputPath) {
+    return new Promise((resolve, reject) => {
+        const browser = spawn(browserExecutable, [
+            "--headless=new",
+            "--disable-gpu",
+            "--allow-file-access-from-files",
+            `--print-to-pdf=${outputPath}`,
+            pathToFileURL(htmlPath).href
+        ], {
+            stdio: ["ignore", "ignore", "pipe"],
+            windowsHide: true
+        });
+        const stderrChunks = [];
+        browser.stderr.on("data", (chunk) => {
+            stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        browser.on("error", reject);
+        browser.on("close", (exitCode) => {
+            if (exitCode === 0) {
+                resolve();
+                return;
+            }
+            const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+            const details = stderr ? ` ${stderr}` : "";
+            reject(new Error(`Browser PDF export failed with exit code ${exitCode}.${details}`));
+        });
+    });
+}
+function escapeHtmlAttribute(value) {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}

package/dist/cli/run.d.ts

@@ -0,0 +1,16 @@
+import { type OutputFormat } from "./args.js";
+import { type PdfPrintOptions } from "./pdf.js";
+import { type WatchFilesOptions } from "./watch.js";
+export interface CliIo {
+    cwd: string;
+    pdfPrinter?: (options: PdfPrintOptions) => Promise<void>;
+    signal?: AbortSignal;
+    stderr: Pick<NodeJS.WriteStream, "write">;
+    stdin?: NodeJS.ReadableStream;
+    stdout: Pick<NodeJS.WriteStream, "write">;
+    watcher?: (options: WatchFilesOptions) => Promise<void>;
+}
+export declare function runCli(argv: string[], io?: CliIo): Promise<number>;
+export declare function getHelpText(): string;
+export declare function getDefaultOutputPath(inputPath: string, format?: OutputFormat): string;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/cli/run.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,YAAY,EAElB,MAAM,WAAW,CAAC;AAInB,OAAO,EAAE,KAAK,eAAe,EAAkB,MAAM,UAAU,CAAC;AAEhE,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,CA8FxF;AA2JD,wBAAgB,WAAW,IAAI,MAAM,CAsCpC;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,YAAqB,GAAG,MAAM,CAG7F"}