@vivliostyle/cli 9.0.0-next.3 → 9.0.0-next.5

package/dist/chunk-UQHNZL7X.js

@@ -0,0 +1,590 @@
+import {
+  resolveViteConfig
+} from "./chunk-4ZNBH6IA.js";
+import {
+  Logger,
+  buildPDFWithContainer,
+  buildWebPublication,
+  cleanupWorkspace,
+  collectVolumeArgs,
+  compile,
+  copyAssets,
+  createViteServer,
+  cwd,
+  getFullBrowserName,
+  getViewerFullUrl,
+  isInContainer,
+  isUnicodeSupported,
+  isWebPubConfig,
+  launchPreview,
+  loadVivliostyleConfig,
+  mergeInlineConfig,
+  pathEquals,
+  prepareThemeDirectory,
+  randomBookSymbol,
+  resolveTaskConfig,
+  runContainer,
+  runExitHandlers,
+  setupConfigFromFlags,
+  toContainerPath,
+  warnDeprecatedConfig
+} from "./chunk-SPYTZBBG.js";
+import {
+  coreVersion
+} from "./chunk-EX7EA34F.js";
+import {
+  importNodeModule
+} from "./chunk-WX6JHPSL.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-BIEQXUOY.js";
+
+// src/core/build.ts
+import { pathToFileURL } from "node:url";
+import terminalLink2 from "terminal-link";
+import upath3 from "upath";
+import { build as viteBuild } from "vite";
+import { cyan as cyan2 } from "yoctocolors";
+
+// src/output/pdf.ts
+import fs2 from "node:fs";
+import { URL } from "node:url";
+import terminalLink from "terminal-link";
+import upath2 from "upath";
+import { cyan, gray, green, red } from "yoctocolors";
+
+// src/output/pdf-postprocess.ts
+import decamelize from "decamelize";
+import fs from "node:fs";
+import os from "node:os";
+import upath from "upath";
+import { v1 as uuid } from "uuid";
+var prefixes = {
+  dcterms: "http://purl.org/dc/terms/",
+  meta: "http://idpf.org/epub/vocab/package/meta/#"
+};
+var metaTerms = {
+  title: `${prefixes.dcterms}title`,
+  creator: `${prefixes.dcterms}creator`,
+  description: `${prefixes.dcterms}description`,
+  subject: `${prefixes.dcterms}subject`,
+  contributor: `${prefixes.dcterms}contributor`,
+  language: `${prefixes.dcterms}language`,
+  role: `${prefixes.meta}role`,
+  created: `${prefixes.meta}created`,
+  date: `${prefixes.meta}date`
+};
+async function pressReadyWithContainer({
+  input,
+  output,
+  preflightOption,
+  image
+}) {
+  await runContainer({
+    image,
+    entrypoint: "press-ready",
+    userVolumeArgs: collectVolumeArgs([
+      upath.dirname(input),
+      upath.dirname(output)
+    ]),
+    commandArgs: [
+      "build",
+      "-i",
+      toContainerPath(input),
+      "-o",
+      toContainerPath(output),
+      ...preflightOption.map((opt) => `--${decamelize(opt, { separator: "-" })}`).filter((str) => /^[\w-]+/.test(str))
+    ]
+  });
+}
+var PostProcess = class _PostProcess {
+  constructor(document2) {
+    this.document = document2;
+  }
+  static async load(pdf) {
+    const { PDFDocument } = await importNodeModule("pdf-lib");
+    const document2 = await PDFDocument.load(pdf, { updateMetadata: false });
+    return new _PostProcess(document2);
+  }
+  async save(output, { preflight, preflightOption, image }) {
+    const input = preflight ? upath.join(os.tmpdir(), `vivliostyle-cli-${uuid()}.pdf`) : output;
+    const pdf = await this.document.save();
+    await fs.promises.writeFile(input, pdf);
+    if (preflight === "press-ready-local" || preflight === "press-ready" && isInContainer()) {
+      var _stack = [];
+      try {
+        const _3 = __using(_stack, Logger.suspendLogging("Running press-ready"));
+        const { build: build2 } = await importNodeModule("press-ready");
+        await build2({
+          ...preflightOption.reduce((acc, opt) => {
+            const optName = decamelize(opt, { separator: "-" });
+            return optName.startsWith("no-") ? {
+              ...acc,
+              [optName.slice(3)]: false
+            } : {
+              ...acc,
+              [optName]: true
+            };
+          }, {}),
+          input,
+          output
+        });
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    } else if (preflight === "press-ready") {
+      var _stack2 = [];
+      try {
+        const _3 = __using(_stack2, Logger.suspendLogging("Running press-ready"));
+        await pressReadyWithContainer({
+          input,
+          output,
+          preflightOption,
+          image
+        });
+      } catch (_2) {
+        var _error2 = _2, _hasError2 = true;
+      } finally {
+        __callDispose(_stack2, _error2, _hasError2);
+      }
+    }
+  }
+  async metadata(tree, {
+    pageProgression,
+    browserVersion,
+    viewerCoreVersion,
+    disableCreatorOption
+  } = {}) {
+    const { ReadingDirection } = await importNodeModule("pdf-lib");
+    const title = tree[metaTerms.title]?.[0].v;
+    if (title) {
+      this.document.setTitle(title);
+    }
+    const author = tree[metaTerms.creator]?.map((item) => item.v)?.join("; ");
+    if (author) {
+      this.document.setAuthor(author);
+    }
+    const subject = tree[metaTerms.description]?.[0].v;
+    if (subject) {
+      this.document.setSubject(subject);
+    }
+    const keywords = tree[metaTerms.subject]?.map((item) => item.v);
+    if (keywords) {
+      this.document.setKeywords(keywords);
+    }
+    let creatorOpt = `Vivliostyle.js ${viewerCoreVersion ?? coreVersion}`;
+    if (browserVersion) {
+      creatorOpt += `; ${browserVersion}`;
+    }
+    this.document.setCreator(
+      disableCreatorOption ? "Vivliostyle" : `Vivliostyle (${creatorOpt})`
+    );
+    const language = tree[metaTerms.language]?.[0].v;
+    if (language) {
+      this.document.setLanguage(language);
+    }
+    const creation = (tree[metaTerms.created] || tree[metaTerms.date])?.[0].v;
+    const creationDate = creation && new Date(creation);
+    if (creationDate) {
+      this.document.setCreationDate(creationDate);
+    }
+    if (pageProgression === "rtl") {
+      const viewerPrefs = this.document.catalog.getOrCreateViewerPreferences();
+      viewerPrefs.setReadingDirection(ReadingDirection.R2L);
+    }
+  }
+  async toc(items) {
+    const { PDFDict, PDFHexString, PDFName, PDFNumber } = await importNodeModule("pdf-lib");
+    if (!items || !items.length) {
+      return;
+    }
+    const addRefs = (items2, parentRef) => items2.map((item) => {
+      const ref = this.document.context.nextRef();
+      return {
+        ...item,
+        parentRef,
+        ref,
+        children: addRefs(item.children, ref)
+      };
+    });
+    const countAll = (items2) => items2.reduce((sum, item) => sum + countAll(item.children), items2.length);
+    const addObjectsToPDF = (items2) => {
+      for (const [i, item] of items2.entries()) {
+        const child = PDFDict.withContext(this.document.context);
+        child.set(PDFName.of("Title"), PDFHexString.fromText(item.title));
+        child.set(PDFName.of("Dest"), PDFName.of(item.id));
+        child.set(PDFName.of("Parent"), item.parentRef);
+        const prev = items2[i - 1];
+        if (prev) {
+          child.set(PDFName.of("Prev"), prev.ref);
+        }
+        const next = items2[i + 1];
+        if (next) {
+          child.set(PDFName.of("Next"), next.ref);
+        }
+        if (item.children.length) {
+          child.set(PDFName.of("First"), item.children[0].ref);
+          child.set(
+            PDFName.of("Last"),
+            item.children[item.children.length - 1].ref
+          );
+          child.set(PDFName.of("Count"), PDFNumber.of(countAll(item.children)));
+        }
+        this.document.context.assign(item.ref, child);
+        addObjectsToPDF(item.children);
+      }
+    };
+    const outlineRef = this.document.context.nextRef();
+    const itemsWithRefs = addRefs(items, outlineRef);
+    addObjectsToPDF(itemsWithRefs);
+    const outline = PDFDict.withContext(this.document.context);
+    outline.set(PDFName.of("First"), itemsWithRefs[0].ref);
+    outline.set(
+      PDFName.of("Last"),
+      itemsWithRefs[itemsWithRefs.length - 1].ref
+    );
+    outline.set(PDFName.of("Count"), PDFNumber.of(countAll(itemsWithRefs)));
+    this.document.context.assign(outlineRef, outline);
+    this.document.catalog.set(PDFName.of("Outlines"), outlineRef);
+  }
+  async setPageBoxes(pageSizeData) {
+    if (pageSizeData.length + 1 === this.document.getPageCount()) {
+      this.document.removePage(pageSizeData.length);
+    }
+    if (pageSizeData.length !== this.document.getPageCount()) {
+      return;
+    }
+    for (let i = 0; i < pageSizeData.length; i++) {
+      const page = this.document.getPage(i);
+      const sizeData = pageSizeData[i];
+      if (!sizeData.mediaWidth || !sizeData.mediaHeight || isNaN(sizeData.bleedOffset) || isNaN(sizeData.bleedSize)) {
+        continue;
+      }
+      const yOffset = page.getHeight() - sizeData.mediaHeight;
+      page.setMediaBox(0, yOffset, sizeData.mediaWidth, sizeData.mediaHeight);
+      if (!sizeData.bleedOffset && !sizeData.bleedSize) {
+        continue;
+      }
+      page.setBleedBox(
+        sizeData.bleedOffset,
+        yOffset + sizeData.bleedOffset,
+        sizeData.mediaWidth - sizeData.bleedOffset * 2,
+        sizeData.mediaHeight - sizeData.bleedOffset * 2
+      );
+      const trimOffset = sizeData.bleedOffset + sizeData.bleedSize;
+      page.setTrimBox(
+        trimOffset,
+        yOffset + trimOffset,
+        sizeData.mediaWidth - trimOffset * 2,
+        sizeData.mediaHeight - trimOffset * 2
+      );
+    }
+  }
+};
+
+// src/output/pdf.ts
+async function buildPDF({
+  target,
+  config
+}) {
+  Logger.logUpdate(`Launching PDF build environment`);
+  const viewerFullUrl = await getViewerFullUrl(config);
+  Logger.debug("viewerFullUrl", viewerFullUrl);
+  let lastEntry;
+  function stringifyEntry(entry) {
+    const formattedSourcePath = cyan(
+      entry.source.type === "file" ? upath2.relative(config.entryContextDir, entry.source.pathname) : entry.source.href
+    );
+    return `${terminalLink(
+      formattedSourcePath,
+      entry.source.type === "file" ? `file://${entry.source.pathname}` : entry.source.href,
+      {
+        fallback: () => formattedSourcePath
+      }
+    )} ${entry.title ? gray(entry.title) : ""}`;
+  }
+  function handleEntry(response) {
+    const entry = config.entries.find((entry2) => {
+      if (!("source" in entry2)) {
+        return false;
+      }
+      const url = new URL(response.url());
+      return url.protocol === "file:" ? pathEquals(entry2.target, url.pathname) : pathEquals(
+        upath2.relative(config.workspaceDir, entry2.target),
+        url.pathname.substring(1)
+      );
+    });
+    if (entry) {
+      if (!lastEntry) {
+        lastEntry = entry;
+        Logger.logUpdate(stringifyEntry(entry));
+        return;
+      }
+      Logger.logSuccess(stringifyEntry(lastEntry));
+      Logger.startLogging(stringifyEntry(entry));
+      lastEntry = entry;
+    }
+  }
+  const { browser, page } = await launchPreview({
+    mode: "build",
+    url: viewerFullUrl,
+    config,
+    onBrowserOpen: () => {
+      Logger.logUpdate("Building pages");
+    },
+    onPageOpen: async (page2) => {
+      page2.on("pageerror", (error) => {
+        Logger.logError(red(error.message));
+      });
+      page2.on("console", (msg) => {
+        switch (msg.type()) {
+          case "error":
+            if (/\/vivliostyle-viewer\.js$/.test(msg.location().url ?? "")) {
+              Logger.logError(msg.text());
+              throw msg.text();
+            }
+            return;
+          case "debug":
+            if (/time slice/.test(msg.text())) {
+              return;
+            }
+            break;
+        }
+        if (msg.type() === "error") {
+          Logger.logVerbose(red("console.error()"), msg.text());
+        } else {
+          Logger.logVerbose(gray(`console.${msg.type()}()`), msg.text());
+        }
+      });
+      page2.on("response", (response) => {
+        Logger.debug(
+          gray("viewer:response"),
+          green(response.status().toString()),
+          response.url()
+        );
+        handleEntry(response);
+        if (300 > response.status() && 200 <= response.status()) return;
+        if (response.url().startsWith("file://") && response.ok()) return;
+        Logger.logError(red(`${response.status()}`), response.url());
+      });
+      await page2.setDefaultTimeout(config.timeout);
+    }
+  });
+  const browserName = getFullBrowserName(config.browser.type);
+  const browserVersion = `${browserName}/${await browser.version()}`;
+  Logger.debug(green("success"), `browserVersion=${browserVersion}`);
+  let remainTime = config.timeout;
+  const startTime = Date.now();
+  await page.waitForLoadState("networkidle");
+  await page.waitForFunction(() => !!window.coreViewer);
+  await page.emulateMedia({ media: "print" });
+  await page.waitForFunction(
+    /* v8 ignore next */
+    () => window.coreViewer.readyState === "complete",
+    void 0,
+    { polling: 1e3 }
+  );
+  if (lastEntry) {
+    Logger.logSuccess(stringifyEntry(lastEntry));
+  }
+  const pageProgression = await page.evaluate(
+    () => (
+      /* v8 ignore next 5 */
+      document.querySelector("#vivliostyle-viewer-viewport")?.getAttribute("data-vivliostyle-page-progression") === "rtl" ? "rtl" : "ltr"
+    )
+  );
+  const viewerCoreVersion = await page.evaluate(
+    () => (
+      /* v8 ignore next 3 */
+      document.querySelector("#vivliostyle-menu_settings .version")?.textContent?.replace(/^.*?: (\d[-+.\w]+).*$/, "$1")
+    )
+  );
+  const metadata = await loadMetadata(page);
+  const toc = await loadTOC(page);
+  const pageSizeData = await loadPageSizeData(page);
+  remainTime -= Date.now() - startTime;
+  if (remainTime <= 0) {
+    throw new Error("Typesetting process timed out");
+  }
+  Logger.debug("Remaining timeout:", remainTime);
+  Logger.logUpdate("Building PDF");
+  const pdf = await page.pdf({
+    margin: {
+      top: 0,
+      bottom: 0,
+      right: 0,
+      left: 0
+    },
+    printBackground: true,
+    preferCSSPageSize: true,
+    tagged: true
+    // timeout: remainTime,
+  });
+  await browser.close();
+  Logger.logUpdate("Processing PDF");
+  fs2.mkdirSync(upath2.dirname(target.path), { recursive: true });
+  const post = await PostProcess.load(pdf);
+  await post.metadata(metadata, {
+    pageProgression,
+    browserVersion,
+    viewerCoreVersion,
+    // If custom viewer is set and its version info is not available,
+    // there is no guarantee that the default creator option is correct.
+    disableCreatorOption: !!config.viewer && !viewerCoreVersion
+  });
+  await post.toc(toc);
+  await post.setPageBoxes(pageSizeData);
+  await post.save(target.path, {
+    preflight: target.preflight,
+    preflightOption: target.preflightOption,
+    image: config.image
+  });
+  return target.path;
+}
+async function loadMetadata(page) {
+  return page.evaluate(() => window.coreViewer.getMetadata());
+}
+async function loadTOC(page) {
+  return page.evaluate(
+    () => new Promise((resolve) => {
+      function listener(payload) {
+        if (payload.a !== "toc") {
+          return;
+        }
+        window.coreViewer.removeListener("done", listener);
+        window.coreViewer.showTOC(false);
+        resolve(window.coreViewer.getTOC());
+      }
+      window.coreViewer.addListener("done", listener);
+      window.coreViewer.showTOC(true);
+    })
+  );
+}
+async function loadPageSizeData(page) {
+  return page.evaluate(() => {
+    const sizeData = [];
+    const pageContainers = document.querySelectorAll(
+      "#vivliostyle-viewer-viewport > div > div > div[data-vivliostyle-page-container]"
+    );
+    for (const pageContainer of pageContainers) {
+      const bleedBox = pageContainer.querySelector(
+        "div[data-vivliostyle-bleed-box]"
+      );
+      sizeData.push({
+        mediaWidth: parseFloat(pageContainer.style.width) * 0.75,
+        mediaHeight: parseFloat(pageContainer.style.height) * 0.75,
+        bleedOffset: parseFloat(bleedBox?.style.left) * 0.75,
+        bleedSize: parseFloat(bleedBox?.style.paddingLeft) * 0.75
+      });
+    }
+    return sizeData;
+  });
+}
+
+// src/core/build.ts
+async function build(inlineConfig) {
+  Logger.setLogLevel(inlineConfig.logLevel);
+  Logger.setCustomLogger(inlineConfig.logger);
+  Logger.debug("build > inlineConfig %O", inlineConfig);
+  let vivliostyleConfig = await loadVivliostyleConfig(inlineConfig) ?? setupConfigFromFlags(inlineConfig);
+  warnDeprecatedConfig(vivliostyleConfig);
+  vivliostyleConfig = mergeInlineConfig(vivliostyleConfig, {
+    ...inlineConfig,
+    quick: false
+  });
+  const { inlineOptions } = vivliostyleConfig;
+  Logger.debug("build > vivliostyleConfig %O", vivliostyleConfig);
+  for (let [i, task] of vivliostyleConfig.tasks.entries()) {
+    var _stack2 = [];
+    try {
+      const _3 = __using(_stack2, Logger.startLogging("Start building"));
+      const config = resolveTaskConfig(task, inlineOptions);
+      Logger.debug("build > config %O", config);
+      const viteConfig = await resolveViteConfig({
+        ...config,
+        mode: "build"
+      });
+      let server;
+      if (!isInContainer()) {
+        Logger.debug("build > viteConfig.configFile %s", viteConfig.configFile);
+        if (viteConfig.configFile) {
+          var _stack = [];
+          try {
+            const _4 = __using(_stack, Logger.suspendLogging("Building Vite project"));
+            await viteBuild({
+              configFile: viteConfig.configFile,
+              root: config.context
+            });
+          } catch (_) {
+            var _error = _, _hasError = true;
+          } finally {
+            __callDispose(_stack, _error, _hasError);
+          }
+        }
+        if (isWebPubConfig(config)) {
+          await cleanupWorkspace(config);
+          await prepareThemeDirectory(config);
+          await compile(config);
+          await copyAssets(config);
+        }
+        if (config.outputs.some((o) => o.format === "pdf")) {
+          server = await createViteServer({
+            config,
+            viteConfig,
+            inlineConfig,
+            mode: "build"
+          });
+        }
+      }
+      for (const target of config.outputs) {
+        let output = null;
+        const { format } = target;
+        if (format === "pdf") {
+          if (!isInContainer() && target.renderMode === "docker") {
+            output = await buildPDFWithContainer({
+              target,
+              config,
+              inlineConfig
+            });
+          } else {
+            output = await buildPDF({ target, config });
+          }
+        } else if (format === "webpub" || format === "epub") {
+          output = await buildWebPublication({ target, config });
+        }
+        if (output && !isInContainer()) {
+          const formattedOutput = cyan2(
+            upath3.relative(inlineConfig.cwd ?? cwd, output)
+          );
+          Logger.logSuccess(
+            `Finished building ${terminalLink2(
+              formattedOutput,
+              pathToFileURL(output).href,
+              {
+                fallback: () => formattedOutput
+              }
+            )}`
+          );
+        }
+      }
+      await server?.close();
+    } catch (_2) {
+      var _error2 = _2, _hasError2 = true;
+    } finally {
+      __callDispose(_stack2, _error2, _hasError2);
+    }
+  }
+  runExitHandlers();
+  if (!isInContainer()) {
+    const num = vivliostyleConfig.tasks.flatMap((t) => t.output ?? []).length;
+    const symbol = isUnicodeSupported ? `${num > 1 ? "\u{1F4DA}" : randomBookSymbol} ` : "";
+    Logger.log(`${symbol}Built successfully!`);
+  }
+}
+
+export {
+  build
+};

package/dist/chunk-WX6JHPSL.js

@@ -0,0 +1,16 @@
+// src/node-modules.ts
+var nodeExternalModules = [
+  "@napi-rs/canvas",
+  "command-exists",
+  "execa",
+  "press-ready",
+  "pdf-lib",
+  "playwright-core",
+  "playwright-core/lib/server"
+];
+var importNodeModule = (name) => import(name);
+
+export {
+  nodeExternalModules,
+  importNodeModule
+};

package/dist/cli.d.ts

@@ -1,3 +1 @@
 #!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -1,20 +1,19 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { cliVersion, coreVersion } from './const.js';
-const version = `cli: ${cliVersion}
+import {
+  cliVersion,
+  coreVersion
+} from "./chunk-EX7EA34F.js";
+import "./chunk-BIEQXUOY.js";
+
+// src/cli.ts
+import { Command } from "commander";
+var version = `cli: ${cliVersion}
 core: ${coreVersion}`;
-const program = new Command();
-program
-    .name('vivliostyle')
-    .version(version, '-v, --version')
-    .command('init', 'create vivliostyle config', {
-    executableFile: 'commands/init',
-})
-    .command('build', 'build and create PDF file', {
-    executableFile: 'commands/build',
-})
-    .command('preview', 'launch preview server', {
-    executableFile: 'commands/preview',
-})
-    .parse(process.argv);
-//# sourceMappingURL=cli.js.map
+var program = new Command();
+program.name("vivliostyle").version(version, "-v, --version").command("init", "create vivliostyle config", {
+  executableFile: "commands/init"
+}).command("build", "build and create PDF file", {
+  executableFile: "commands/build"
+}).command("preview", "launch preview server", {
+  executableFile: "commands/preview"
+}).parse(process.argv);

package/dist/commands/build.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=build.d.ts.map
+
+export {  }