@slidev/cli 0.48.0-beta.8 → 0.48.0

package/dist/{build-E73DC6MR.mjs → build-KHRRQKZT.mjs}

@@ -2,21 +2,17 @@ import {
   ViteSlidevPlugin,
   getIndexHtml,
   mergeViteConfigs
-} from "./chunk-H6RR7TOW.mjs";
-import "./chunk-O6TYYGU6.mjs";
-import {
-  findPkgRoot
-} from "./chunk-7HOZGSL4.mjs";
-import "./chunk-BXO7ZPPU.mjs";
+} from "./chunk-EAVFHD5X.mjs";
+import "./chunk-LOUKLO2C.mjs";
+import "./chunk-AQQIBD5X.mjs";
 
-// node/build.ts
-import { join, resolve } from "node:path";
+// node/commands/build.ts
+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;
@@ -53,38 +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"));
-        const monacoRoot = await findPkgRoot("monaco-editor", options.clientRoot, true);
-        const getWorkerPath = (path) => [join(monacoRoot, "esm/vs", path)];
-        await viteBuild({
-          root: join(options.clientRoot, "iframes/monaco"),
-          base: `${config.base}iframes/monaco/`,
-          plugins: [
-            await ViteSlidevPlugin(options, inlineConfig.slidev || {})
-          ],
-          build: {
-            outDir: resolve(options.userRoot, config.build.outDir, "iframes/monaco"),
-            // fix for monaco workers
-            // https://github.com/vitejs/vite/issues/1927#issuecomment-805803918
-            rollupOptions: {
-              output: {
-                manualChunks: {
-                  jsonWorker: getWorkerPath("language/json/json.worker"),
-                  cssWorker: getWorkerPath("language/css/css.worker"),
-                  htmlWorker: getWorkerPath("language/html/html.worker"),
-                  tsWorker: getWorkerPath("language/typescript/ts.worker"),
-                  editorWorker: getWorkerPath("editor/editor.worker")
-                }
-              }
-            }
-          }
-        });
-      }
-    }
   } 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-SM2ZATWB.mjs");
+    const { exportSlides, getExportOptions } = await import("./export-P7ZNLPWH.mjs");
     const port = 12445;
     const app = connect();
     const server = http.createServer(app);

package/dist/chunk-AQQIBD5X.mjs

@@ -0,0 +1,187 @@
+// 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 { 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";
+var cliRoot = fileURLToPath(new URL("..", import.meta.url));
+async function resolveImportUrl(id) {
+  return toAtFS(await resolveImportPath(id, true));
+}
+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 ? await 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) {
+  if (!fs.existsSync(entryRaw) && !entryRaw.endsWith(".md") && !/[\/\\]/.test(entryRaw))
+    entryRaw += ".md";
+  const entry = resolve(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(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)];
+  };
+}
+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(entry) {
+  if (rootsInfo)
+    return rootsInfo;
+  if (!entry)
+    throw new Error("[slidev] Cannot find roots without entry");
+  const clientRoot = await findPkgRoot("@slidev/client", cliRoot, true);
+  const userRoot = dirname(entry);
+  const userPkgJson = getUserPkgJson(userRoot);
+  const userWorkspaceRoot = searchForWorkspaceRoot(userRoot);
+  rootsInfo = {
+    cliRoot,
+    clientRoot,
+    userRoot,
+    userPkgJson,
+    userWorkspaceRoot
+  };
+  return rootsInfo;
+}
+
+export {
+  resolveImportUrl,
+  toAtFS,
+  resolveImportPath,
+  resolveEntry,
+  createResolver,
+  getRoots
+};