@vivliostyle/cli 9.9.0 → 10.0.0

package/dist/{chunk-G3GROLBN.js → chunk-MQYXBSRJ.js}

@@ -1,33 +1,84 @@
 import {
   VivliostyleInlineConfig
-} from "./chunk-UYKCTF6F.js";
+} from "./chunk-IIKRNYAM.js";
 import {
-  EMPTY_DATA_URI
-} from "./chunk-4IIM6RSG.js";
+  DEFAULT_BROWSER_VERSIONS,
+  EMPTY_DATA_URI,
+  languages
+} from "./chunk-ZKEIYNLT.js";
+
+// src/commands/cli-flags.ts
+import "commander";
+import * as v from "valibot";
+function createParserProgram({
+  setupProgram,
+  parseArgs
+}) {
+  return (argv) => {
+    const program = setupProgram();
+    program.parse(argv);
+    let options = program.opts();
+    options = parseArgs?.(options, program.args ?? []) || options;
+    options = warnDeprecatedFlags(options);
+    return v.parse(VivliostyleInlineConfig, options);
+  };
+}
+function setupConfigFromFlags(flags) {
+  if (!flags.input) {
+    if (flags.enableViewerStartPage) {
+      return {
+        tasks: [{ entry: [] }],
+        inlineOptions: {
+          input: { format: "webbook", entry: EMPTY_DATA_URI }
+        }
+      };
+    } else {
+      throw new Error(
+        "No input is set. Please set an appropriate entry or a Vivliostyle config file."
+      );
+    }
+  }
+  return {
+    tasks: [{ entry: [] }],
+    inlineOptions: { ...flags }
+  };
+}
+function warnDeprecatedFlags(options) {
+  const modifiedOptions = { ...options };
+  return modifiedOptions;
+}
 
 // src/util.ts
 import { codeFrameColumns } from "@babel/code-frame";
 import {
   evaluate,
-  parse
+  parse as parse2
 } from "@humanwhocodes/momoa";
 import { Ajv } from "ajv";
 import formatsPlugin from "ajv-formats";
 import { XMLParser } from "fast-xml-parser";
+import lcid from "lcid";
 import StreamZip from "node-stream-zip";
+import childProcess from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import readline from "node:readline";
 import util from "node:util";
+import { osLocale } from "os-locale";
+import { titleCase } from "title-case";
 import tmp from "tmp";
 import upath from "upath";
 import { gray, red, redBright as redBright2 } from "yoctocolors";
 
 // src/logger.ts
 import debug from "debug";
+import { Console } from "node:console";
 import yoctoSpinner from "yocto-spinner";
 import { blueBright, greenBright, redBright, yellowBright } from "yoctocolors";
 var isUnicodeSupported = process.platform !== "win32" || Boolean(process.env.WT_SESSION);
 var randomBookSymbol = ["\u{1F4D5}", "\u{1F4D7}", "\u{1F4D8}", "\u{1F4D9}"][Math.floor(Math.random() * 4)];
+var spinnerFrames = isUnicodeSupported ? ["\u2581\u2581\u2571 ", "\u2581\u2551\u2581 ", "\u2572\u2581\u2581 ", "\u2581\u2581\u2581 ", "\u2581\u2581\u2581 ", "\u2581\u2581\u2581 "] : ["-   ", "\\   ", "|   ", "/   "];
+var spinnerInterval = 80;
 var infoSymbol = blueBright("INFO");
 var successSymbol = greenBright("SUCCESS");
 var warnSymbol = yellowBright("WARN");
@@ -41,13 +92,42 @@ var Logger = class _Logger {
   static #nonBlockingLogPrinted = false;
   static #customLogger;
   static #logPrefix;
+  static #stdin = process.stdin;
+  static #stdout = process.stdout;
+  static #stderr = process.stderr;
+  static #signal;
   static debug = debug("vs-cli");
+  static get #console() {
+    if (this.#customLogger) {
+      return {
+        ...this.#customLogger,
+        log: () => {
+        }
+      };
+    }
+    return new Console({
+      stdout: this.#stdout,
+      stderr: this.#stderr
+    });
+  }
   static get #spinner() {
     return this.#loggerInstance && this.#loggerInstance.#_spinner;
   }
+  static get stdin() {
+    return this.#stdin;
+  }
+  static get stdout() {
+    return this.#stdout;
+  }
+  static get stderr() {
+    return this.#stderr;
+  }
+  static get signal() {
+    return this.#signal;
+  }
   static get isInteractive() {
     return Boolean(
-      !this.#customLogger && process.stderr.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env) && !import.meta.env?.VITEST && !debug.enabled("vs-cli") && // Prevent stream output in docker container so that not to spawn process
+      !this.#customLogger && this.#stderr.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env) && !import.meta.env?.VITEST && !debug.enabled("vs-cli") && // Prevent stream output in docker container so that not to spawn process
       !isInContainer()
     );
   }
