dumi 1.1.45 → 2.0.0-alpha.0

package/dist/features/theme/index.js

@@ -0,0 +1,143 @@
+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/features/theme/index.ts
+var theme_exports = {};
+__export(theme_exports, {
+  default: () => theme_default
+});
+module.exports = __toCommonJS(theme_exports);
+var import_constants = require("../../constants");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_plugin_utils = require("umi/plugin-utils");
+var import_loader = __toESM(require("./loader"));
+var DEFAULT_THEME_PATH = import_path.default.join(__dirname, "../../../theme-default");
+function getPkgThemePath(api) {
+  const validDeps = Object.assign({}, api.pkg.dependencies, api.pkg.devDependencies);
+  const pkgThemeName = Object.keys(validDeps).find((pkg) => pkg.split("/").pop().startsWith(import_constants.THEME_PREFIX));
+  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 themeMapKeys = [
+    "layouts",
+    "builtins",
+    "slots"
+  ];
+  api.describe({ key: "dumi:theme" });
+  api.register({
+    key: "modifyAppData",
+    before: "appData",
+    async fn(memo) {
+      const defaultThemeData = (0, import_loader.default)(DEFAULT_THEME_PATH);
+      const pkgThemePath = getPkgThemePath(api);
+      const pkgThemeData = (0, import_plugin_utils.deepmerge)(defaultThemeData, pkgThemePath ? (0, import_loader.default)(pkgThemePath) : {});
+      originalThemeData = await api.applyPlugins({
+        key: "modifyTheme",
+        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);
+        api.service.themeData = (0, import_plugin_utils.deepmerge)(originalThemeData, localThemeData, {
+          clone: true
+        });
+      }
+      Object.assign(api.service.themeData.builtins, {
+        DumiDemo: {
+          specifier: "{ DumiDemo }",
+          source: "dumi/theme"
+        }
+      });
+      return memo;
+    }
+  });
+  api.modifyConfig((memo) => {
+    memo.alias["dumi/theme$"] = require.resolve("../../client/theme");
+    if (localThemeData) {
+      themeMapKeys.forEach((key) => {
+        Object.values(localThemeData[key] || {}).forEach((item) => {
+          memo.alias[`dumi/theme/${key}/${item.specifier}`] = item.source;
+        });
+      });
+    }
+    memo.alias["dumi/theme"] = "dumi/theme-original";
+    memo.alias["dumi/theme-original"] = import_path.default.join(api.paths.absTmpPath, "dumi/theme");
+    memo.alias["dumi/theme-default"] = DEFAULT_THEME_PATH;
+    memo.extraBabelIncludes ?? (memo.extraBabelIncludes = []);
+    memo.extraBabelIncludes.push(import_path.default.resolve(__dirname, "../../client/theme"));
+    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) => {
+        api.writeTmpFile({
+          noPluginDir: true,
+          path: `dumi/theme/${key}/${item.specifier}.ts`,
+          content: `export * from '${item.source}';
+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';
+
+export default function DumiContextWrapper() {
+  const outlet = useOutlet();
+
+  return (
+    <Context.Provider value={{ demos }}>{outlet}</Context.Provider>
+  );
+}`
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/features/theme/loader.d.ts

@@ -0,0 +1,51 @@
+export interface IThemeComponent {
+    specifier: string;
+    source: string;
+}
+export interface IThemeLoadResult {
+    /**
+     * theme package name
+     */
+    name: string;
+    /**
+     * theme package path
+     */
+    path: string;
+    /**
+     * locale text data
+     */
+    locales: {
+        [key: string]: Record<string, string>;
+    };
+    /**
+     * builtin components
+     */
+    builtins: {
+        [key: string]: IThemeComponent;
+    };
+    /**
+     * slots components
+     */
+    slots: {
+        [key: string]: IThemeComponent;
+    };
+    /**
+     * layout components
+     */
+    layouts: {
+        /**
+         * apply for all routes
+         */
+        GlobalLayout?: IThemeComponent;
+        /**
+         * apply for doc routes
+         */
+        DocLayout?: IThemeComponent;
+        /**
+         * apply for demo routes /~demos/:id
+         */
+        DemoLayout?: IThemeComponent;
+    } & Record<string, IThemeComponent>;
+}
+declare const _default: (dir: string) => IThemeLoadResult;
+export default _default;

package/dist/features/theme/loader.js

@@ -0,0 +1,58 @@
+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/features/theme/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => loader_default
+});
+module.exports = __toCommonJS(loader_exports);
+var import_path = __toESM(require("path"));
+var import_plugin_utils = require("umi/plugin-utils");
+function getComponentMapFromDir(globExp, dir) {
+  return import_plugin_utils.glob.sync(globExp, { cwd: dir }).reduce((ret, file) => {
+    const specifier = import_path.default.basename(file.replace(/(\/index)?\.[a-z]+$/, ""));
+    ret[specifier] = {
+      specifier,
+      source: (0, import_plugin_utils.winPath)(import_path.default.join(dir, file))
+    };
+    return ret;
+  }, {});
+}
+function getLocaleMapFromDir(globExp, dir) {
+  return import_plugin_utils.glob.sync(globExp, { cwd: dir }).reduce((ret, file) => {
+    const locale = file.replace(/\.json$/, "");
+    ret[locale] = require(import_path.default.join(dir, file));
+    return ret;
+  }, {});
+}
+var loader_default = (dir) => {
+  return {
+    name: import_path.default.basename(dir),
+    path: dir,
+    locales: getLocaleMapFromDir("locales/*.json", dir),
+    builtins: getComponentMapFromDir("builtins/{*,*/index}.{js,jsx,ts,tsx}", dir),
+    slots: getComponentMapFromDir("slots/{*,*/index}.{js,jsx,ts,tsx}", dir),
+    layouts: getComponentMapFromDir("layouts/{GlobalLayout,DocLayout,DemoLayout}{.,/index.}{js,jsx,ts,tsx}", dir)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "Hello dumi 2.0!";
+export default _default;

package/dist/index.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var src_default = "Hello dumi 2.0!";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -0,0 +1,6 @@
+import type { IDumiTechStack } from "../../types";
+export interface IDemoLoaderOptions {
+    techStacks: IDumiTechStack[];
+    cwd: string;
+}
+export default function demoLoader(this: any, raw: string): string;

package/dist/loaders/demo/index.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loaders/demo/index.ts
+var demo_exports = {};
+__export(demo_exports, {
+  default: () => demoLoader
+});
+module.exports = __toCommonJS(demo_exports);
+function demoLoader(raw) {
+  const opts = this.getOptions();
+  const techStackName = new URLSearchParams(this.resourceQuery).get("techStack");
+  const techStack = opts.techStacks.find((t) => t.name === techStackName);
+  return techStack.transformCode(raw, {
+    type: "external",
+    fileAbsPath: this.resourcePath
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -0,0 +1,12 @@
+import type { IThemeLoadResult } from "../../features/theme/loader";
+import { type IMdTransformerOptions } from './transformer';
+interface IMdLoaderDefaultModeOptions extends Omit<IMdTransformerOptions, 'fileAbsPath'> {
+    mode?: 'markdown';
+    builtins: IThemeLoadResult['builtins'];
+}
+interface IMdLoaderDemosModeOptions extends Omit<IMdLoaderDefaultModeOptions, 'builtins' | 'mode'> {
+    mode: 'demos';
+}
+export declare type IMdLoaderOptions = IMdLoaderDefaultModeOptions | IMdLoaderDemosModeOptions;
+export default function mdLoader(this: any, raw: string): void;
+export {};

package/dist/loaders/markdown/index.js

@@ -0,0 +1,60 @@
+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/index.ts
+var markdown_exports = {};
+__export(markdown_exports, {
+  default: () => mdLoader
+});
+module.exports = __toCommonJS(markdown_exports);
+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,
+    fileAbsPath: this.resourcePath
+  }).then((ret) => {
+    if (opts.mode === "demos") {
+      cb(null, import_plugin_utils.Mustache.render(`import React from 'react';
+
+export default {
+  {{#demos}}
+  '{{{id}}}': {{{component}}},
+  {{/demos}}
+}`, { demos: ret.meta.demos }));
+    } else {
+      cb(null, `${Object.values(opts.builtins).map((item) => `import ${item.specifier} from '${item.source}';`).join("\n")}
+
+// 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
+function DumiMarkdownContent() {
+  return ${ret.content};
+}
+
+export default DumiMarkdownContent;`);
+    }
+  }, cb);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -0,0 +1,37 @@
+import type { IDumiTechStack } from "../../../types";
+declare module 'hast' {
+    interface Element {
+        JSXAttributes?: Array<{
+            type: 'JSXAttribute';
+            name: string;
+            value: string;
+        } | {
+            type: 'JSXSpreadAttribute';
+            argument: string;
+        }>;
+    }
+}
+export interface IMdTransformerOptions {
+    cwd: string;
+    fileAbsPath: string;
+    techStacks: IDumiTechStack[];
+}
+export interface IMdTransformerResult {
+    content: string;
+    meta: {
+        demos: {
+            id: string;
+            component: string;
+        }[];
+    };
+}
+declare const _default: (raw: string, opts: IMdTransformerOptions) => Promise<{
+    content: string;
+    meta: {
+        demos: {
+            id: string;
+            component: string;
+        }[];
+    };
+}>;
+export default _default;

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

@@ -0,0 +1,49 @@
+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/index.ts
+var transformer_exports = {};
+__export(transformer_exports, {
+  default: () => transformer_default
+});
+module.exports = __toCommonJS(transformer_exports);
+var import_rehypeDemo = __toESM(require("./rehypeDemo"));
+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 transformer_default = async (raw, opts) => {
+  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 result = await unified().use(remarkParse).use(remarkGfm).use(remarkRehype, { allowDangerousHtml: true }).use(import_rehypeRaw.default).use(import_rehypeStrip.default).use(import_rehypeDemo.default, {
+    techStacks: opts.techStacks,
+    cwd: opts.cwd,
+    fileAbsPath: opts.fileAbsPath
+  }).use(import_rehypeIsolation.default).use(import_rehypeJsxify.default).process(raw);
+  return {
+    content: String(result.value),
+    meta: result.data
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

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

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

@@ -0,0 +1,91 @@
+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/rehypeDemo.ts
+var rehypeDemo_exports = {};
+__export(rehypeDemo_exports, {
+  default: () => rehypeDemo
+});
+module.exports = __toCommonJS(rehypeDemo_exports);
+var import_utils = require("../../../utils");
+var import_path = __toESM(require("path"));
+var import_plugin_utils = require("umi/plugin-utils");
+var visit;
+var SKIP;
+var toString;
+(async () => {
+  ({ visit, SKIP } = await import("unist-util-visit"));
+  ({ toString } = await import("mdast-util-to-string"));
+})();
+function getCodeLang(node) {
+  var _a, _b;
+  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)) {
+    lang = String(node.properties.className[0]).replace("language-", "");
+  }
+  return lang;
+}
+function getCodeId(cwd, fileAbsPath, codeIndex, entityName) {
+  const prefix = entityName || (0, import_utils.getRoutePathFromFsPath)(import_path.default.relative(cwd, fileAbsPath)).replace(/\//g, "-");
+  return [prefix, "demo", String(codeIndex)].filter(Boolean).join("-");
+}
+function rehypeDemo(opts) {
+  return (tree, vFile) => {
+    let index = 0;
+    const demos = [];
+    visit(tree, "element", (node) => {
+      var _a;
+      if (["pre", "p"].includes(node.tagName) && node.children.length === 1 && node.children[0].type === "element" && node.children[0].tagName === "code") {
+        const codeNode = node.children[0];
+        const techStack = opts.techStacks.find((ts) => ts.isSupported(codeNode, getCodeLang(codeNode)));
+        const hasSrc = typeof ((_a = codeNode.properties) == null ? void 0 : _a.src) === "string";
+        const codeValue = toString(codeNode.children).trim();
+        if (techStack && (hasSrc || codeValue)) {
+          const codeId = getCodeId(opts.cwd, opts.fileAbsPath, index++);
+          if (hasSrc) {
+            const codeAbsPath = import_path.default.resolve(import_path.default.dirname(opts.fileAbsPath), codeNode.properties.src);
+            demos.push({
+              id: codeId,
+              component: `React.lazy(() => import('${(0, import_plugin_utils.winPath)(codeAbsPath)}?techStack=${techStack.name}'))`
+            });
+          } else {
+            demos.push({
+              id: codeId,
+              component: techStack.transformCode(codeValue, {
+                type: "code-block",
+                fileAbsPath: opts.fileAbsPath
+              })
+            });
+          }
+          node.tagName = "DumiDemo";
+          node.properties = { id: codeId };
+          node.children = [];
+          return SKIP;
+        }
+      }
+    });
+    vFile.data.demos = demos;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

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

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

@@ -0,0 +1,60 @@
+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/rehypeIsolation.ts
+var rehypeIsolation_exports = {};
+__export(rehypeIsolation_exports, {
+  default: () => rehypeIsolation
+});
+module.exports = __toCommonJS(rehypeIsolation_exports);
+var visit;
+(async () => {
+  ({ visit } = await import("unist-util-visit"));
+})();
+function isDemoNode(node) {
+  return node.tagName === "DumiDemo";
+}
+function rehypeIsolation() {
+  return (tree) => {
+    visit(tree, "root", (node) => {
+      node.children = node.children.reduce((nextChildren, current) => {
+        let prevSibling = nextChildren[nextChildren.length - 1];
+        if (isDemoNode(current)) {
+          nextChildren.push(current);
+        } else {
+          if (!prevSibling || isDemoNode(prevSibling)) {
+            prevSibling = {
+              type: "element",
+              tagName: "div",
+              properties: { className: "markdown" },
+              children: []
+            };
+            nextChildren.push(prevSibling);
+          }
+          prevSibling.children.push(current);
+        }
+        return nextChildren;
+      }, []);
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -0,0 +1,2 @@
+import type { FrozenProcessor } from 'unified';
+export default function rehypeJsxify(this: FrozenProcessor): void;