dumi 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/features/theme/index.js

@@ -37,14 +37,14 @@ function getPkgThemePath(api) {
   return pkgThemeName && import_path.default.basename(require.resolve(`${pkgThemeName}/package.json`, { paths: [api.cwd] }));
 }
 var theme_default = (api) => {
-  let localThemeData;
-  let originalThemeData;
-  const mdRouteFiles = [];
+  const localThemePath = import_path.default.join(api.cwd, import_constants.LOCAL_THEME_DIR);
+  const localThemeData = import_fs.default.existsSync(localThemePath) && (0, import_loader.default)(localThemePath);
   const themeMapKeys = [
     "layouts",
     "builtins",
     "slots"
   ];
+  let originalThemeData;
   api.describe({ key: "dumi:theme" });
   api.register({
     key: "modifyAppData",
@@ -58,9 +58,7 @@ var theme_default = (api) => {
         initialValue: pkgThemeData
       });
       api.service.themeData = originalThemeData;
-      const localThemePath = import_path.default.join(api.cwd, import_constants.LOCAL_THEME_DIR);
-      if (import_fs.default.existsSync(localThemePath)) {
-        localThemeData = (0, import_loader.default)(localThemePath);
+      if (localThemeData) {
         api.service.themeData = (0, import_plugin_utils.deepmerge)(originalThemeData, localThemeData, {
           clone: true
         });
@@ -94,14 +92,6 @@ var theme_default = (api) => {
     memo.extraBabelIncludes.push(import_path.default.resolve(__dirname, "../../client/theme-api"));
     return memo;
   });
-  api.modifyRoutes((routes) => {
-    Object.values(routes).forEach((route) => {
-      if (route.file.endsWith(".md")) {
-        mdRouteFiles.push({ index: mdRouteFiles.length, file: route.file });
-      }
-    });
-    return routes;
-  });
   api.onGenerateFiles(() => {
     themeMapKeys.forEach((key) => {
       Object.values(originalThemeData[key] || {}).forEach((item) => {
@@ -113,25 +103,12 @@ export { default } from '${item.source}';`
         });
       });
     });
-    api.writeTmpFile({
-      noPluginDir: true,
-      path: "dumi/demos.ts",
-      content: import_plugin_utils.Mustache.render(`{{#mdRouteFiles}}
-import demos{{{index}}} from '{{{file}}}?type=meta.demos';
-{{/mdRouteFiles}}
-
-export default {
-  {{#mdRouteFiles}}
-  ...demos{{{index}}},
-  {{/mdRouteFiles}}
-}`, { mdRouteFiles })
-    });
     api.writeTmpFile({
       noPluginDir: true,
       path: "dumi/theme/ContextWrapper.tsx",
       content: `import { Context } from 'dumi/theme';
 import { useOutlet } from 'umi';
-import demos from '../demos';
+import { demos } from '../meta';
 import { locales } from '../locales/config';
 
 export default function DumiContextWrapper() {

package/dist/index.d.ts

@@ -1,2 +1,8 @@
-declare const _default: "Hello dumi 2.0!";
-export default _default;
+import type { IDumiConfig } from "./types";
+declare let unistUtilVisit: typeof import('unist-util-visit');
+export { IApi } from "./types";
+export type { Root as HastRoot } from 'hast';
+export * from 'umi';
+export type { Plugin as UnifiedPlugin, Transformer as UnifiedTransformer, } from 'unified';
+export { unistUtilVisit };
+export declare const defineConfig: (config: IDumiConfig) => IDumiConfig;

package/dist/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,14 +16,25 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  default: () => src_default
+  defineConfig: () => defineConfig,
+  unistUtilVisit: () => unistUtilVisit
 });
 module.exports = __toCommonJS(src_exports);
-var src_default = "Hello dumi 2.0!";
+__reExport(src_exports, require("umi"), module.exports);
+var unistUtilVisit;
+(async () => {
+  unistUtilVisit = await import("unist-util-visit");
+})();
+var defineConfig = (config) => config;
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+0 && (module.exports = {
+  defineConfig,
+  unistUtilVisit
+});

package/dist/loaders/markdown/index.d.ts

@@ -5,7 +5,7 @@ interface IMdLoaderDefaultModeOptions extends Omit<IMdTransformerOptions, 'fileA
     builtins: IThemeLoadResult['builtins'];
 }
 interface IMdLoaderDemosModeOptions extends Omit<IMdLoaderDefaultModeOptions, 'builtins' | 'mode'> {
-    mode: 'demos';
+    mode: 'meta';
 }
 export declare type IMdLoaderOptions = IMdLoaderDefaultModeOptions | IMdLoaderDemosModeOptions;
 export default function mdLoader(this: any, raw: string): void;

package/dist/loaders/markdown/index.js

@@ -25,28 +25,42 @@ __export(markdown_exports, {
   default: () => mdLoader
 });
 module.exports = __toCommonJS(markdown_exports);
+var import_utils = require("../../utils");
 var import_plugin_utils = require("umi/plugin-utils");
 var import_transformer = __toESM(require("./transformer"));
 function mdLoader(raw) {
   const opts = this.getOptions();
   const cb = this.async();
-  (0, import_transformer.default)(raw, {
-    techStacks: opts.techStacks,
-    cwd: opts.cwd,
+  let content = raw;
+  const params = new URLSearchParams(this.resourceQuery);
+  const range = params.get("range");
+  const regexp = params.get("regexp");
+  if (range) {
+    content = (0, import_utils.getFileRangeLines)(content, range);
+  } else if (regexp) {
+    content = (0, import_utils.getFileContentByRegExp)(content, regexp, this.resourcePath);
+  }
+  (0, import_transformer.default)(content, {
+    ...import_plugin_utils.lodash.omit(opts, ["mode", "builtins"]),
     fileAbsPath: this.resourcePath
   }).then((ret) => {
-    if (opts.mode === "demos") {
+    if (opts.mode === "meta") {
+      const { demos, frontmatter = {} } = ret.meta;
       cb(null, import_plugin_utils.Mustache.render(`import React from 'react';
 
-export default {
+export const demos = {
   {{#demos}}
   '{{{id}}}': {
     component: {{{component}}},
     asset: {{{renderAsset}}}
   },
   {{/demos}}
-}`, {
-        demos: ret.meta.demos,
+};
+
+export const frontmatter = {{{frontmatter}}};
+`, {
+        demos,
+        frontmatter: JSON.stringify(frontmatter),
         renderAsset: function renderAsset() {
           Object.keys(this.sources).forEach((file) => {
             this.asset.dependencies[file].value = `{{{require('!!raw-loader!${this.sources[file]}?raw').default}}}`;
@@ -56,6 +70,7 @@ export default {
       }));
     } else {
       cb(null, `${Object.values(opts.builtins).map((item) => `import ${item.specifier} from '${item.source}';`).join("\n")}
+import React from 'react';
 
 // export named function for fastRefresh
 // ref: https://github.com/pmmmwh/react-refresh-webpack-plugin/blob/main/docs/TROUBLESHOOTING.md#edits-always-lead-to-full-reload

package/dist/loaders/markdown/transformer/index.d.ts

@@ -1,5 +1,6 @@
 import type { IParsedBlockAsset } from "../../../assetParsers/block";
-import type { IDumiTechStack } from "../../../types";
+import type { IRouteMeta } from "../../../client/theme-api";
+import type { IDumiConfig, IDumiTechStack } from "../../../types";
 import type { DataMap } from 'vfile';
 declare module 'hast' {
     interface Element {
@@ -21,12 +22,16 @@ declare module 'vfile' {
             asset: IParsedBlockAsset['asset'];
             sources: IParsedBlockAsset['sources'];
         }[];
+        frontmatter: IRouteMeta;
     }
 }
 export interface IMdTransformerOptions {
     cwd: string;
     fileAbsPath: string;
     techStacks: IDumiTechStack[];
+    codeBlockMode: IDumiConfig['resolve']['codeBlockMode'];
+    extraRemarkPlugins?: IDumiConfig['extraRemarkPlugins'];
+    extraRehypePlugins?: IDumiConfig['extraRehypePlugins'];
 }
 export interface IMdTransformerResult {
     content: string;

package/dist/loaders/markdown/transformer/index.js

@@ -26,22 +26,46 @@ __export(transformer_exports, {
 });
 module.exports = __toCommonJS(transformer_exports);
 var import_rehypeDemo = __toESM(require("./rehypeDemo"));
+var import_rehypeEmbed = __toESM(require("./rehypeEmbed"));
 var import_rehypeIsolation = __toESM(require("./rehypeIsolation"));
 var import_rehypeJsxify = __toESM(require("./rehypeJsxify"));
 var import_rehypeRaw = __toESM(require("./rehypeRaw"));
 var import_rehypeStrip = __toESM(require("./rehypeStrip"));
+var import_remarkMeta = __toESM(require("./remarkMeta"));
+function applyUnifiedPlugin(opts) {
+  const [plugin, options] = Array.isArray(opts.plugin) ? opts.plugin : [opts.plugin];
+  const mod = typeof plugin === "function" ? plugin : require(require.resolve(plugin, { paths: [opts.cwd] }));
+  const fn = mod.default || mod;
+  opts.processor.use(fn, options);
+}
 var transformer_default = async (raw, opts) => {
+  var _a, _b;
   const { unified } = await import("unified");
   const { default: remarkParse } = await import("remark-parse");
   const { default: remarkFrontmatter } = await import("remark-frontmatter");
   const { default: remarkBreaks } = await import("remark-breaks");
   const { default: remarkGfm } = await import("remark-gfm");
   const { default: remarkRehype } = await import("remark-rehype");
-  const result = await unified().use(remarkParse).use(remarkFrontmatter).use(remarkBreaks).use(remarkGfm).use(remarkRehype, { allowDangerousHtml: true }).use(import_rehypeRaw.default).use(import_rehypeStrip.default).use(import_rehypeDemo.default, {
+  const processor = unified().use(remarkParse).use(remarkFrontmatter).use(import_remarkMeta.default).use(remarkBreaks).use(remarkGfm);
+  (_a = opts.extraRemarkPlugins) == null ? void 0 : _a.forEach((plugin) => applyUnifiedPlugin({
+    plugin,
+    processor,
+    cwd: opts.cwd
+  }));
+  processor.use(remarkRehype, { allowDangerousHtml: true }).use(import_rehypeRaw.default).use(import_rehypeStrip.default).use(import_rehypeEmbed.default, {
+    fileAbsPath: opts.fileAbsPath
+  }).use(import_rehypeDemo.default, {
     techStacks: opts.techStacks,
     cwd: opts.cwd,
-    fileAbsPath: opts.fileAbsPath
-  }).use(import_rehypeIsolation.default).use(import_rehypeJsxify.default).process(raw);
+    fileAbsPath: opts.fileAbsPath,
+    codeBlockMode: opts.codeBlockMode
+  }).use(import_rehypeIsolation.default);
+  (_b = opts.extraRehypePlugins) == null ? void 0 : _b.forEach((plugin) => applyUnifiedPlugin({
+    plugin,
+    processor,
+    cwd: opts.cwd
+  }));
+  const result = await processor.use(import_rehypeJsxify.default).process(raw);
   return {
     content: String(result.value),
     meta: result.data

package/dist/loaders/markdown/transformer/rehypeDemo.d.ts

@@ -1,6 +1,6 @@
 import type { Root } from 'hast';
 import type { Transformer } from 'unified';
 import type { IMdTransformerOptions } from '.';
-declare type IRehypeDemoOptions = Pick<IMdTransformerOptions, 'techStacks' | 'cwd' | 'fileAbsPath'>;
+declare type IRehypeDemoOptions = Pick<IMdTransformerOptions, 'techStacks' | 'cwd' | 'fileAbsPath' | 'codeBlockMode'>;
 export default function rehypeDemo(opts: IRehypeDemoOptions): Transformer<Root>;
 export {};

package/dist/loaders/markdown/transformer/rehypeDemo.js

@@ -40,25 +40,25 @@ var DEMO_PROP_VALUE_KEY = "$demo-prop-value-key";
   ({ toString } = await import("mdast-util-to-string"));
   ({ isElement } = await import("hast-util-is-element"));
 })();
-function getCodeLang(node) {
-  var _a, _b;
+function getCodeLang(node, opts) {
+  var _a, _b, _c, _d;
   let lang = "";
   if (typeof ((_a = node.properties) == null ? void 0 : _a.src) === "string") {
     lang = import_path.default.extname(node.properties.src).slice(1);
-  } else if (Array.isArray((_b = node.properties) == null ? void 0 : _b.className)) {
+  } else if (Array.isArray((_b = node.properties) == null ? void 0 : _b.className) && (opts.codeBlockMode === "passive" ? / demo/.test(String((_c = node.data) == null ? void 0 : _c.meta)) : !/ pure/.test(String((_d = node.data) == null ? void 0 : _d.meta)))) {
     lang = String(node.properties.className[0]).replace("language-", "");
   }
   return lang;
 }
-function getCodeId(cwd, fileAbsPath, codeIndex, entityName) {
+function getCodeId(cwd, fileAbsPath, localId, entityName) {
   const prefix = entityName || (0, import_utils.getRoutePathFromFsPath)(import_path.default.relative(cwd, fileAbsPath)).replace(/\//g, "-");
-  return [prefix, "demo", String(codeIndex)].filter(Boolean).join("-");
+  return [prefix, "demo", localId].filter(Boolean).join("-");
 }
 function tryMarkDemoNode(node, opts) {
   var _a, _b;
   let isDemoNode = Boolean((_a = node.data) == null ? void 0 : _a.techStack);
   if (!isDemoNode) {
-    const lang = getCodeLang(node);
+    const lang = getCodeLang(node, opts);
     const techStack = lang && opts.techStacks.find((ts) => ts.isSupported(node, lang));
     if (techStack) {
       isDemoNode = true;
@@ -118,38 +118,63 @@ function rehypeDemo(opts) {
       if (isElement(node, "p") && ((_a = node.data) == null ? void 0 : _a[DEMO_NODE_CONTAINER])) {
         const demosPropData = [];
         node.children.forEach((codeNode) => {
+          var _a2;
           if (isElement(codeNode, "code")) {
             const codeType = codeNode.data.type;
             const techStack = codeNode.data.techStack;
-            const codeId = getCodeId(opts.cwd, opts.fileAbsPath, index++);
             const codeValue = toString(codeNode.children).trim();
             const parseOpts = {
-              id: codeId,
+              id: "",
               refAtomIds: [],
               fileAbsPath: "",
               entryPointCode: codeType === "external" ? void 0 : codeValue
             };
             const previewerProps = {};
             let component = "";
-            if (codeNode.data.type === "external") {
+            if (codeType === "external") {
               parseOpts.fileAbsPath = import_path.default.resolve(import_path.default.dirname(opts.fileAbsPath), codeNode.properties.src);
+              parseOpts.id = getCodeId(opts.cwd, opts.fileAbsPath, import_path.default.parse(parseOpts.fileAbsPath).name);
               component = `React.lazy(() => import('${(0, import_plugin_utils.winPath)(parseOpts.fileAbsPath)}?techStack=${techStack.name}'))`;
+              codeNode.properties.title = codeValue || void 0;
+              (_a2 = codeNode.properties).filePath ?? (_a2.filePath = (0, import_plugin_utils.winPath)(import_path.default.relative(opts.cwd, parseOpts.fileAbsPath)));
             } else {
               parseOpts.fileAbsPath = opts.fileAbsPath.replace(".md", ".tsx");
+              parseOpts.id = getCodeId(opts.cwd, opts.fileAbsPath, String(index++));
               component = techStack.transformCode(codeValue, {
                 type: "code-block",
                 fileAbsPath: opts.fileAbsPath
               });
             }
             deferrers.push((0, import_block.default)(parseOpts).then(async ({ asset, sources, frontmatter }) => {
-              const { src, className, title, description, ...restAttrs } = codeNode.properties || {};
-              if (description) {
-                asset.description = String(description);
+              var _a3;
+              const { src, className, ...restAttrs } = codeNode.properties || {};
+              if (restAttrs.title) {
+                asset.title = String(restAttrs.title);
               }
-              if (codeType === "external" && codeValue) {
-                asset.title = codeValue;
+              Object.keys(restAttrs).forEach((key) => {
+                if (restAttrs[key] === "")
+                  restAttrs[key] = true;
+              });
+              const originalProps = Object.assign({}, frontmatter, restAttrs);
+              Object.assign(previewerProps, await ((_a3 = techStack.generatePreviewerProps) == null ? void 0 : _a3.call(techStack, originalProps, {
+                type: codeType,
+                mdAbsPath: opts.fileAbsPath,
+                fileAbsPath: codeType === "external" ? parseOpts.fileAbsPath : void 0,
+                entryPointCode: parseOpts.entryPointCode
+              })) || originalProps);
+              if (previewerProps.description) {
+                const { unified } = await import("unified");
+                const { default: remarkParse } = await import("remark-parse");
+                const { default: remarkGfm } = await import("remark-gfm");
+                const { default: remarkRehype } = await import("remark-rehype");
+                const { default: rehypeStringify } = await import("rehype-stringify");
+                const { convert } = require("html-to-text");
+                const result = await unified().use(remarkParse).use(remarkGfm).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeStringify).process(previewerProps.description);
+                previewerProps.description = String(result.value);
+                asset.description = convert(result.value, {
+                  wordwrap: false
+                });
               }
-              Object.assign(previewerProps, frontmatter, restAttrs);
               return {
                 id: asset.id,
                 component,
@@ -158,7 +183,7 @@ function rehypeDemo(opts) {
               };
             }));
             demosPropData.push({
-              demo: { id: codeId },
+              demo: { id: parseOpts.id },
               previewerProps
             });
           }

package/dist/loaders/markdown/transformer/rehypeEmbed.d.ts

@@ -0,0 +1,4 @@
+import type { Root } from 'hast';
+import type { Transformer } from 'unified';
+import type { IMdTransformerOptions } from '.';
+export default function rehypeEmbed(opts: Pick<IMdTransformerOptions, 'fileAbsPath'>): Transformer<Root>;

package/dist/loaders/markdown/transformer/rehypeEmbed.js

@@ -0,0 +1,75 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loaders/markdown/transformer/rehypeEmbed.ts
+var rehypeEmbed_exports = {};
+__export(rehypeEmbed_exports, {
+  default: () => rehypeEmbed
+});
+module.exports = __toCommonJS(rehypeEmbed_exports);
+var import_path = __toESM(require("path"));
+var import_url = __toESM(require("url"));
+var visit;
+(async () => {
+  ({ visit } = await import("unist-util-visit"));
+})();
+function rehypeEmbed(opts) {
+  return async (tree) => {
+    visit(tree, "element", (node, idx, parent) => {
+      var _a;
+      if (node.tagName === "embed" && ((_a = node.properties) == null ? void 0 : _a.hasOwnProperty("src"))) {
+        const { src } = node.properties;
+        const parsed = import_url.default.parse((src == null ? void 0 : src.toString()) || "");
+        const absPath = import_path.default.resolve(import_path.default.parse(opts.fileAbsPath).dir, parsed.pathname);
+        if (absPath) {
+          const hash = decodeURIComponent(parsed.hash || "").replace("#", "");
+          const query = new URLSearchParams();
+          if (hash[0] === "L") {
+            query.append("range", hash);
+          } else if (hash.startsWith("RE-")) {
+            query.append("regexp", hash.substring(3));
+          }
+          const moduleReqPath = `${absPath}?${query}`;
+          switch (import_path.default.extname(parsed.pathname)) {
+            case ".md":
+            default:
+              parent == null ? void 0 : parent.children.splice(idx, 1, {
+                type: "element",
+                tagName: "React.Fragment",
+                children: [],
+                properties: {},
+                position: node.position,
+                JSXAttributes: [
+                  {
+                    type: "JSXAttribute",
+                    name: "children",
+                    value: `require('${moduleReqPath}').default()`
+                  }
+                ]
+              });
+          }
+        }
+      }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/loaders/markdown/transformer/rehypeRaw.js

@@ -29,6 +29,7 @@ var raw;
 var visit;
 var COMPONENT_NAME_REGEX = /<[A-Z][a-zA-Z\d]*/g;
 var COMPONENT_STUB_ATTR = "$tag-name";
+var CODE_META_STUB_ATTR = "$code-meta";
 (async () => {
   ({ visit } = await import("unist-util-visit"));
   ({ raw } = await import("hast-util-raw"));
@@ -36,19 +37,26 @@ var COMPONENT_STUB_ATTR = "$tag-name";
 function rehypeRaw() {
   return (tree, file) => {
     visit(tree, (node) => {
+      var _a;
       if (node.type === "raw" && COMPONENT_NAME_REGEX.test(node.value)) {
         node.value = node.value.replace(COMPONENT_NAME_REGEX, (str) => {
           const tagName = str.slice(1);
           return `${str} ${COMPONENT_STUB_ATTR}="${tagName}"`;
         });
+      } else if (node.type === "element" && ((_a = node.data) == null ? void 0 : _a.meta)) {
+        node.properties ?? (node.properties = {});
+        node.properties[CODE_META_STUB_ATTR] = node.data.meta;
       }
     });
     const newTree = raw(tree, file);
     visit(newTree, "element", (node) => {
-      var _a;
+      var _a, _b;
       if ((_a = node.properties) == null ? void 0 : _a[COMPONENT_STUB_ATTR]) {
         node.tagName = node.properties[COMPONENT_STUB_ATTR];
         delete node.properties[COMPONENT_STUB_ATTR];
+      } else if ((_b = node.properties) == null ? void 0 : _b[CODE_META_STUB_ATTR]) {
+        node.data = { meta: node.properties[CODE_META_STUB_ATTR] };
+        delete node.properties[CODE_META_STUB_ATTR];
       }
     });
     return newTree;

package/dist/loaders/markdown/transformer/remarkMeta.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'remark-frontmatter';
+import type { Transformer } from 'unified';
+export default function remarkMeta(): Transformer<Root>;

package/dist/loaders/markdown/transformer/remarkMeta.js

@@ -0,0 +1,44 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loaders/markdown/transformer/remarkMeta.ts
+var remarkMeta_exports = {};
+__export(remarkMeta_exports, {
+  default: () => remarkMeta
+});
+module.exports = __toCommonJS(remarkMeta_exports);
+var import_js_yaml = __toESM(require("js-yaml"));
+var visit;
+(async () => {
+  ({ visit } = await import("unist-util-visit"));
+})();
+function remarkMeta() {
+  return (tree, file) => {
+    visit(tree, "yaml", (node) => {
+      try {
+        file.data.frontmatter = import_js_yaml.default.load(node.value);
+      } catch {
+      }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/preset.js

@@ -31,8 +31,10 @@ var preset_default = (api) => {
     plugins: [
       require.resolve("./registerMethods"),
       require.resolve("./features/configPlugins"),
+      require.resolve("./features/sideEffects"),
       require.resolve("./features/compile"),
       require.resolve("./features/routes"),
+      require.resolve("./features/meta"),
       require.resolve("./features/theme"),
       require.resolve("./features/locales")
     ]

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { IDumiDemoProps, ILocalesConfig } from "./client/theme-api";
 import type { IThemeLoadResult } from "./features/theme/loader";
 import type { IModify } from '@umijs/core';
 import type { ExampleBlockAsset } from 'dumi-assets-types';
@@ -11,12 +12,14 @@ export interface IDumiConfig extends IUmiConfig {
             type: string;
             dir: string;
         }[];
+        codeBlockMode: 'active' | 'passive';
     };
-    locales: {
-        id: string;
-        name: string;
-        base?: string;
-    }[];
+    locales: ILocalesConfig;
+    /**
+     * extra unified plugins
+     */
+    extraRemarkPlugins?: (string | Function | [string | Function, object])[];
+    extraRehypePlugins?: (string | Function | [string | Function, object])[];
 }
 export declare abstract class IDumiTechStack {
     /**
@@ -41,7 +44,12 @@ export declare abstract class IDumiTechStack {
     /**
      * generator for return previewer props
      */
-    abstract generatePreviewerProps?(): Record<string, any>;
+    abstract generatePreviewerProps?(props: IDumiDemoProps['previewerProps'], opts: {
+        type: Parameters<IDumiTechStack['transformCode']>[1]['type'];
+        mdAbsPath: string;
+        fileAbsPath?: string;
+        entryPointCode?: string;
+    }): Promise<IDumiDemoProps['previewerProps']> | IDumiDemoProps['previewerProps'];
 }
 export declare type IApi = IUmiApi & {
     config: IDumiConfig;

package/dist/utils.d.ts

@@ -2,3 +2,14 @@
  * get route path from file-system path
  */
 export declare function getRoutePathFromFsPath(fsPath: string): string;
+/**
+ * get range lines of markdown file
+ */
+export declare const getFileRangeLines: (content: string, range: string) => string;
+/**
+ * get file content by regular expression
+ * @param content   source file content
+ * @param regexp    regular expression string
+ * @param filePath  source file path
+ */
+export declare const getFileContentByRegExp: (content: string, regexp: string, filePath: string) => string;