@slidev/cli 0.48.0-beta.2 → 0.48.0-beta.20

package/dist/{build-BVDM4ZAC.mjs → build-5AFXNUEB.mjs}

@@ -2,19 +2,17 @@ import {
   ViteSlidevPlugin,
   getIndexHtml,
   mergeViteConfigs
-} from "./chunk-FIXL4WBO.mjs";
-import "./chunk-CTBVOVLQ.mjs";
-import "./chunk-DWXI5WEO.mjs";
-import "./chunk-BXO7ZPPU.mjs";
+} from "./chunk-O56CS6WQ.mjs";
+import "./chunk-O6TYYGU6.mjs";
+import "./chunk-CV7OWJOF.mjs";
 
 // node/build.ts
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 import http from "node:http";
 import fs from "fs-extra";
 import { mergeConfig, build as viteBuild } from "vite";
 import connect from "connect";
 import sirv from "sirv";
-import { blue, yellow } from "kolorist";
 async function build(options, viteConfig = {}, args) {
   const indexPath = resolve(options.userRoot, "index.html");
   let originalIndexHTML;
@@ -51,40 +49,6 @@ async function build(options, viteConfig = {}, args) {
       }
     );
     await viteBuild(inlineConfig);
-    if (options.data.features.monaco) {
-      if (options.data.config.monaco === "dev") {
-        console.log(yellow("  Monaco is disabled in the build, to enabled it, set `monaco: true` in the frontmatter"));
-      } else {
-        console.log(blue("  building for Monaco...\n"));
-        await viteBuild(
-          await mergeViteConfigs(
-            options,
-            inlineConfig,
-            {
-              root: join(options.clientRoot, "iframes/monaco"),
-              base: `${config.base}iframes/monaco/`,
-              build: {
-                outDir: resolve(config.build.outDir, "iframes/monaco"),
-                // fix for monaco workers
-                // https://github.com/vitejs/vite/issues/1927#issuecomment-805803918
-                rollupOptions: {
-                  output: {
-                    manualChunks: {
-                      jsonWorker: ["monaco-editor/esm/vs/language/json/json.worker"],
-                      cssWorker: ["monaco-editor/esm/vs/language/css/css.worker"],
-                      htmlWorker: ["monaco-editor/esm/vs/language/html/html.worker"],
-                      tsWorker: ["monaco-editor/esm/vs/language/typescript/ts.worker"],
-                      editorWorker: ["monaco-editor/esm/vs/editor/editor.worker"]
-                    }
-                  }
-                }
-              }
-            },
-            "build"
-          )
-        );
-      }
-    }
   } finally {
     if (originalIndexHTML != null)
       await fs.writeFile(indexPath, originalIndexHTML, "utf-8");
@@ -98,7 +62,7 @@ async function build(options, viteConfig = {}, args) {
     await fs.writeFile(redirectsPath, `${config.base}*    ${config.base}index.html   200
 `, "utf-8");
   if ([true, "true", "auto"].includes(options.data.config.download)) {
-    const { exportSlides, getExportOptions } = await import("./export-MLH55TH5.mjs");
+    const { exportSlides, getExportOptions } = await import("./export-65BQ7S5F.mjs");
     const port = 12445;
     const app = connect();
     const server = http.createServer(app);

package/dist/chunk-CV7OWJOF.mjs

@@ -0,0 +1,185 @@
+// node/resolver.ts
+import { dirname, join, resolve } from "node:path";
+import * as fs from "node:fs";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { ensurePrefix, slash } from "@antfu/utils";
+import isInstalledGlobally from "is-installed-globally";
+import { resolveGlobal } from "resolve-global";
+import { findClosestPkgJsonPath, findDepPkgJsonPath } from "vitefu";
+import { resolvePath } from "mlly";
+import globalDirs from "global-directory";
+import prompts from "prompts";
+import { parseNi, run } from "@antfu/ni";
+import { underline, yellow } from "kolorist";
+function toAtFS(path) {
+  return `/@fs${ensurePrefix("/", slash(path))}`;
+}
+async function resolveImportPath(importName, ensure = false) {
+  try {
+    return await resolvePath(importName, {
+      url: import.meta.url
+    });
+  } catch {
+  }
+  if (isInstalledGlobally) {
+    try {
+      return resolveGlobal(importName);
+    } catch {
+    }
+  }
+  if (ensure)
+    throw new Error(`Failed to resolve package "${importName}"`);
+}
+async function findPkgRoot(dep, parent, ensure = false) {
+  const pkgJsonPath = await findDepPkgJsonPath(dep, parent);
+  const path = pkgJsonPath ? dirname(pkgJsonPath) : isInstalledGlobally ? findGlobalPkgRoot(dep, false) : void 0;
+  if (ensure && !path)
+    throw new Error(`Failed to resolve package "${dep}"`);
+  return path;
+}
+async function findGlobalPkgRoot(name, ensure = false) {
+  const yarnPath = join(globalDirs.yarn.packages, name);
+  if (fs.existsSync(`${yarnPath}/package.json`))
+    return yarnPath;
+  const npmPath = join(globalDirs.npm.packages, name);
+  if (fs.existsSync(`${npmPath}/package.json`))
+    return npmPath;
+  if (ensure)
+    throw new Error(`Failed to resolve global package "${name}"`);
+}
+async function resolveEntry(entryRaw, roots) {
+  if (!fs.existsSync(entryRaw) && !entryRaw.endsWith(".md") && !/\/\\/.test(entryRaw))
+    entryRaw += ".md";
+  const entry = entryRaw.startsWith("@/") ? join(roots.userRoot, entryRaw.slice(2)) : resolve(process.cwd(), entryRaw);
+  if (!fs.existsSync(entry)) {
+    const { create } = await prompts({
+      name: "create",
+      type: "confirm",
+      initial: "Y",
+      message: `Entry file ${yellow(`"${entry}"`)} does not exist, do you want to create it?`
+    });
+    if (create)
+      fs.copyFileSync(resolve(roots.cliRoot, "template.md"), entry);
+    else
+      process.exit(0);
+  }
+  return entry;
+}
+function createResolver(type, officials) {
+  async function promptForInstallation(pkgName) {
+    const { confirm } = await prompts({
+      name: "confirm",
+      initial: "Y",
+      type: "confirm",
+      message: `The ${type} "${pkgName}" was not found ${underline(isInstalledGlobally ? "globally" : "in your project")}, do you want to install it now?`
+    });
+    if (!confirm)
+      process.exit(1);
+    if (isInstalledGlobally)
+      await run(parseNi, ["-g", pkgName]);
+    else
+      await run(parseNi, [pkgName]);
+  }
+  return async function(name, importer) {
+    const { userRoot } = await getRoots();
+    if (name === "none")
+      return ["", null];
+    if (name[0] === "/")
+      return [name, name];
+    if (name.startsWith("@/"))
+      return [name, join(userRoot, name.slice(2))];
+    if (name[0] === "." || name[0] !== "@" && name.includes("/"))
+      return [name, join(dirname(importer), name)];
+    if (name.startsWith(`@slidev/${type}-`) || name.startsWith(`slidev-${type}-`)) {
+      const pkgRoot = await findPkgRoot(name, importer);
+      if (!pkgRoot)
+        await promptForInstallation(name);
+      return [name, await findPkgRoot(name, importer, true)];
+    }
+    {
+      const possiblePkgNames = [
+        `@slidev/${type}-${name}`,
+        `slidev-${type}-${name}`,
+        name
+      ];
+      for (const pkgName2 of possiblePkgNames) {
+        const pkgRoot = await findPkgRoot(pkgName2, importer);
+        if (pkgRoot)
+          return [pkgName2, pkgRoot];
+      }
+    }
+    const pkgName = officials[name] ?? (name[0] === "@" ? name : `slidev-${type}-${name}`);
+    await promptForInstallation(pkgName);
+    return [pkgName, await findPkgRoot(pkgName, importer, true)];
+  };
+}
+async function getUserRoot() {
+  const pkgJsonPath = await findClosestPkgJsonPath(process.cwd());
+  return pkgJsonPath ? dirname(pkgJsonPath) : process.cwd();
+}
+function getUserPkgJson(userRoot) {
+  const path = resolve(userRoot, "package.json");
+  if (fs.existsSync(path))
+    return JSON.parse(fs.readFileSync(path, "utf-8"));
+  return {};
+}
+function hasWorkspacePackageJSON(root) {
+  const path = join(root, "package.json");
+  try {
+    fs.accessSync(path, fs.constants.R_OK);
+  } catch {
+    return false;
+  }
+  const content = JSON.parse(fs.readFileSync(path, "utf-8")) || {};
+  return !!content.workspaces;
+}
+function hasRootFile(root) {
+  const ROOT_FILES = [
+    // '.git',
+    // https://pnpm.js.org/workspaces/
+    "pnpm-workspace.yaml"
+    // https://rushjs.io/pages/advanced/config_files/
+    // 'rush.json',
+    // https://nx.dev/latest/react/getting-started/nx-setup
+    // 'workspace.json',
+    // 'nx.json'
+  ];
+  return ROOT_FILES.some((file) => fs.existsSync(join(root, file)));
+}
+function searchForWorkspaceRoot(current, root = current) {
+  if (hasRootFile(current))
+    return current;
+  if (hasWorkspacePackageJSON(current))
+    return current;
+  const dir = dirname(current);
+  if (!dir || dir === current)
+    return root;
+  return searchForWorkspaceRoot(dir, root);
+}
+var rootsInfo = null;
+async function getRoots() {
+  if (rootsInfo)
+    return rootsInfo;
+  const cliRoot = fileURLToPath(new URL("..", import.meta.url));
+  const clientRoot = await findPkgRoot("@slidev/client", cliRoot, true);
+  const userRoot = await getUserRoot();
+  const userPkgJson = getUserPkgJson(userRoot);
+  const userWorkspaceRoot = searchForWorkspaceRoot(userRoot);
+  rootsInfo = {
+    cliRoot,
+    clientRoot,
+    userRoot,
+    userPkgJson,
+    userWorkspaceRoot
+  };
+  return rootsInfo;
+}
+
+export {
+  toAtFS,
+  resolveImportPath,
+  resolveEntry,
+  createResolver,
+  getRoots
+};

package/dist/chunk-KNY3KC45.mjs

@@ -0,0 +1,151 @@
+import {
+  ViteSlidevPlugin,
+  checkEngine,
+  mergeViteConfigs,
+  version
+} from "./chunk-O56CS6WQ.mjs";
+import {
+  createResolver,
+  getRoots,
+  resolveEntry
+} from "./chunk-CV7OWJOF.mjs";
+
+// node/server.ts
+import { join } from "node:path";
+import process from "node:process";
+import { createServer as createViteServer, mergeConfig } from "vite";
+async function createServer(options, viteConfig = {}, serverOptions = {}) {
+  process.env.EDITOR = process.env.EDITOR || "code";
+  const config = await mergeViteConfigs(
+    options,
+    viteConfig,
+    {
+      root: options.userRoot,
+      optimizeDeps: {
+        entries: [
+          join(options.clientRoot, "main.ts")
+        ]
+      }
+    },
+    "serve"
+  );
+  const server = await createViteServer(
+    mergeConfig(
+      config,
+      {
+        plugins: [
+          await ViteSlidevPlugin(options, config.slidev || {}, serverOptions)
+        ],
+        define: {
+          // Fixes Vue production mode breaking PDF Export #1245
+          __VUE_PROD_DEVTOOLS__: JSON.stringify(true)
+        }
+      }
+    )
+  );
+  return server;
+}
+
+// node/parser.ts
+import * as parser from "@slidev/parser/fs";
+
+// node/themes.ts
+import { join as join2 } from "node:path";
+import fs from "fs-extra";
+import { satisfies } from "semver";
+var officialThemes = {
+  "none": "",
+  "default": "@slidev/theme-default",
+  "seriph": "@slidev/theme-seriph",
+  "apple-basic": "@slidev/theme-apple-basic",
+  "shibainu": "@slidev/theme-shibainu",
+  "bricks": "@slidev/theme-bricks"
+};
+var resolveTheme = createResolver("theme", officialThemes);
+async function getThemeMeta(name, root) {
+  const path = join2(root, "package.json");
+  if (!fs.existsSync(path))
+    return {};
+  const { slidev = {}, engines = {} } = await fs.readJSON(path);
+  if (engines.slidev && !satisfies(version, engines.slidev, { includePrerelease: true }))
+    throw new Error(`[slidev] theme "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
+  return slidev;
+}
+
+// node/addons.ts
+import { resolve } from "node:path";
+import fs2 from "fs-extra";
+async function resolveAddons(addonsInConfig) {
+  const { userRoot, userPkgJson } = await getRoots();
+  const resolved = [];
+  const resolveAddonNameAndRoot = createResolver("addon", {});
+  async function resolveAddon(name, parent) {
+    const [, pkgRoot] = await resolveAddonNameAndRoot(name, parent);
+    if (!pkgRoot)
+      return;
+    resolved.push(pkgRoot);
+    const { slidev, engines } = await fs2.readJSON(resolve(pkgRoot, "package.json"));
+    checkEngine(name, engines);
+    if (Array.isArray(slidev?.addons))
+      await Promise.all(slidev.addons.map((addon) => resolveAddon(addon, pkgRoot)));
+  }
+  if (Array.isArray(addonsInConfig))
+    await Promise.all(addonsInConfig.map((addon) => resolveAddon(addon, userRoot)));
+  if (Array.isArray(userPkgJson.slidev?.addons))
+    await Promise.all(userPkgJson.slidev.addons.map((addon) => resolveAddon(addon, userRoot)));
+  return resolved;
+}
+
+// node/options.ts
+import { uniq } from "@antfu/utils";
+import _debug from "debug";
+var debug = _debug("slidev:options");
+async function resolveOptions(options, mode) {
+  const rootsInfo = await getRoots();
+  const entry = await resolveEntry(options.entry || "slides.md", rootsInfo);
+  const loaded = await parser.load(rootsInfo.userRoot, entry, void 0, mode);
+  const themeRaw = options.theme || loaded.headmatter.theme || "default";
+  const [theme, themeRoot] = await resolveTheme(themeRaw, entry);
+  const themeRoots = themeRoot ? [themeRoot] : [];
+  const themeMeta = themeRoot ? await getThemeMeta(theme, themeRoot) : void 0;
+  const config = parser.resolveConfig(loaded.headmatter, themeMeta, options.entry);
+  const addonRoots = await resolveAddons(config.addons);
+  const roots = uniq([...themeRoots, ...addonRoots, rootsInfo.userRoot]);
+  debug({
+    ...rootsInfo,
+    ...options,
+    config,
+    mode,
+    entry,
+    themeRaw,
+    theme,
+    themeRoots,
+    addonRoots,
+    roots
+  });
+  return {
+    ...rootsInfo,
+    ...options,
+    data: {
+      ...loaded,
+      config,
+      themeMeta
+    },
+    mode,
+    entry,
+    themeRaw,
+    theme,
+    themeRoots,
+    addonRoots,
+    roots
+  };
+}
+
+export {
+  createServer,
+  parser,
+  resolveTheme,
+  getThemeMeta,
+  resolveAddons,
+  resolveOptions
+};