@vivliostyle/cli 10.2.0 → 10.3.0

package/dist/{chunk-BR2V7MHE.js → chunk-YNX6D2I6.js}

@@ -1,6 +1,6 @@
 import {
   importNodeModule
-} from "./chunk-E6QVHS6D.js";
+} from "./chunk-ECEGM36O.js";
 import {
   DetailError,
   GlobMatcher,
@@ -33,10 +33,10 @@ import {
   touchTmpFile,
   useTmpDirectory,
   writeFileIfChanged
-} from "./chunk-T2VWLU2I.js";
+} from "./chunk-RILZCPJE.js";
 import {
   VivliostyleConfigSchema
-} from "./chunk-CKXFRCPH.js";
+} from "./chunk-3QOSSWIX.js";
 import {
   CONTAINER_LOCAL_HOSTNAME,
   CONTAINER_URL,
@@ -77,7 +77,7 @@ function locateVivliostyleConfig({
   if (config) {
     return upath.resolve(cwd2, config);
   }
-  return [".js", ".mjs", ".cjs", ".json"].map((ext) => upath.join(cwd2, `vivliostyle.config${ext}`)).find((p) => fs.existsSync(p));
+  return [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts", ".json"].map((ext) => upath.join(cwd2, `vivliostyle.config${ext}`)).find((p) => fs.existsSync(p));
 }
 async function loadVivliostyleConfig({
   config,
@@ -149,6 +149,25 @@ function warnDeprecatedConfig(config) {
       "'http' property of Vivliostyle config was deprecated and will be removed in a future release. This option is enabled by default, and the file protocol is no longer supported."
     );
   }
+  if (config.tasks.some((task) => task.pressReady !== void 0)) {
+    Logger.logWarn(
+      `'pressReady' property of Vivliostyle config was deprecated and will be removed in a future release. Please use 'pdfPostprocess.preflight: "press-ready"' property instead.`
+    );
+  }
+  if (config.tasks.some(
+    (task) => task.output && [task.output].flat().some((o) => o.preflight)
+  )) {
+    Logger.logWarn(
+      "'preflight' property of output config was deprecated and will be removed in a future release. Please use 'pdfPostprocess.preflight' property instead."
+    );
+  }
+  if (config.tasks.some(
+    (task) => task.output && [task.output].flat().some((o) => o.preflightOption)
+  )) {
+    Logger.logWarn(
+      "'preflightOption' property of output config was deprecated and will be removed in a future release. Please use 'pdfPostprocess.preflightOption' property instead."
+    );
+  }
 }
 
 // src/config/merge.ts
@@ -249,6 +268,7 @@ import { lookup as mime } from "mime-types";
 import fs3 from "node:fs";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
 import npa from "npm-package-arg";
+import { globSync } from "tinyglobby";
 import upath2 from "upath";
 
 // src/processor/markdown.ts
@@ -493,24 +513,105 @@ function resolveTaskConfig(config, options) {
   const customStyle = options.style && parseCustomStyle({ customStyle: options.style, entryContextDir }) || void 0;
   const customUserStyle = options.userStyle && parseCustomStyle({ customStyle: options.userStyle, entryContextDir }) || void 0;
   const outputs = (() => {
+    const resolveCmykConfig = (cmykOption) => {
+      if (cmykOption && typeof cmykOption === "object") {
+        return {
+          warnUnmapped: cmykOption.warnUnmapped ?? true,
+          overrideMap: cmykOption.overrideMap ?? [],
+          mapOutput: cmykOption.mapOutput ? upath2.resolve(context, cmykOption.mapOutput) : void 0
+        };
+      }
+      if (options.cmyk || cmykOption === true) {
+        return { warnUnmapped: true, overrideMap: [], mapOutput: void 0 };
+      }
+      return false;
+    };
+    const resolveReplaceImageConfig = (replaceImageOption) => {
+      if (!replaceImageOption) {
+        return [];
+      }
+      const allFiles = globSync("**/*", {
+        cwd: entryContextDir,
+        onlyFiles: true
+      });
+      return replaceImageOption.flatMap(({ source, replacement }) => {
+        if (source instanceof RegExp) {
+          return allFiles.filter((file) => source.test(file)).map((file) => ({
+            source: upath2.resolve(entryContextDir, file),
+            replacement: upath2.resolve(
+              entryContextDir,
+              file.replace(source, replacement)
+            )
+          }));
+        }
+        return {
+          source: upath2.resolve(entryContextDir, source),
+          replacement: upath2.resolve(entryContextDir, replacement)
+        };
+      });
+    };
+    const resolveDefaultPreflight = () => {
+      if (options.preflight) {
+        return options.preflight;
+      }
+      const pp = config.pdfPostprocess;
+      if (pp && "preflight" in pp) {
+        return pp.preflight;
+      }
+      if (config.pressReady) {
+        return "press-ready";
+      }
+      return void 0;
+    };
+    const resolveDefaultPreflightOption = () => {
+      if (options.preflightOption) {
+        return options.preflightOption;
+      }
+      return config.pdfPostprocess?.preflightOption ?? [];
+    };
     const defaultPdfOptions = {
       format: "pdf",
       renderMode: options.renderMode ?? "local",
-      preflight: options.preflight ?? (config.pressReady ? "press-ready" : void 0),
-      preflightOption: options.preflightOption ?? []
+      preflight: resolveDefaultPreflight(),
+      preflightOption: resolveDefaultPreflightOption(),
+      cmyk: resolveCmykConfig(config.pdfPostprocess?.cmyk),
+      replaceImage: resolveReplaceImageConfig(
+        config.pdfPostprocess?.replaceImage
+      )
     };
     if (config.output) {
       return config.output.map((target) => {
         const outputPath = upath2.resolve(context, target.path);
         const format = target.format;
         switch (format) {
-          case "pdf":
+          case "pdf": {
+            const targetPp = target.pdfPostprocess;
+            const { pdfPostprocess: _, ...targetRest } = target;
+            const resolvedPreflight = (() => {
+              if (options.preflight) return options.preflight;
+              if (targetPp?.preflight) return targetPp.preflight;
+              if (target.preflight) return target.preflight;
+              return defaultPdfOptions.preflight;
+            })();
+            const resolvedPreflightOption = (() => {
+              if (options.preflightOption) return options.preflightOption;
+              if (targetPp?.preflightOption) return targetPp.preflightOption;
+              if (target.preflightOption) return target.preflightOption;
+              return defaultPdfOptions.preflightOption;
+            })();
+            const resolvedCmyk = targetPp?.cmyk !== void 0 ? resolveCmykConfig(targetPp.cmyk) : defaultPdfOptions.cmyk;
+            const resolvedReplaceImage = targetPp?.replaceImage !== void 0 ? resolveReplaceImageConfig(targetPp.replaceImage) : defaultPdfOptions.replaceImage;
             return {
               ...defaultPdfOptions,
-              ...target,
+              ...targetRest,
               format,
-              path: outputPath
+              path: outputPath,
+              preflight: resolvedPreflight,
+              preflightOption: resolvedPreflightOption,
+              cmyk: resolvedCmyk,
+              replaceImage: resolvedReplaceImage
             };
+          }
           case "epub":
             return {
               ...target,
@@ -1128,7 +1229,8 @@ async function launchBrowser({
   headless,
   noSandbox,
   disableDevShmUsage,
-  ignoreHttpsErrors
+  ignoreHttpsErrors,
+  protocolTimeout
 }) {
   const puppeteer = await importNodeModule("puppeteer-core");
   const args = [];
@@ -1197,7 +1299,8 @@ async function launchBrowser({
     browser: browserType === "chromium" ? "chrome" : browserType,
     headless,
     acceptInsecureCerts: ignoreHttpsErrors,
-    waitForInitialPage: false
+    waitForInitialPage: false,
+    protocolTimeout
   };
   Logger.debug("launchOptions %O", launchOptions);
   const browser = await puppeteer.launch({
@@ -1321,7 +1424,13 @@ async function launchPreview({
   url,
   onBrowserOpen,
   onPageOpen,
-  config: { browser: browserConfig, proxy, sandbox, ignoreHttpsErrors }
+  config: {
+    browser: browserConfig,
+    proxy,
+    sandbox,
+    ignoreHttpsErrors,
+    timeout
+  }
 }) {
   let executableBrowser = browserConfig.executablePath;
   Logger.debug(`Specified browser path: ${executableBrowser}`);
@@ -1351,7 +1460,8 @@ async function launchPreview({
     headless: mode === "build",
     noSandbox: !sandbox,
     disableDevShmUsage: isInContainer(),
-    ignoreHttpsErrors
+    ignoreHttpsErrors,
+    protocolTimeout: timeout
   });
   await onBrowserOpen?.(browser);
   const page = (await browserContext.pages())[0] ?? await browserContext.newPage();
@@ -1378,7 +1488,7 @@ async function launchPreview({
 // src/server.ts
 import fs10 from "node:fs";
 import { URL as URL2 } from "node:url";
-import upath11 from "upath";
+import upath12 from "upath";
 import {
   createServer,
   preview
@@ -1388,14 +1498,14 @@ import {
 import escapeRe from "escape-string-regexp";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 import sirv from "sirv";
-import upath8 from "upath";
+import upath9 from "upath";
 import "vite";
 
 // src/processor/compile.ts
 import "@vivliostyle/jsdom";
 import { copy as copy3, move } from "fs-extra/esm";
 import fs8 from "node:fs";
-import upath7 from "upath";
+import upath8 from "upath";
 import serializeToXml2 from "w3c-xmlserializer";
 import MIMEType2 from "whatwg-mimetype";
 
@@ -2991,10 +3101,37 @@ async function buildWebPublication({
 // src/processor/theme.ts
 import Arborist from "@npmcli/arborist";
 import fs7 from "node:fs";
+import upath7 from "upath";
+function* iterateSymlinksInThemesNodeModules(themesDir) {
+  if (!fs7.existsSync(themesDir)) {
+    return;
+  }
+  const nodeModulesDir = upath7.join(themesDir, "node_modules");
+  if (!fs7.existsSync(nodeModulesDir)) {
+    return;
+  }
+  for (const entry of fs7.readdirSync(nodeModulesDir, { withFileTypes: true })) {
+    if (!entry.isSymbolicLink()) {
+      continue;
+    }
+    const linkPath = upath7.join(nodeModulesDir, entry.name);
+    const target = fs7.readlinkSync(linkPath);
+    yield upath7.resolve(nodeModulesDir, target);
+  }
+}
+function removeThemesDirIfBrokenSymlinks(themesDir) {
+  for (const target of iterateSymlinksInThemesNodeModules(themesDir)) {
+    if (!fs7.existsSync(target)) {
+      fs7.rmSync(themesDir, { recursive: true });
+      return;
+    }
+  }
+}
 async function checkThemeInstallationNecessity({
   themesDir,
   themeIndexes
 }) {
+  removeThemesDirIfBrokenSymlinks(themesDir);
   if (!fs7.existsSync(themesDir)) {
     return [...themeIndexes].some((theme) => theme.type === "package");
   }
@@ -3010,11 +3147,17 @@ async function checkThemeInstallationNecessity({
     (theme) => theme.type === "package" && !pkgs.includes(theme.name)
   );
 }
+function getLocalThemePaths({
+  themesDir
+}) {
+  return [...iterateSymlinksInThemesNodeModules(themesDir)];
+}
 async function installThemeDependencies({
   themesDir,
   themeIndexes
 }) {
   fs7.mkdirSync(themesDir, { recursive: true });
+  removeThemesDirIfBrokenSymlinks(themesDir);
   try {
     const commonOpt = {
       path: themesDir,
@@ -3033,8 +3176,17 @@ async function installThemeDependencies({
     const rm = existing.filter((v2) => !add.includes(v2));
     const opt = { ...commonOpt, rm, add };
     const arb = new Arborist(opt);
-    await arb.reify(opt);
-    return;
+    const actualTree = await arb.reify(opt);
+    for (const child of actualTree.children.values()) {
+      if (child.resolved?.startsWith("file:")) {
+        const sourcePath = upath7.resolve(themesDir, child.resolved.slice(5));
+        if (fs7.existsSync(child.path)) {
+          fs7.rmSync(child.path, { recursive: true });
+        }
+        const relPath = upath7.relative(upath7.dirname(child.path), sourcePath);
+        fs7.symlinkSync(relPath, child.path, "junction");
+      }
+    }
   } catch (error) {
     const thrownError = error;
     throw new DetailError(
@@ -3050,20 +3202,20 @@ function locateThemePath(theme, from) {
     return theme.location;
   }
   if (theme.type === "file") {
-    return upath7.relative(from, theme.location);
+    return upath8.relative(from, theme.location);
   }
   if (theme.importPath) {
     return [theme.importPath].flat().map((locator) => {
-      const resolvedPath = upath7.resolve(theme.location, locator);
+      const resolvedPath = upath8.resolve(theme.location, locator);
       if (!pathContains(theme.location, resolvedPath) || !fs8.existsSync(resolvedPath)) {
         throw new Error(
           `Could not find a style path ${theme.importPath} for the theme: ${theme.name}.`
         );
       }
-      return upath7.relative(from, resolvedPath);
+      return upath8.relative(from, resolvedPath);
     });
   } else {
-    const pkgJsonPath = upath7.join(theme.location, "package.json");
+    const pkgJsonPath = upath8.join(theme.location, "package.json");
     const packageJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf8"));
     const maybeStyle = packageJson?.vivliostyle?.theme?.style ?? packageJson.style ?? packageJson.main;
     if (!maybeStyle) {
@@ -3072,7 +3224,7 @@ function locateThemePath(theme, from) {
         "Please ensure this package satisfies a `vivliostyle.theme.style` property."
       );
     }
-    return upath7.relative(from, upath7.join(theme.location, maybeStyle));
+    return upath8.relative(from, upath8.join(theme.location, maybeStyle));
   }
 }
 async function cleanupWorkspace({
@@ -3089,15 +3241,15 @@ async function cleanupWorkspace({
   Logger.debug("cleanup workspace files", workspaceDir);
   let movedWorkspacePath;
   if (pathContains(workspaceDir, themesDir) && fs8.existsSync(themesDir)) {
-    movedWorkspacePath = upath7.join(
-      upath7.dirname(workspaceDir),
+    movedWorkspacePath = upath8.join(
+      upath8.dirname(workspaceDir),
       `.vs-${Date.now()}`
     );
-    const movedThemePath = upath7.join(
+    const movedThemePath = upath8.join(
       movedWorkspacePath,
-      upath7.relative(workspaceDir, themesDir)
+      upath8.relative(workspaceDir, themesDir)
     );
-    fs8.mkdirSync(upath7.dirname(movedThemePath), { recursive: true });
+    fs8.mkdirSync(upath8.dirname(movedThemePath), { recursive: true });
     registerExitHandler(
       `Removing the moved workspace directory: ${movedWorkspacePath}`,
       () => {
@@ -3117,10 +3269,10 @@ async function prepareThemeDirectory({
   themesDir,
   themeIndexes
 }) {
-  if (fs8.existsSync(upath7.join(themesDir, "packages")) && !fs8.existsSync(upath7.join(themesDir, "node_modules"))) {
+  if (fs8.existsSync(upath8.join(themesDir, "packages")) && !fs8.existsSync(upath8.join(themesDir, "node_modules"))) {
     fs8.renameSync(
-      upath7.join(themesDir, "packages"),
-      upath7.join(themesDir, "node_modules")
+      upath8.join(themesDir, "packages"),
+      upath8.join(themesDir, "node_modules")
     );
   }
   if (await checkThemeInstallationNecessity({ themesDir, themeIndexes })) {
@@ -3129,10 +3281,11 @@ async function prepareThemeDirectory({
   }
   for (const theme of themeIndexes) {
     if (theme.type === "file" && !pathEquals(theme.source, theme.location)) {
-      fs8.mkdirSync(upath7.dirname(theme.location), { recursive: true });
+      fs8.mkdirSync(upath8.dirname(theme.location), { recursive: true });
       await copy3(theme.source, theme.location);
     }
   }
+  return getLocalThemePaths({ themesDir });
 }
 async function transformManuscript(entry, {
   entryContextDir,
@@ -3149,7 +3302,7 @@ async function transformManuscript(entry, {
   let resourceLoader;
   let resourceUrl;
   const style = entry.themes.flatMap(
-    (theme) => locateThemePath(theme, upath7.dirname(entry.target))
+    (theme) => locateThemePath(theme, upath8.dirname(entry.target))
   );
   if (source?.type === "file") {
     if (source.documentProcessor) {
@@ -3245,7 +3398,7 @@ async function transformManuscript(entry, {
     content = await processTocHtml(content, {
       entries: manuscriptEntries,
       manifestPath,
-      distDir: upath7.dirname(contentsEntry.target),
+      distDir: upath8.dirname(contentsEntry.target),
       tocTitle: contentsEntry.tocTitle,
       sectionDepth: contentsEntry.sectionDepth,
       styleOptions: contentsEntry,
@@ -3255,10 +3408,10 @@ async function transformManuscript(entry, {
   if (entry.rel === "cover") {
     const coverEntry = entry;
     content = await processCoverHtml(content, {
-      imageSrc: upath7.relative(
-        upath7.join(
+      imageSrc: upath8.relative(
+        upath8.join(
           entryContextDir,
-          upath7.relative(workspaceDir, coverEntry.target),
+          upath8.relative(workspaceDir, coverEntry.target),
           ".."
         ),
         coverEntry.coverImageSrc
@@ -3308,7 +3461,7 @@ async function generateManifest({
 }) {
   const manifestEntries = entries.map((entry) => ({
     title: entry.rel === "contents" && entry.tocTitle || entry.title,
-    path: upath7.relative(workspaceDir, entry.target),
+    path: upath8.relative(workspaceDir, entry.target),
     encodingFormat: !("contentType" in entry) || entry.contentType === "text/markdown" || entry.contentType === "text/x-vivliostyle-custom" || entry.contentType === "text/html" ? void 0 : entry.contentType,
     rel: entry.rel
   }));
@@ -3318,7 +3471,7 @@ async function generateManifest({
     language,
     readingProgression,
     cover: cover && {
-      url: upath7.relative(entryContextDir, cover.src),
+      url: upath8.relative(entryContextDir, cover.src),
       name: cover.name
     },
     entries: manifestEntries,
@@ -3374,7 +3527,7 @@ function createEntriesRouteLookup(entries, cwd2) {
     return arr;
   };
   const cache = entries.reduce((acc, e) => {
-    acc[`/${upath8.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
+    acc[`/${upath9.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
     return acc;
   }, {});
   return (uri) => {
@@ -3407,8 +3560,8 @@ function getWorkspaceMatcher({
   switch (viewerInput.type) {
     case "epub":
       entryFiles = [
-        upath8.join(
-          upath8.relative(workspaceDir, viewerInput.epubTmpOutputDir),
+        upath9.join(
+          upath9.relative(workspaceDir, viewerInput.epubTmpOutputDir),
           "**"
         )
       ];
@@ -3447,7 +3600,7 @@ function vsDevServerPlugin({
     if (isWebPubConfig(config) && config.viewerInput.needToGenerateManifest && needToUpdateManifest) {
       await generateManifest(config);
     }
-    await prepareThemeDirectory(config);
+    const localThemePaths = await prepareThemeDirectory(config);
     const entriesLookup = createEntriesRouteLookup(
       config.entries,
       config.workspaceDir
@@ -3514,7 +3667,8 @@ function vsDevServerPlugin({
       prevThemeFiles.filter((target) => !themeFiles.includes(target))
     );
     server?.watcher.add(themeFiles);
-    projectDeps.push(...themeFiles);
+    server?.watcher.add(localThemePaths);
+    projectDeps.push(...themeFiles, ...localThemePaths);
     matchProjectDep = (pathname) => projectDeps.some(
       (dep) => pathEquals(dep, pathname) || pathContains(dep, pathname)
     );
@@ -3713,7 +3867,7 @@ function vsDevServerPlugin({
 
 // src/vite/vite-plugin-static-serve.ts
 import sirv2 from "sirv";
-import upath9 from "upath";
+import upath10 from "upath";
 import "vite";
 function vsStaticServePlugin({
   config: _config,
@@ -3728,7 +3882,7 @@ function vsStaticServePlugin({
       ([base, dirs]) => dirs.map(
         (dir) => [
           base,
-          sirv2(upath9.resolve(config.serverRootDir, dir), {
+          sirv2(upath10.resolve(config.serverRootDir, dir), {
             dev: true,
             etag: false
           })
@@ -3759,7 +3913,7 @@ function vsStaticServePlugin({
 // src/vite/vite-plugin-viewer.ts
 import fs9 from "node:fs";
 import sirv3 from "sirv";
-import upath10 from "upath";
+import upath11 from "upath";
 import "vite";
 var viewerClientId = "@vivliostyle:viewer:client";
 var viewerClientRequestPath = `/${viewerClientId}`;
@@ -3773,13 +3927,13 @@ if (import.meta.hot) {
 }`
 );
 function vsViewerPlugin(_) {
-  const serveRootDir = upath10.join(viewerRoot, "lib");
+  const serveRootDir = upath11.join(viewerRoot, "lib");
   const serve = sirv3(serveRootDir, { dev: false, etag: true });
   let cachedIndexHtml;
   const middleware = async function vivliostyleViewerMiddleware(req, res, next) {
     if (req.url === "/" || req.url === "/index.html") {
       cachedIndexHtml ??= prependToHead(
-        fs9.readFileSync(upath10.join(serveRootDir, "index.html"), "utf-8"),
+        fs9.readFileSync(upath11.join(serveRootDir, "index.html"), "utf-8"),
         `<script type="module" src="${viewerClientRequestPath}"></script>`
       );
       res.statusCode = 200;
@@ -3834,11 +3988,11 @@ function getViewerParams(src, {
   let viewerParams = src ? `src=${escapeParam(src)}` : "";
   viewerParams += `&bookMode=${!singleDoc}&renderAllPages=${!quick}`;
   if (customStyle) {
-    const param = isValidUri(customStyle) ? customStyle : upath11.posix.join(base, customStyle);
+    const param = isValidUri(customStyle) ? customStyle : upath12.posix.join(base, customStyle);
     viewerParams += `&style=${escapeParam(param)}`;
   }
   if (customUserStyle) {
-    const param = isValidUri(customUserStyle) ? customUserStyle : upath11.posix.join(base, customUserStyle);
+    const param = isValidUri(customUserStyle) ? customUserStyle : upath12.posix.join(base, customUserStyle);
     viewerParams += `&userStyle=${escapeParam(param)}`;
   }
   if (pageSizeValue || cropMarks || bleed || cropOffset || css) {
@@ -3893,7 +4047,7 @@ async function getSourceUrl({
       input = viewerInput;
   }
   return (isValidUri(input) ? new URL2(input) : new URL2(
-    upath11.posix.join(base, upath11.relative(workspaceDir, input)),
+    upath12.posix.join(base, upath12.relative(workspaceDir, input)),
     rootUrl
   )).href;
 }
@@ -4036,4 +4190,4 @@ export {
   getViewerFullUrl,
   createViteServer
 };
-//# sourceMappingURL=chunk-BR2V7MHE.js.map
+//# sourceMappingURL=chunk-YNX6D2I6.js.map