@@ -63,7 +143,7 @@ var Logger = class _Logger {
       this.#loggerInstance.#_spinner.text = text;
       return this.#loggerInstance;
     }
-    this.#loggerInstance = new _Logger();
+    this.#loggerInstance = new _Logger(this.#stderr);
     this.#loggerInstance.#start(text);
     return this.#loggerInstance;
   }
@@ -82,7 +162,7 @@ var Logger = class _Logger {
     return {
       [Symbol.dispose]() {
         if (_Logger.isInteractive) {
-          console.log("");
+          _Logger.#console.log("");
           _Logger.#spinner?.start(currentMsg);
           _Logger.#nonBlockingLogPrinted = true;
         }
@@ -93,7 +173,7 @@ var Logger = class _Logger {
     if (this.#logLevel < 1) {
       return;
     }
-    console.log(...messages);
+    _Logger.#console.log(...messages);
   }
   static logUpdate(...messages) {
     if (!this.#spinner || !this.isInteractive) {
@@ -114,7 +194,7 @@ var Logger = class _Logger {
       if (this.#logPrefix) {
         message = `${this.#logPrefix} ${message}`;
       }
-      this.#logLevel >= 3 ? this.debug(message) : (this.#customLogger || console)[logMethod](message);
+      this.#logLevel >= 3 ? this.debug(message) : this.#console[logMethod](message);
       return;
     }
     this.logUpdate(this.#spinner.text);
@@ -164,35 +244,54 @@ var Logger = class _Logger {
     }
     this.#nonBlockingLog("info", this.getMessage(messages.join(" ")));
   }
-  static setLogLevel(level) {
-    if (!level) {
-      return;
+  static setLogOptions({
+    logLevel,
+    logger,
+    stdin,
+    stdout,
+    stderr,
+    signal
+  }) {
+    if (logLevel) {
+      this.#logLevel = {
+        silent: 0,
+        info: 1,
+        verbose: 2,
+        debug: 3
+      }[logLevel];
+      if (this.#logLevel >= 3) {
+        debug.enable("vs-cli");
+      }
     }
-    this.#logLevel = {
-      silent: 0,
-      info: 1,
-      verbose: 2,
-      debug: 3
-    }[level];
-    if (this.#logLevel >= 3) {
-      debug.enable("vs-cli");
+    if (logger) {
+      this.#customLogger = logger;
+    }
+    if (stdin) {
+      this.#stdin = stdin;
+    }
+    if (stdout) {
+      this.#stdout = stdout;
+    }
+    if (stderr) {
+      this.#stderr = stderr;
+    }
+    if (signal) {
+      this.#signal = signal;
     }
-  }
-  static setCustomLogger(logger) {
-    this.#customLogger = logger;
   }
   static setLogPrefix(prefix) {
     this.#logPrefix = prefix;
   }
   #_spinner;
   #_disposeSpinnerExitHandler;
-  constructor() {
+  constructor(stream) {
     this.#_spinner = yoctoSpinner({
       spinner: {
-        frames: isUnicodeSupported ? ["\u2581\u2581\u2571 ", "\u2581\u2551\u2581 ", "\u2572\u2581\u2581 ", "\u2581\u2581\u2581 ", "\u2581\u2581\u2581 ", "\u2581\u2581\u2581 "] : ["-   ", "\\   ", "|   ", "/   "],
-        interval: 80
+        frames: spinnerFrames,
+        interval: spinnerInterval
       },
-      color: "gray"
+      color: "gray",
+      stream
     });
     return this;
   }
@@ -775,6 +874,15 @@ var publicationSchemas = [
 
 // src/util.ts
 var cwd = upath.normalize(process.cwd());
+var execFile = util.promisify(childProcess.execFile);
+async function exec(command, args = [], options = {}) {
+  const subprocess = await execFile(command, args, {
+    ...options,
+    encoding: "utf8"
+  });
+  subprocess.stdout = subprocess.stdout.trim();
+  return subprocess;
+}
 var beforeExitHandlers = [];
 var registerExitHandler = (debugMessage, handler) => {
   const callback = () => {
@@ -785,7 +893,7 @@ var registerExitHandler = (debugMessage, handler) => {
   return () => {
     const index = beforeExitHandlers.indexOf(callback);
     if (index !== -1) {
-      beforeExitHandlers.splice(index, 1);
+      return beforeExitHandlers.splice(index, 1)[0];
     }
   };
 };
@@ -821,6 +929,7 @@ if (process.platform === "win32") {
   });
 }
 var DetailError = class extends Error {
+  detail;
   constructor(message, detail) {
     super(message);
     this.detail = detail;
@@ -918,12 +1027,16 @@ function pathContains(parentPath, childPath) {
 function isValidUri(str) {
   return /^(https?|file|data):/i.test(str);
 }
-function isInContainer() {
-  return fs.existsSync("/opt/vivliostyle-cli/.vs-cli-version");
+function cachedFn(fn) {
+  let cache = null;
+  return () => cache ?? (cache = fn());
 }
-function isRunningOnWSL() {
+var isInContainer = cachedFn(function isInContainer2() {
+  return fs.existsSync("/opt/vivliostyle-cli/.vs-cli-version");
+});
+var isRunningOnWSL = cachedFn(function isRunningOnWSL2() {
   return fs.existsSync("/proc/version") && fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
-}
+});
 async function openEpub(epubPath, tmpDir) {
   await inflateZip(epubPath, tmpDir);
   Logger.debug(`Created the temporary EPUB directory: ${tmpDir}`);
@@ -981,7 +1094,7 @@ var assertPubManifestSchema = getAjvValidatorFunction(
   publicationSchemas
 );
 function parseJsonc(rawJsonc) {
-  const ast = parse(rawJsonc, {
+  const ast = parse2(rawJsonc, {
     mode: "jsonc",
     ranges: false,
     tokens: false
@@ -989,7 +1102,7 @@ function parseJsonc(rawJsonc) {
   return evaluate(ast);
 }
 function prettifySchemaError(rawJsonc, issues) {
-  const parsed = parse(rawJsonc, {
+  const parsed = parse2(rawJsonc, {
     mode: "jsonc",
     ranges: false,
     tokens: false
@@ -1041,6 +1154,48 @@ function writeFileIfChanged(filePath, content) {
     fs.writeFileSync(filePath, content);
   }
 }
+var cachedLocale;
+async function getOsLocale() {
+  if (import.meta.env?.VITEST) {
+    return process.env.TEST_LOCALE || "en";
+  }
+  if (cachedLocale) {
+    return cachedLocale;
+  }
+  let locale;
+  if (process.platform === "win32") {
+    const { stdout } = await exec("wmic", ["os", "get", "locale"]);
+    const lcidCode = Number.parseInt(stdout.replace("Locale", ""), 16);
+    locale = lcid.from(lcidCode);
+  }
+  if (process.platform === "darwin") {
+    const results = await Promise.all([
+      exec("defaults", ["read", "-globalDomain", "AppleLocale"]).then(
+        ({ stdout }) => stdout
+      ),
+      exec("locale", ["-a"]).then(({ stdout }) => stdout)
+    ]);
+    if (results[1].includes(results[0])) {
+      locale = results[0];
+    }
+  }
+  if (locale) {
+    locale = locale.replace(/_/, "-");
+  } else {
+    locale = await osLocale();
+  }
+  const langs = Object.keys(languages);
+  locale = langs.includes(locale) ? locale : langs.includes(locale.split("-")[0]) ? locale.split("-")[0] : "en";
+  return cachedLocale = locale.replace(/_/, "-");
+}
+function toTitleCase(input) {
+  if (typeof input !== "string") {
+    return input;
+  }
+  return titleCase(
+    input.replace(/[\W_]/g, " ").replace(/\s+/g, " ").trim()
+  );
+}
 function debounce(func, wait, options = {}) {
   const leading = options.leading ?? false;
   const trailing = options.trailing ?? !leading;
@@ -1070,71 +1225,217 @@ function debounce(func, wait, options = {}) {
     }
   };
 }
-
-// src/commands/cli-flags.ts
-import upath2 from "upath";
-import * as v from "valibot";
-function parseFlagsToInlineConfig(argv, setupProgram) {
-  const program = setupProgram();
-  program.parse(argv);
-  let options = program.opts();
-  const input = program.args?.[0];
-  options = warnDeprecatedFlags(options);
-  let inlineConfig = { input, ...options };
-  if (input && !options.config && upath2.basename(input).startsWith("vivliostyle.config")) {
-    inlineConfig = { config: input, ...options };
+var getCacheDir = cachedFn(function getCacheDir2() {
+  let osCacheDir;
+  if (process.platform === "linux") {
+    osCacheDir = process.env.XDG_CACHE_HOME || upath.join(os.homedir(), ".cache");
+  } else if (process.platform === "darwin") {
+    osCacheDir = upath.join(os.homedir(), "Library", "Caches");
+  } else if (process.platform === "win32") {
+    osCacheDir = process.env.LOCALAPPDATA || upath.join(os.homedir(), "AppData", "Local");
+  } else {
+    throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+  return upath.join(osCacheDir, "vivliostyle");
+});
+var detectBrowserPlatform = cachedFn(function detectBrowserPlatform2() {
+  const platform = process.platform;
+  const arch = process.arch;
+  switch (platform) {
+    case "darwin":
+      return arch === "arm64" ? "mac_arm" : "mac";
+    case "linux":
+      return arch === "arm64" ? "linux_arm" : "linux";
+    case "win32":
+      return arch === "x64" || // Windows 11 for ARM supports x64 emulation
+      arch === "arm64" && isWindows11(os.release()) ? "win64" : "win32";
+    default:
+      return void 0;
+  }
+});
+function isWindows11(version) {
+  const parts = version.split(".");
+  if (parts.length > 2) {
+    const major = parseInt(parts[0], 10);
+    const minor = parseInt(parts[1], 10);
+    const patch = parseInt(parts[2], 10);
+    return major > 10 || major === 10 && minor > 0 || major === 10 && minor === 0 && patch >= 22e3;
   }
-  return v.parse(VivliostyleInlineConfig, inlineConfig);
+  return false;
 }
-function setupConfigFromFlags(flags) {
-  if (!flags.input) {
-    if (flags.enableViewerStartPage) {
-      return {
-        tasks: [{ entry: [] }],
-        inlineOptions: {
-          input: { format: "webbook", entry: EMPTY_DATA_URI }
-        }
-      };
-    } else {
-      throw new Error(
-        "No input is set. Please set an appropriate entry or a Vivliostyle config file."
-      );
-    }
+var getDefaultBrowserTag = (browserType) => {
+  if (import.meta.env?.VITEST) {
+    return "100.0";
   }
-  return {
-    tasks: [{ entry: [] }],
-    inlineOptions: { ...flags }
-  };
+  const platform = detectBrowserPlatform();
+  return platform && DEFAULT_BROWSER_VERSIONS[browserType][platform];
+};
+function whichPm() {
+  if (!process.env.npm_config_user_agent) {
+    return "npm";
+  }
+  const pmSpec = process.env.npm_config_user_agent.split(" ")[0];
+  const separatorPos = pmSpec.lastIndexOf("/");
+  const name = pmSpec.substring(0, separatorPos);
+  return name;
 }
-function warnDeprecatedFlags(options) {
-  const modifiedOptions = { ...options };
-  if (options.executableChromium) {
-    Logger.logWarn(
-      "'--executable-chromium' option was deprecated and will be removed in a future release. Please replace with '--executable-browser' option."
+
+// src/processor/asset.ts
+import { copy } from "fs-extra/esm";
+import fs2 from "node:fs";
+import picomatch from "picomatch";
+import { glob } from "tinyglobby";
+import upath2 from "upath";
+var GlobMatcher = class {
+  matcherConfig;
+  #_matchers;
+  constructor(matcherConfig) {
+    this.matcherConfig = matcherConfig;
+    this.#_matchers = matcherConfig.map(
+      ({ patterns, ...options }) => picomatch(patterns, options)
     );
-    modifiedOptions.executableBrowser = options.executableChromium;
   }
-  if (options.verbose) {
-    Logger.logWarn(
-      "'--verbose' option was deprecated and will be removed in a future release. Please replace with '--log-level verbose' option."
-    );
-    modifiedOptions.logLevel = "verbose";
+  match(test) {
+    return this.#_matchers.some((matcher) => matcher(test));
   }
-  if (options.sandbox === false) {
-    Logger.logWarn(
-      "'--no-sandbox' option was deprecated and will be removed in a future release. It is no longer necessary because the sandbox is disabled by default."
+  async glob(globOptions = {}) {
+    return new Set(
+      (await Promise.all(
+        this.matcherConfig.map(
+          (config) => glob({ ...config, ...globOptions })
+        )
+      )).flat()
     );
   }
-  if (options.http) {
-    Logger.logWarn(
-      "'--http' option was deprecated and will be removed in a future release. It is unnecessary because the HTTP server starts automatically."
-    );
+};
+function getIgnoreThemeDirectoryPatterns({
+  themesDir,
+  cwd: cwd2
+}) {
+  return pathContains(cwd2, themesDir) ? [
+    `${upath2.relative(cwd2, themesDir)}/node_modules/*/example`,
+    `${upath2.relative(cwd2, themesDir)}/node_modules/*/*/example`
+  ] : [];
+}
+function getIgnoreAssetPatterns({
+  outputs,
+  entries,
+  cwd: cwd2
+}) {
+  return [
+    ...outputs.flatMap(
+      ({ format, path: p }) => !pathContains(cwd2, p) ? [] : format === "webpub" ? upath2.join(upath2.relative(cwd2, p), "**") : upath2.relative(cwd2, p)
+    ),
+    ...entries.flatMap(({ template }) => {
+      return template?.type === "file" && pathContains(cwd2, template.pathname) ? upath2.relative(cwd2, template.pathname) : [];
+    })
+  ];
+}
+function getWebPubResourceMatcher({
+  outputs,
+  themesDir,
+  entries,
+  cwd: cwd2,
+  manifestPath,
+  copyAsset: { fileExtensions }
+}) {
+  return new GlobMatcher([
+    {
+      patterns: [
+        `**/${upath2.relative(cwd2, manifestPath)}`,
+        "**/*.{html,htm,xhtml,xht}",
+        `**/*.{${fileExtensions.join(",")}}`
+      ],
+      ignore: [
+        ...getIgnoreAssetPatterns({
+          cwd: cwd2,
+          outputs,
+          entries
+        }),
+        ...getIgnoreThemeDirectoryPatterns({
+          cwd: cwd2,
+          themesDir
+        }),
+        // Ignore node_modules in the root directory
+        "node_modules/**",
+        // only include dotfiles starting with `.vs-`
+        "**/.!(vs-*)/**"
+      ],
+      dot: true,
+      cwd: cwd2
+    }
+  ]);
+}
+function getAssetMatcher({
+  copyAsset: { fileExtensions, includes, excludes },
+  outputs,
+  themesDir,
+  entries,
+  cwd: cwd2,
+  ignore = []
+}) {
+  const ignorePatterns = [
+    ...ignore,
+    ...excludes,
+    ...getIgnoreAssetPatterns({ outputs, entries, cwd: cwd2 })
+  ];
+  return new GlobMatcher([
+    // Step 1: Glob files with an extension in `fileExtension`
+    // Ignore files in node_modules directory, theme example files and files matched `excludes`
+    {
+      patterns: fileExtensions.map((ext) => `**/*.${ext}`),
+      ignore: [
+        "**/node_modules/**",
+        ...ignorePatterns,
+        ...getIgnoreThemeDirectoryPatterns({ themesDir, cwd: cwd2 })
+      ],
+      cwd: cwd2
+    },
+    // Step 2: Glob files matched with `includes`
+    // Ignore only files matched `excludes`
+    {
+      patterns: includes,
+      ignore: ignorePatterns,
+      cwd: cwd2
+    }
+  ]);
+}
+async function copyAssets({
+  entryContextDir,
+  workspaceDir,
+  copyAsset,
+  outputs,
+  themesDir,
+  entries
+}) {
+  if (pathEquals(entryContextDir, workspaceDir)) {
+    return;
+  }
+  const relWorkspaceDir = upath2.relative(entryContextDir, workspaceDir);
+  const assets = await getAssetMatcher({
+    copyAsset,
+    cwd: entryContextDir,
+    outputs,
+    themesDir,
+    entries,
+    ignore: [
+      // don't copy workspace itself
+      ...relWorkspaceDir ? [upath2.join(relWorkspaceDir, "**")] : []
+    ]
+  }).glob({ followSymbolicLinks: true });
+  Logger.debug("assets", assets);
+  for (const asset of assets) {
+    const target = upath2.join(workspaceDir, asset);
+    fs2.mkdirSync(upath2.dirname(target), { recursive: true });
+    await copy(upath2.resolve(entryContextDir, asset), target);
   }
-  return modifiedOptions;
 }
 
 export {
+  createParserProgram,
+  setupConfigFromFlags,
   cwd,
+  exec,
   registerExitHandler,
   runExitHandlers,
   DetailError,
@@ -1156,11 +1457,19 @@ export {
   parseJsonc,
   prettifySchemaError,
   writeFileIfChanged,
+  getOsLocale,
+  toTitleCase,
   debounce,
+  getCacheDir,
+  detectBrowserPlatform,
+  getDefaultBrowserTag,
+  whichPm,
   isUnicodeSupported,
   randomBookSymbol,
   Logger,
-  parseFlagsToInlineConfig,
-  setupConfigFromFlags
+  GlobMatcher,
+  getWebPubResourceMatcher,
+  getAssetMatcher,
+  copyAssets
 };
-//# sourceMappingURL=chunk-G3GROLBN.js.map
+//# sourceMappingURL=chunk-MQYXBSRJ.js.map