@slidev/cli 0.22.6 → 0.23.2

package/dist/{chunk-WW3PRZGC.mjs → chunk-NHK2R4LN.mjs}

@@ -92,15 +92,13 @@ import { resolve as resolve2, dirname } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { slash, uniq as uniq2 } from "@antfu/utils";
 import WindiCSS, { defaultConfigureFiles } from "vite-plugin-windicss";
-
-// node/plugins/jiti.ts
-import _jiti from "jiti";
-var jiti = _jiti(__filename);
+import jiti2 from "jiti";
 
 // node/plugins/setupNode.ts
 import { resolve } from "path";
 import { existsSync as existsSync2 } from "fs-extra";
 import { isObject } from "@antfu/utils";
+import jiti from "jiti";
 function deepMerge(a, b, rootPath = "") {
   a = __spreadValues({}, a);
   Object.keys(b).forEach((key) => {
@@ -118,7 +116,7 @@ async function loadSetups(roots, name, arg, initial, merge = true) {
   for (const root of roots) {
     const path = resolve(root, "setup", name);
     if (existsSync2(path)) {
-      const { default: setup } = jiti(path);
+      const { default: setup } = jiti(__filename)(path);
       const result = await setup(arg);
       if (result !== null) {
         returns = merge ? deepMerge(returns, result) : result;
@@ -136,7 +134,7 @@ async function createWindiCSSPlugin({ themeRoots, clientRoot, userRoot, roots, d
     resolve2(clientRoot, "windi.config.ts")
   ]);
   const configFile = configFiles.find((i) => existsSync3(i));
-  let config = jiti(configFile);
+  let config = jiti2(__filename)(configFile);
   if (config.default)
     config = config.default;
   config = await loadSetups(roots, "windicss.ts", {}, config, true);
@@ -171,42 +169,134 @@ async function createWindiCSSPlugin({ themeRoots, clientRoot, userRoot, roots, d
 
 // node/plugins/preset.ts
 import Vue from "@vitejs/plugin-vue";
-import ViteIcons, { ViteIconsResolver } from "vite-plugin-icons";
-import ViteComponents from "vite-plugin-components";
+import Icons from "unplugin-icons/vite";
+import IconsResolver from "unplugin-icons/resolver";
+import Components from "unplugin-vue-components/vite";
 import RemoteAssets, { DefaultRules } from "vite-plugin-remote-assets";
+import ServerRef from "vite-plugin-vue-server-ref";
 import { notNullish as notNullish2 } from "@antfu/utils";
 
-// node/plugins/config.ts
-import { join as join2 } from "path";
+// node/drawings.ts
+import { dirname as dirname2, resolve as resolve3, join as join2, basename } from "path";
+import fs2 from "fs-extra";
+import fg from "fast-glob";
+function resolveDrawingsDir(options) {
+  return options.data.config.drawings.persist ? resolve3(dirname2(options.entry), options.data.config.drawings.persist) : void 0;
+}
+async function loadDrawings(options) {
+  const dir = resolveDrawingsDir(options);
+  if (!dir || !fs2.existsSync(dir))
+    return {};
+  const files = await fg("*.svg", {
+    onlyFiles: true,
+    cwd: dir,
+    absolute: true
+  });
+  const obj = {};
+  Promise.all(files.map(async (path) => {
+    const num = +basename(path, ".svg");
+    if (Number.isNaN(num))
+      return;
+    const content = await fs2.readFile(path, "utf8");
+    const lines = content.split(/\n/g);
+    obj[num.toString()] = lines.slice(1, -1).join("\n");
+  }));
+  return obj;
+}
+async function writeDarwings(options, drawing) {
+  const dir = resolveDrawingsDir(options);
+  if (!dir)
+    return;
+  const width = options.data.config.canvasWidth;
+  const height = Math.round(width / options.data.config.aspectRatio);
+  const SVG_HEAD = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">`;
+  await fs2.ensureDir(dir);
+  return Promise.all(Object.entries(drawing).map(async ([key, value]) => {
+    if (!value)
+      return;
+    const svg = `${SVG_HEAD}
+${value}
+</svg>`;
+    await fs2.writeFile(join2(dir, `${key}.svg`), svg, "utf-8");
+  }));
+}
+
+// node/plugins/extendConfig.ts
+import { dirname as dirname4, join as join4 } from "path";
 import { mergeConfig } from "vite";
 import isInstalledGlobally from "is-installed-globally";
+import resolveGlobal from "resolve-global";
+import { uniq as uniq3 } from "@antfu/utils";
 
 // ../client/package.json
 var dependencies = {
-  "@antfu/utils": "^0.2.4",
+  "@antfu/utils": "^0.3.0",
   "@slidev/parser": "workspace:*",
   "@slidev/types": "workspace:*",
-  "@vueuse/core": "^5.1.4",
+  "@vueuse/core": "^6.3.3",
   "@vueuse/head": "^0.6.0",
-  "@vueuse/motion": "^1.5.6",
-  codemirror: "^5.62.2",
+  "@vueuse/motion": "^1.6.0",
+  codemirror: "^5.62.3",
+  drauu: "^0.1.0",
   "file-saver": "^2.0.5",
-  "js-base64": "^3.6.1",
+  "js-base64": "^3.7.0",
   "js-yaml": "^4.1.0",
-  katex: "^0.13.13",
-  mermaid: "8.5.0",
-  "monaco-editor": "^0.26.1",
-  nanoid: "^3.1.23",
-  prettier: "^2.3.2",
+  katex: "^0.13.18",
+  mermaid: "^8.12.1",
+  "monaco-editor": "^0.27.0",
+  nanoid: "^3.1.25",
+  prettier: "^2.4.0",
   recordrtc: "^5.6.2",
   resolve: "^1.20.0",
-  "vite-plugin-windicss": "^1.2.5",
-  vue: "^3.1.5",
-  "vue-router": "^4.0.10",
-  windicss: "^3.1.5"
+  "vite-plugin-windicss": "^1.4.2",
+  vue: "^3.2.11",
+  "vue-router": "^4.0.11",
+  windicss: "^3.1.7"
 };
 
-// node/plugins/config.ts
+// node/vite/searchRoot.ts
+import fs3 from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+var ROOT_FILES = [
+  "pnpm-workspace.yaml"
+];
+function hasWorkspacePackageJSON(root) {
+  const path = join3(root, "package.json");
+  try {
+    fs3.accessSync(path, fs3.constants.R_OK);
+  } catch {
+    return false;
+  }
+  const content = JSON.parse(fs3.readFileSync(path, "utf-8")) || {};
+  return !!content.workspaces;
+}
+function hasRootFile(root) {
+  return ROOT_FILES.some((file) => fs3.existsSync(join3(root, file)));
+}
+function hasPackageJSON(root) {
+  const path = join3(root, "package.json");
+  return fs3.existsSync(path);
+}
+function searchForPackageRoot(current, root = current) {
+  if (hasPackageJSON(current))
+    return current;
+  const dir = dirname3(current);
+  if (!dir || dir === current)
+    return root;
+  return searchForPackageRoot(dir, root);
+}
+function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
+  if (hasRootFile(current))
+    return current;
+  if (hasWorkspacePackageJSON(current))
+    return current;
+  const dir = dirname3(current);
+  if (!dir || dir === current)
+    return root;
+  return searchForWorkspaceRoot(dir, root);
+}
+
+// node/plugins/extendConfig.ts
 var EXCLUDE = [
   "@slidev/shared",
   "@slidev/types",
@@ -221,11 +311,7 @@ function createConfigPlugin(options) {
     name: "slidev:config",
     config(config) {
       const injection = {
-        define: {
-          __SLIDEV_CLIENT_ROOT__: JSON.stringify(toAtFS(options.clientRoot)),
-          __SLIDEV_HASH_ROUTE__: options.data.config.routerMode === "hash",
-          __DEV__: options.mode === "dev" ? "true" : "false"
-        },
+        define: getDefine(options),
         resolve: {
           alias: {
             "@slidev/client/": `${toAtFS(options.clientRoot)}/`
@@ -243,18 +329,24 @@ function createConfigPlugin(options) {
             "prettier/esm/parser-babel",
             "prettier/esm/parser-html",
             "prettier/esm/parser-typescript",
-            "mermaid/dist/mermaid.min"
+            "mermaid/dist/mermaid.min",
+            "vite-plugin-vue-server-ref/client"
           ],
           exclude: EXCLUDE
         },
         server: {
           fs: {
-            strict: true
+            strict: true,
+            allow: uniq3([
+              searchForWorkspaceRoot(options.userRoot),
+              searchForWorkspaceRoot(options.cliRoot),
+              ...isInstalledGlobally ? [dirname4(resolveGlobal("@slidev/client/package.json"))] : []
+            ])
           }
         }
       };
       if (isInstalledGlobally) {
-        injection.cacheDir = join2(options.cliRoot, "node_modules/.vite");
+        injection.cacheDir = join4(options.cliRoot, "node_modules/.vite");
         injection.root = options.cliRoot;
         injection.resolve.alias.vue = `${resolveImportPath("vue/dist/vue.esm-browser.js", true)}`;
       }
@@ -264,6 +356,7 @@ function createConfigPlugin(options) {
       return () => {
         server.middlewares.use(async (req, res, next) => {
           if (req.url.endsWith(".html")) {
+            res.setHeader("Content-Type", "text/html");
             res.statusCode = 200;
             res.end(await getIndexHtml(options));
             return;
@@ -274,13 +367,22 @@ function createConfigPlugin(options) {
     }
   };
 }
+function getDefine(options) {
+  return {
+    __SLIDEV_CLIENT_ROOT__: JSON.stringify(toAtFS(options.clientRoot)),
+    __SLIDEV_HASH_ROUTE__: JSON.stringify(options.data.config.routerMode === "hash"),
+    __SLIDEV_FEATURE_DRAWINGS__: JSON.stringify(options.data.config.drawings.enabled === true || options.data.config.drawings.enabled === options.mode),
+    __SLIDEV_FEATURE_DRAWINGS_PERSIST__: JSON.stringify(!!options.data.config.drawings.persist === true),
+    __DEV__: options.mode === "dev" ? "true" : "false"
+  };
+}
 
 // node/plugins/loaders.ts
 var import_fast_deep_equal = __toModule(require_fast_deep_equal());
-import { basename, join as join3 } from "path";
-import { isString, notNullish, objectMap, range, slash as slash2, uniq as uniq3 } from "@antfu/utils";
-import fg from "fast-glob";
-import fs2, { existsSync as existsSync4 } from "fs-extra";
+import { basename as basename2, join as join5 } from "path";
+import { isString, notNullish, objectMap, range, slash as slash2, uniq as uniq4 } from "@antfu/utils";
+import fg2 from "fast-glob";
+import fs4, { existsSync as existsSync4 } from "fs-extra";
 import Markdown from "markdown-it";
 import mila from "markdown-it-link-attributes";
 import {
@@ -292,13 +394,13 @@ import {
 var regexId = /^\/\@slidev\/slide\/(\d+)\.(md|json)(?:\?import)?$/;
 var regexIdQuery = /(\d+?)\.(md|json)$/;
 function getBodyJson(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let body = "";
     req.on("data", (chunk) => body += chunk);
     req.on("error", reject);
     req.on("end", () => {
       try {
-        resolve4(JSON.parse(body) || {});
+        resolve5(JSON.parse(body) || {});
       } catch (e) {
         reject(e);
       }
@@ -489,6 +591,7 @@ function createSlidesLoader({ data, entry, clientRoot, themeRoots, userRoot, roo
     const layoutName = (frontmatter == null ? void 0 : frontmatter.layout) || (pageNo === 0 ? "cover" : "default");
     if (!layouts[layoutName])
       throw new Error(`Unknown layout "${layoutName}"`);
+    delete frontmatter.title;
     const imports = [
       `import InjectedLayout from "${toAtFS(layouts[layoutName])}"`,
       `const frontmatter = ${JSON.stringify(frontmatter)}`
@@ -513,18 +616,18 @@ ${code.slice(injectB)}`;
     if (now - _layouts_cache_time < 2e3)
       return _layouts_cache;
     const layouts = {};
-    const roots2 = uniq3([
+    const roots2 = uniq4([
       userRoot,
       ...themeRoots,
       clientRoot
     ]);
     for (const root of roots2) {
-      const layoutPaths = await fg("layouts/*.{vue,ts}", {
+      const layoutPaths = await fg2("layouts/*.{vue,ts}", {
         cwd: root,
         absolute: true
       });
       for (const layoutPath of layoutPaths) {
-        const layout = basename(layoutPath).replace(/\.\w+$/, "");
+        const layout = basename2(layoutPath).replace(/\.\w+$/, "");
         if (layouts[layout])
           continue;
         layouts[layout] = layoutPath;
@@ -536,21 +639,21 @@ ${code.slice(injectB)}`;
   }
   async function generateUserStyles() {
     const imports = [
-      `import "${toAtFS(join3(clientRoot, "styles/vars.css"))}"`,
-      `import "${toAtFS(join3(clientRoot, "styles/index.css"))}"`,
-      `import "${toAtFS(join3(clientRoot, "styles/code.css"))}"`
+      `import "${toAtFS(join5(clientRoot, "styles/vars.css"))}"`,
+      `import "${toAtFS(join5(clientRoot, "styles/index.css"))}"`,
+      `import "${toAtFS(join5(clientRoot, "styles/code.css"))}"`
     ];
-    const roots2 = uniq3([
+    const roots2 = uniq4([
       ...themeRoots,
       userRoot
     ]);
     for (const root of roots2) {
       const styles = [
-        join3(root, "styles", "index.ts"),
-        join3(root, "styles", "index.js"),
-        join3(root, "styles", "index.css"),
-        join3(root, "styles.css"),
-        join3(root, "style.css")
+        join5(root, "styles", "index.ts"),
+        join5(root, "styles", "index.js"),
+        join5(root, "styles", "index.css"),
+        join5(root, "styles.css"),
+        join5(root, "style.css")
       ];
       for (const style of styles) {
         if (existsSync4(style)) {
@@ -628,17 +731,17 @@ ${routes.join(",\n")}
     const components = roots.flatMap((root) => {
       if (layer === "top") {
         return [
-          join3(root, "global.vue"),
-          join3(root, "global-top.vue"),
-          join3(root, "GlobalTop.vue")
+          join5(root, "global.vue"),
+          join5(root, "global-top.vue"),
+          join5(root, "GlobalTop.vue")
         ];
       } else {
         return [
-          join3(root, "global-bottom.vue"),
-          join3(root, "GlobalBottom.vue")
+          join5(root, "global-bottom.vue"),
+          join5(root, "GlobalBottom.vue")
         ];
       }
-    }).filter((i) => fs2.existsSync(i));
+    }).filter((i) => fs4.existsSync(i));
     const imports = components.map((i, idx) => `import __n${idx} from '${toAtFS(i)}'`).join("\n");
     const render = components.map((i, idx) => `h(__n${idx})`).join(",");
     return `
@@ -653,8 +756,8 @@ export default {
   }
 }
 
-// node/plugins/monaco.ts
-import { join as join4 } from "path";
+// node/plugins/monacoTransform.ts
+import { join as join6 } from "path";
 import { slash as slash3 } from "@antfu/utils";
 import { resolvePackageData } from "vite";
 function createMonacoTypesLoader() {
@@ -677,7 +780,7 @@ function createMonacoTypesLoader() {
           return "";
         return [
           "import * as monaco from 'monaco-editor'",
-          `import Type from "${slash3(join4(info.dir, typePath))}?raw"`,
+          `import Type from "${slash3(join6(info.dir, typePath))}?raw"`,
           ...Object.keys(info.data.dependencies || {}).map((i) => `import "/@slidev-monaco-types/${i}"`),
           `monaco.languages.typescript.typescriptDefaults.addExtraLib(\`declare module "${pkg}" { \${Type} }\`)`
         ].join("\n");
@@ -688,10 +791,10 @@ function createMonacoTypesLoader() {
 
 // node/plugins/setupClient.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join5, resolve as resolve3 } from "path";
-import { slash as slash4, uniq as uniq4 } from "@antfu/utils";
+import { join as join7, resolve as resolve4 } from "path";
+import { slash as slash4, uniq as uniq5 } from "@antfu/utils";
 function createClientSetupPlugin({ clientRoot, themeRoots, userRoot }) {
-  const setupEntry = slash4(resolve3(clientRoot, "setup"));
+  const setupEntry = slash4(resolve4(clientRoot, "setup"));
   return {
     name: "slidev:setup",
     enforce: "pre",
@@ -701,10 +804,10 @@ function createClientSetupPlugin({ clientRoot, themeRoots, userRoot }) {
         const imports = [];
         const injections = [];
         const asyncInjections = [];
-        const setups = uniq4([
+        const setups = uniq5([
           ...themeRoots,
           userRoot
-        ]).map((i) => join5(i, "setup", name));
+        ]).map((i) => join7(i, "setup", name));
         setups.forEach((path, idx) => {
           if (!existsSync5(path))
             return;
@@ -735,98 +838,6 @@ function createClientSetupPlugin({ clientRoot, themeRoots, userRoot }) {
   };
 }
 
-// node/plugins/server-ref.ts
-var PREFIX = "/@server-ref/";
-function VitePluginServerRef(options = {}) {
-  const {
-    dataMap = {},
-    debounceMs = 10,
-    debug = true
-  } = options;
-  return {
-    name: "vite-plugin-server-ref",
-    resolveId(id) {
-      return id.startsWith(PREFIX) ? id : null;
-    },
-    configureServer(server) {
-      server.middlewares.use(async (req, res, next) => {
-        var _a, _b;
-        if (!((_a = req.url) == null ? void 0 : _a.startsWith(PREFIX)) || req.method !== "POST")
-          return next();
-        const name = req.url.slice(PREFIX.length);
-        const { data, timestamp } = await getBodyJson(req);
-        const module = server.moduleGraph.getModuleById(PREFIX + name);
-        if (module)
-          server.moduleGraph.invalidateModule(module);
-        dataMap[name] = data;
-        server.ws.send({
-          type: "custom",
-          event: "server-ref",
-          data: {
-            name,
-            data,
-            timestamp
-          }
-        });
-        (_b = options.onChanged) == null ? void 0 : _b.call(options, name, data, timestamp);
-        res.write("");
-        res.end();
-      });
-    },
-    load(id) {
-      var _a;
-      if (!id.startsWith(PREFIX))
-        return;
-      const name = id.slice(PREFIX.length);
-      return `
-import { ref, watch } from "vue"
-
-const data = ref(${JSON.stringify((_a = dataMap[name]) != null ? _a : null)})
-
-if (import.meta.hot) {
-  ${debug ? `console.log("[server-ref] [${name}] ref", data)` : ""}
-  ${debug ? `console.log("[server-ref] [${name}] initial", data.value)` : ""}
-
-  let skipNext = false
-  let timer = null
-  import.meta.hot.on("server-ref", (payload) =>{
-    if (payload.name !== "${name}")
-      return
-    skipNext = true
-    data.value = payload.data
-    ${debug ? `console.log("[server-ref] [${name}] incoming", payload.data)` : ""}
-  })
-  watch(data, (v) => {
-    if (skipNext) {
-      skipNext = false
-      return
-    }
-    if (timer)
-      clearTimeout(timer)
-
-    timer = setTimeout(()=>{
-      ${debug ? `console.log("[server-ref] [${name}] outgoing", data.value)` : ""}
-      fetch('${PREFIX + name}', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          data: data.value,
-          timestamp: Date.now(),
-        })
-      })
-    }, ${debounceMs})
-  }, { flush: 'sync', deep: true })
-}
-
-export default data
-`;
-    }
-  };
-}
-var server_ref_default = VitePluginServerRef;
-
 // node/plugins/markdown.ts
 import Markdown2 from "vite-plugin-md";
 import base64 from "js-base64";
@@ -1244,16 +1255,21 @@ function escapeVueInCode(md2) {
   return md2.replace(/{{(.*?)}}/g, "&lbrace;&lbrace;$1&rbrace;&rbrace;");
 }
 
-// node/plugins/fix.ts
-function createFixPlugins({ mode }) {
-  const DEV = mode === "dev" ? "true" : "false";
+// node/plugins/patchTransform.ts
+import { objectEntries } from "@antfu/utils";
+function createFixPlugins(options) {
+  const define = objectEntries(getDefine(options));
   return [
     {
       name: "slidev:flags",
       enforce: "pre",
       transform(code, id) {
-        if (id.endsWith(".vue"))
-          return code.replace(/__DEV__/g, DEV);
+        if (id.endsWith(".vue")) {
+          define.forEach(([from, to]) => {
+            code = code.replace(new RegExp(from, "g"), to);
+          });
+          return code;
+        }
       }
     }
   ];
@@ -1305,12 +1321,13 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
     }, vueOptions == null ? void 0 : vueOptions.template)
   }, vueOptions));
   const MarkdownPlugin = await createMarkdownPlugin(options, pluginOptions);
+  const drawingData = await loadDrawings(options);
   return [
     await createWindiCSSPlugin(options, pluginOptions),
     MarkdownPlugin,
     VuePlugin,
     createSlidesLoader(options, pluginOptions, serverOptions, VuePlugin, MarkdownPlugin),
-    ViteComponents(__spreadValues({
+    Components(__spreadValues({
       extensions: ["vue", "md", "ts"],
       dirs: [
         `${clientRoot}/builtin`,
@@ -1319,14 +1336,15 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
         "src/components",
         "components"
       ],
-      customLoaderMatcher: (id) => id.endsWith(".md"),
-      customComponentResolvers: [
-        ViteIconsResolver({
-          componentPrefix: ""
+      include: [/\.vue$/, /\.vue\?vue/, /\.md$/],
+      exclude: [],
+      resolvers: [
+        IconsResolver({
+          prefix: ""
         })
       ]
     }, componentsOptions)),
-    ViteIcons(__spreadValues({}, iconsOptions)),
+    Icons(__spreadValues({}, iconsOptions)),
     config.remoteAssets === true || config.remoteAssets === mode ? RemoteAssets(__spreadValues({
       rules: [
         ...DefaultRules,
@@ -1338,13 +1356,21 @@ async function ViteSlidevPlugin(options, pluginOptions, serverOptions = {}) {
       resolveMode: (id) => id.endsWith("index.html") ? "relative" : "@fs",
       awaitDownload: mode === "build"
     }, remoteAssetsOptions)) : null,
-    server_ref_default({
-      dataMap: {
+    ServerRef({
+      debug: process.env.NODE_ENV === "development",
+      state: {
         sync: false,
-        state: {
+        nav: {
           page: 0,
           clicks: 0
-        }
+        },
+        drawings: drawingData
+      },
+      onChanged(key, data, patch) {
+        if (!options.data.config.drawings.persist)
+          return;
+        if (key === "drawings")
+          writeDarwings(options, patch != null ? patch : data);
       }
     }),
     createConfigPlugin(options),