dumi 2.4.35 → 2.4.37

package/dist/assetParsers/block.d.ts

@@ -13,7 +13,7 @@ export interface IParsedBlockAsset {
     resolveMap: Record<string, string>;
     frontmatter: ReturnType<typeof parseCodeFrontmatter>['frontmatter'];
 }
-declare function parseBlockAsset(opts: {
+interface IParseBlockAssetOptions {
     fileAbsPath: string;
     fileLocale?: string;
     id: string;
@@ -21,5 +21,7 @@ declare function parseBlockAsset(opts: {
     entryPointCode?: string;
     resolver: typeof sync;
     techStack: IDumiTechStack;
-}): Promise<IParsedBlockAsset>;
+    cacheable?: boolean;
+}
+declare function parseBlockAsset(opts: IParseBlockAssetOptions): Promise<IParsedBlockAsset>;
 export default parseBlockAsset;

package/dist/assetParsers/block.js

@@ -39,7 +39,71 @@ var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_plugin_utils = require("umi/plugin-utils");
 var import_constants = require("../constants");
+var MAX_BLOCK_ASSET_CACHE_SIZE = 512;
+var blockAssetCache = /* @__PURE__ */ new Map();
+function cloneParsedBlockAsset(ret) {
+  return {
+    asset: JSON.parse(JSON.stringify(ret.asset)),
+    resolveMap: { ...ret.resolveMap },
+    frontmatter: ret.frontmatter ? JSON.parse(JSON.stringify(ret.frontmatter)) : ret.frontmatter
+  };
+}
+function getContentHashFromFile(file) {
+  try {
+    return (0, import_utils.getContentHash)(import_fs.default.readFileSync(file, "utf-8"));
+  } catch {
+    return "missing";
+  }
+}
+function getDepsKey(deps) {
+  return JSON.stringify(
+    Array.from(new Set(deps)).sort().map((file) => `${(0, import_plugin_utils.winPath)(file)}:${getContentHashFromFile(file)}`)
+  );
+}
+function getParseCacheKey(opts) {
+  const entryContent = opts.entryPointCode ?? import_fs.default.readFileSync(opts.fileAbsPath, "utf-8");
+  return JSON.stringify({
+    file: (0, import_plugin_utils.winPath)(opts.fileAbsPath),
+    fileLocale: opts.fileLocale,
+    id: opts.id,
+    refAtomIds: opts.refAtomIds,
+    entryHash: (0, import_utils.getContentHash)(entryContent),
+    techStack: opts.techStack.name,
+    runtimeOpts: opts.techStack.runtimeOpts,
+    hasOnBlockLoad: Boolean(opts.techStack.onBlockLoad),
+    hasGenerateMetadata: Boolean(opts.techStack.generateMetadata),
+    hasGenerateSources: Boolean(opts.techStack.generateSources)
+  });
+}
+function getParseDeps(ret, entryFile) {
+  return Object.values(ret.resolveMap).filter(
+    (file) => import_path.default.isAbsolute(file) && file !== entryFile
+  );
+}
+function getCachedBlockAsset(cacheKey) {
+  const cached = blockAssetCache.get(cacheKey);
+  if (cached && cached.depsKey === getDepsKey(cached.deps)) {
+    return cloneParsedBlockAsset(cached.result);
+  }
+}
+function setCachedBlockAsset(cacheKey, ret, deps) {
+  if (blockAssetCache.size >= MAX_BLOCK_ASSET_CACHE_SIZE) {
+    const firstKey = blockAssetCache.keys().next().value;
+    if (firstKey)
+      blockAssetCache.delete(firstKey);
+  }
+  blockAssetCache.set(cacheKey, {
+    deps,
+    depsKey: getDepsKey(deps),
+    result: cloneParsedBlockAsset(ret)
+  });
+}
 async function parseBlockAsset(opts) {
+  const cacheKey = opts.cacheable ? getParseCacheKey(opts) : "";
+  const cached = cacheKey ? getCachedBlockAsset(cacheKey) : void 0;
+  if (cached) {
+    return cached;
+  }
   const asset = {
     type: "BLOCK",
     id: opts.id,
@@ -163,9 +227,18 @@ async function parseBlockAsset(opts) {
       }
     ]
   });
+  let hasError = false;
   try {
     await deferrer;
   } catch {
+    hasError = true;
+  }
+  if (!hasError && cacheKey) {
+    setCachedBlockAsset(
+      cacheKey,
+      result,
+      getParseDeps(result, opts.fileAbsPath)
+    );
   }
   return result;
 }

package/dist/client/pages/Demo/index.js

@@ -1,11 +1,14 @@
-import { useDemo, useLiveDemo, useParams } from 'dumi';
+import { useDemo, useLiveDemo, useLocation, useParams } from 'dumi';
 import { createElement, useEffect } from 'react';
 import { useRenderer } from "../../theme-api/useRenderer";
 import "./index.less";
 var DemoRenderPage = function DemoRenderPage() {
   var params = useParams();
+  var _useLocation = useLocation(),
+    search = _useLocation.search;
   var id = params.id;
-  var demo = useDemo(id);
+  var routeId = new URLSearchParams(search).get('routeId') || undefined;
+  var demo = useDemo(id, undefined, undefined, routeId);
   var _useRenderer = useRenderer({
       id: id,
       component: demo.component,

package/dist/client/theme-api/DumiDemo/index.d.ts

@@ -1,10 +1,16 @@
 import { type FC } from 'react';
-import type { IPreviewerProps } from '../types';
+import type { IDemoData, IPreviewerProps } from '../types';
+type DemoGetter = () => Promise<{
+    demos: Record<string, IDemoData>;
+}>;
 export interface IDumiDemoProps {
     demo: {
         id: string;
         inline?: boolean;
+        loader?: DemoGetter;
+        version?: string;
     };
     previewerProps: Omit<IPreviewerProps, 'asset' | 'children'>;
 }
 export declare const DumiDemo: FC<IDumiDemoProps>;
+export {};

package/dist/client/theme-api/DumiDemo/index.js

@@ -10,8 +10,11 @@ var InternalDumiDemo = function InternalDumiDemo(props) {
     historyType = _useSiteData.historyType;
   var _useAppData = useAppData(),
     basename = _useAppData.basename;
-  var id = props.demo.id;
-  var demo = useDemo(id);
+  var _props$demo = props.demo,
+    id = _props$demo.id,
+    loader = _props$demo.loader,
+    version = _props$demo.version;
+  var demo = useDemo(id, loader, version);
   var component = demo.component,
     asset = demo.asset,
     renderOpts = demo.renderOpts;
@@ -31,12 +34,13 @@ var InternalDumiDemo = function InternalDumiDemo(props) {
     return demoNode;
   }
   var isHashRoute = historyType === 'hash';
+  var routeQuery = demo.routeId ? "?routeId=".concat(encodeURIComponent(demo.routeId)) : '';
   return /*#__PURE__*/React.createElement(Previewer, _extends({
     asset: asset,
     demoUrl:
     // allow user override demoUrl by frontmatter
     props.previewerProps.demoUrl || // when use hash route, browser can automatically handle relative paths starting with #
-    "".concat(isHashRoute ? "#" : '').concat(basename).concat(SP_ROUTE_PREFIX, "demos/").concat(props.demo.id)
+    "".concat(isHashRoute ? "#" : '').concat(basename).concat(SP_ROUTE_PREFIX, "demos/").concat(props.demo.id).concat(routeQuery)
   }, props.previewerProps), props.previewerProps.iframe ? null : demoNode);
 };
 export var DumiDemo = /*#__PURE__*/React.memo(InternalDumiDemo, function (prev, next) {

package/dist/features/meta.d.ts

@@ -1,5 +1,6 @@
 import type { IApi } from '../types';
 export declare const TABS_META_PATH = "dumi/meta/tabs.ts";
 export declare const ATOMS_META_PATH = "dumi/meta/atoms.ts";
+export declare const DEMO_INDEX_META_PATH = "dumi/meta/demoIndex.ts";
 export default _default;
 declare function _default(api: IApi): void;

package/dist/features/meta.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var meta_exports = {};
 __export(meta_exports, {
   ATOMS_META_PATH: () => ATOMS_META_PATH,
+  DEMO_INDEX_META_PATH: () => DEMO_INDEX_META_PATH,
   TABS_META_PATH: () => TABS_META_PATH,
   default: () => meta_default
 });
@@ -40,6 +41,7 @@ var import_plugin_utils = require("umi/plugin-utils");
 var import_tabs = require("./tabs");
 var TABS_META_PATH = "dumi/meta/tabs.ts";
 var ATOMS_META_PATH = "dumi/meta/atoms.ts";
+var DEMO_INDEX_META_PATH = "dumi/meta/demoIndex.ts";
 var meta_default = (api) => {
   const metaFiles = [];
   api.register({
@@ -71,8 +73,11 @@ var meta_default = (api) => {
       key: "dumi.modifyMetaFiles",
       initialValue: JSON.parse(JSON.stringify(metaFiles))
     });
+    const useUtoopackDemoHMR = api.env === "development" && Boolean(api.config.utoopack);
     parsedMetaFiles.forEach((metaFile) => {
       metaFile.isMarkdown = metaFile.file.endsWith(".md");
+      metaFile.loadDemoIndex = metaFile.isMarkdown && !useUtoopackDemoHMR;
+      metaFile.loadDemoIndexMap = metaFile.isMarkdown && useUtoopackDemoHMR;
     });
     api.writeTmpFile({
       noPluginDir: true,
@@ -93,6 +98,14 @@ var meta_default = (api) => {
         }
       }
     });
+    api.writeTmpFile({
+      noPluginDir: true,
+      path: DEMO_INDEX_META_PATH,
+      tplPath: require.resolve("../templates/meta/demoIndex.ts.tpl"),
+      context: {
+        metaFiles: parsedMetaFiles
+      }
+    });
     api.writeTmpFile({
       noPluginDir: true,
       path: "dumi/meta/runtime.ts",
@@ -118,5 +131,6 @@ var meta_default = (api) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ATOMS_META_PATH,
+  DEMO_INDEX_META_PATH,
   TABS_META_PATH
 });

package/dist/loaders/markdown/index.js

@@ -53,6 +53,17 @@ function getDemoSourceFiles(demos = []) {
 function isRelativePath(path2) {
   return /^\.{1,2}(?!\w)/.test(path2);
 }
+function normalizeRouteFile(file) {
+  return (0, import_plugin_utils.winPath)(file).replace(/\.(mdx?)\.js$/, ".$1");
+}
+function getRouteId(opts, fileAbsPath) {
+  const normalizedFile = normalizeRouteFile(fileAbsPath);
+  const route = Object.values(opts.routes ?? {}).find((item) => {
+    const routeFile = item.file || item.__absFile;
+    return routeFile && normalizeRouteFile(routeFile) === normalizedFile;
+  });
+  return route == null ? void 0 : route.id;
+}
 function emitDefault(opts, ret) {
   const { frontmatter, demos } = ret.meta;
   const isTabContent = (0, import_tabs.isTabRouteFile)(this.resourcePath);
@@ -133,6 +144,7 @@ function emitDemo(opts, ret) {
       }).filter((item) => item !== void 0)
     );
   }, []);
+  const routeId = getRouteId(opts, this.resourcePath);
   return import_plugin_utils.Mustache.render(
     `import React from 'react';
 import '${(0, import_plugin_utils.winPath)(this.resourcePath)}?watch=parent';
@@ -146,6 +158,9 @@ export const demos = {
     component: {{{component}}},
     {{/component}}
     asset: {{{renderAsset}}},
+    {{#routeId}}
+    routeId: '{{{routeId}}}',
+    {{/routeId}}
     context: {{{renderContext}}},
     renderOpts: {{{renderRenderOpts}}},
   },
@@ -154,6 +169,7 @@ export const demos = {
     {
       demos,
       dedupedDemosDeps,
+      routeId,
       renderAsset: function renderAsset() {
         if (!("asset" in this))
           return "null";
@@ -291,7 +307,9 @@ function emitText(opts, ret) {
 function emit(opts, ret) {
   const { demos, embeds } = ret.meta;
   embeds.forEach((file) => this.addDependency(file));
-  getDemoSourceFiles(demos).forEach((file) => this.addDependency(file));
+  if (opts.mode !== "demo-index") {
+    getDemoSourceFiles(demos).forEach((file) => this.addDependency(file));
+  }
   if (this.resourceQuery.includes("watch=parent"))
     return null;
   switch (opts.mode) {
@@ -320,6 +338,7 @@ function mdLoader(content) {
   var _a, _b, _c;
   let opts = this.getOptions();
   const loaderContextPath = opts[import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY];
+  const useUtoopackDemoHMR = process.env.NODE_ENV !== "production" && Boolean(loaderContextPath);
   if (loaderContextPath) {
     const ctx = require(loaderContextPath);
     if (!((_a = opts.techStacks) == null ? void 0 : _a.length)) {
@@ -346,6 +365,7 @@ function mdLoader(content) {
   const baseCacheKey = [
     this.resourcePath,
     (0, import_utils.getContentHash)(content),
+    useUtoopackDemoHMR,
     JSON.stringify(import_plugin_utils.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]))
   ].join(":");
   const cacheKey = [
@@ -364,7 +384,8 @@ function mdLoader(content) {
   }
   deferrer[cacheKey] = (0, import_transformer.default)(content, {
     ...import_plugin_utils.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]),
-    fileAbsPath: (0, import_plugin_utils.winPath)(this.resourcePath)
+    fileAbsPath: (0, import_plugin_utils.winPath)(this.resourcePath),
+    useUtoopackDemoHMR
   });
   deferrer[cacheKey].then((ret) => {
     depsMapping[this.resourcePath] = ret.meta.embeds.concat(

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

@@ -48,6 +48,7 @@ declare module 'vfile' {
 export interface IMdTransformerOptions {
     cwd: string;
     fileAbsPath: string;
+    useUtoopackDemoHMR?: boolean;
     alias: ResolveOptions['alias'];
     parentAbsPath?: string;
     techStacks: IDumiTechStack[];

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

@@ -113,6 +113,7 @@ var transformer_default = async (raw, opts) => {
     fileAbsPath: opts.fileAbsPath,
     fileLocaleLessPath,
     fileLocale,
+    useUtoopackDemoHMR: opts.useUtoopackDemoHMR,
     resolve: opts.resolve,
     resolver
   }).use(import_rehypeSlug.default).use(import_rehypeLink.default, {

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

@@ -10,6 +10,7 @@ type IRehypeDemoOptions = Pick<IMdTransformerOptions, 'techStacks' | 'cwd' | 'fi
     resolver: typeof sync;
     fileLocaleLessPath: string;
     fileLocale?: string;
+    useUtoopackDemoHMR?: boolean;
 };
 export default function rehypeDemo(opts: IRehypeDemoOptions): Transformer<Root>;
 export {};

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

@@ -47,6 +47,8 @@ var toString;
 var isElement;
 var DEMO_NODE_CONTAINER = "$demo-container";
 var DEMO_PROP_VALUE_KEY = "$demo-prop-value-key";
+var DEMO_LOADER_PLACEHOLDER = "__DUMI_DEMO_LOADER__";
+var DEMO_LOADER_PLACEHOLDER_VALUE = DEMO_LOADER_PLACEHOLDER;
 var DUMI_DEMO_TAG = "DumiDemo";
 var DUMI_DEMO_GRID_TAG = "DumiDemoGrid";
 var SKIP_DEMO_PARSE = "pure";
@@ -249,9 +251,15 @@ function rehypeDemo(opts) {
               });
             }
             const propDemo = { id: parseOpts.id };
+            if (opts.useUtoopackDemoHMR) {
+              propDemo.loader = DEMO_LOADER_PLACEHOLDER_VALUE;
+            }
             demoIds.push(parseOpts.id);
             deferrers.push(
-              (0, import_block.default)(parseOpts).then(
+              (0, import_block.default)({
+                ...parseOpts,
+                cacheable: opts.useUtoopackDemoHMR
+              }).then(
                 async ({ asset, resolveMap, frontmatter }) => {
                   var _a2, _b2, _c2;
                   if (demoIds.indexOf(parseOpts.id) !== demoIds.lastIndexOf(parseOpts.id)) {
@@ -287,6 +295,11 @@ function rehypeDemo(opts) {
                     if (originalProps[key])
                       asset[key] = originalProps[key];
                   });
+                  if (opts.useUtoopackDemoHMR) {
+                    propDemo.version = (0, import_utils.getContentHash)(
+                      JSON.stringify(asset.dependencies)
+                    );
+                  }
                   if (/ inline/.test(String((_b2 = codeNode.data) == null ? void 0 : _b2.meta)) || originalProps.inline) {
                     propDemo.inline = true;
                     return {
@@ -368,7 +381,16 @@ function rehypeDemo(opts) {
     await Promise.all(deferrers).then((demos) => {
       vFile.data.demos = demos;
       replaceNodes.forEach((node) => {
-        const value = JSON.stringify(node.data[DEMO_PROP_VALUE_KEY]);
+        const demoLoader = `() => import('${(0, import_plugin_utils.winPath)(
+          opts.fileAbsPath
+        )}?type=demo')`;
+        let value = JSON.stringify(node.data[DEMO_PROP_VALUE_KEY]);
+        if (opts.useUtoopackDemoHMR) {
+          value = value.replace(
+            new RegExp(`"${DEMO_LOADER_PLACEHOLDER}"`, "g"),
+            demoLoader
+          );
+        }
         if (node.JSXAttributes[0].type === "JSXAttribute") {
           node.JSXAttributes[0].value = value;
         } else {

package/dist/templates/meta/demoIndex.ts.tpl

@@ -0,0 +1,10 @@
+export const demoIndexMap = {
+  {{#metaFiles}}
+  {{#loadDemoIndexMap}}
+  '{{{id}}}': () =>
+    import('{{{file}}}?type=demo-index').then(
+      ({ demoIndex }) => demoIndex,
+    ),
+  {{/loadDemoIndexMap}}
+  {{/metaFiles}}
+};

package/dist/templates/meta/exports.ts.tpl

@@ -34,19 +34,53 @@ export function use<T>(promise: ReactPromise<T>): T {
   }
 }
 
-const demoIdMap = Object.keys(filesMeta).reduce((total, current) => {
-  if (filesMeta[current].demoIndex) {
-    const { ids, getter } = filesMeta[current].demoIndex;
+type DemoGetter = () => Promise<{ demos: Record<string, IDemoData> }>;
+type DemoIndex = {
+  ids: string[];
+  getter: DemoGetter;
+};
+type DemoIndexGetter = () => Promise<DemoIndex>;
 
-    ids.forEach((id) => {
-      total[id] = getter;
-    });
-  }
+const demoIndexes = Object.entries(filesMeta)
+  .map(([id, meta]) => ({
+    id,
+    demoIndex: meta.demoIndex,
+  }))
+  .filter(
+    (item): item is { id: string; demoIndex: DemoIndex } =>
+      Boolean(item.demoIndex),
+  );
+
+const demoIdMap = demoIndexes.reduce<Record<string, DemoGetter>>(
+  (total, { demoIndex }) => {
+    if (demoIndex) {
+      const { ids, getter } = demoIndex;
+
+      ids.forEach((id) => {
+        total[id] = getter;
+      });
+    }
 
-  return total;
-}, {});
+    return total;
+  },
+  {},
+);
 
 const demosCache = new Map<string, Promise<IDemoData | undefined>>();
+let demoIndexMapPromise:
+  | Promise<Record<string, DemoIndexGetter | undefined>>
+  | undefined;
+
+function loadDemoIndexMap() {
+  if (!demoIndexMapPromise) {
+    demoIndexMapPromise = import('./demoIndex').then(
+      ({ demoIndexMap }) =>
+        demoIndexMap as Record<string, DemoIndexGetter | undefined>,
+    );
+  }
+
+  return demoIndexMapPromise;
+}
 
 /**
  * expand context for source omit extension
@@ -65,36 +99,128 @@ function expandDemoContext(context?: IDemoData['context']) {
   }
 }
 
+function getDemoIdCandidates(id: string) {
+  const ids = [id];
+  const localeLessId = id.replace(/-[a-z]{2}(?:-[A-Z]{2})?$/, '');
+
+  if (localeLessId !== id) {
+    ids.push(localeLessId);
+  }
+
+  return ids;
+}
+
+async function getDemoFromDemoIndex(
+  id: string,
+  demoIndexGetter: DemoIndexGetter,
+) {
+  const demoIndex = await demoIndexGetter();
+  const demoId = getDemoIdCandidates(id).find((candidate) =>
+    demoIndex.ids.includes(candidate),
+  );
+  const getter = demoId ? demoIndex.getter : undefined;
+
+  if (!getter) return undefined;
+
+  demoIdMap[id] = getter;
+  const { demos } = await getter();
+  const demo = demos[id] ?? demos[demoId!];
+
+  if (!demo) return undefined;
+
+  expandDemoContext(demo.context);
+  return demo;
+}
+
+async function getDemoFromRouteIndex(id: string, routeId: string) {
+  const demoIndexMap = await loadDemoIndexMap();
+  const demoIndexGetter = demoIndexMap[routeId];
+
+  if (!demoIndexGetter) return getDemoFromIndexMap(id);
+
+  return (
+    (await getDemoFromDemoIndex(id, demoIndexGetter)) ??
+    getDemoFromIndexMap(id)
+  );
+}
+
+async function getDemoFromIndexMap(id: string) {
+  const demoIndexMap = await loadDemoIndexMap();
+  const demoIndexGetters = Object.values(demoIndexMap).filter(
+    (item): item is DemoIndexGetter => Boolean(item),
+  );
+
+  for (const demoIndexGetter of demoIndexGetters) {
+    const demo = await getDemoFromDemoIndex(id, demoIndexGetter).catch(
+      () => undefined,
+    );
+    if (demo) return demo;
+  }
+}
+
 /**
  * use demo data by id
  */
-export function useDemo(id: string): IDemoData | undefined {
-  if (!demosCache.get(id)) {
+export function useDemo(
+  id: string,
+  loader?: DemoGetter,
+  version?: string,
+  routeId?: string,
+): IDemoData | undefined {
+  const cacheKey = version
+    ? `${id}:${version}`
+    : routeId
+      ? `${id}:route=${routeId}`
+      : id;
+  const getter = loader ?? demoIdMap[id];
+
+  if (!demosCache.get(cacheKey)) {
     demosCache.set(
-      id,
-      demoIdMap[id]?.().then(({ demos }) => {
-        // expand context for omit ext
-        expandDemoContext(demos[id].context);
-        return demos[id];
-      }),
+      cacheKey,
+      getter
+        ? getter().then(({ demos }) => {
+            const demo = demos[id];
+            if (!demo) return undefined;
+
+            // expand context for omit ext
+            expandDemoContext(demo.context);
+            return demo;
+          })
+        : routeId
+          ? getDemoFromRouteIndex(id, routeId)
+          : getDemoFromIndexMap(id),
     );
+
+    // Reuse local demo data for consumers that still call useDemo(id), such as useLiveDemo.
+    demosCache.set(id, demosCache.get(cacheKey)!);
   }
 
-  return use(demosCache.get(id)!);
+  return use(demosCache.get(cacheKey)!);
 }
 
 /**
  * get all demos
  */
 export async function getFullDemos() {
-  const demoFilesMeta = Object.entries(filesMeta).filter(
-    ([_id, meta]) => meta.demoIndex,
+  const demoIndexMap = await loadDemoIndexMap();
+  const lazyDemoIndexes = await Promise.all(
+    Object.entries(demoIndexMap).map(async ([id, demoIndexGetter]) => ({
+      id,
+      demoIndex: await demoIndexGetter?.().catch(() => undefined),
+    })),
+  );
+  const allDemoIndexes = [
+    ...demoIndexes,
+    ...lazyDemoIndexes,
+  ].filter(
+    (item): item is { id: string; demoIndex: DemoIndex } =>
+      Boolean(item.demoIndex),
   );
 
   return Promise.all(
-    demoFilesMeta.map(async ([id, meta]) => ({
+    allDemoIndexes.map(async ({ id, demoIndex }) => ({
       id,
-      demos: (await meta.demoIndex.getter()).demos as Record<string, IDemoData>,
+      demos: (await demoIndex.getter()).demos as Record<string, IDemoData>,
     })),
   ).then((ret) =>
     ret.reduce<Record<string, IDemoData>>((total, { id, demos }) => {

package/dist/templates/meta/index.ts.tpl

@@ -1,10 +1,10 @@
 {{#metaFiles}}
-{{#isMarkdown}}
+{{#loadDemoIndex}}
 import { frontmatter as fm{{{index}}}, toc as t{{{index}}}, demoIndex as dmi{{{index}}} } from '{{{file}}}?type=frontmatter';
-{{/isMarkdown}}
-{{^isMarkdown}}
+{{/loadDemoIndex}}
+{{^loadDemoIndex}}
 import { frontmatter as fm{{{index}}}, toc as t{{{index}}} } from '{{{file}}}?type=frontmatter';
-{{/isMarkdown}}
+{{/loadDemoIndex}}
 {{/metaFiles}}
 
 export const filesMeta = {
@@ -12,9 +12,9 @@ export const filesMeta = {
   '{{{id}}}': {
     frontmatter: fm{{{index}}},
     toc: t{{{index}}},
-    {{#isMarkdown}}
+    {{#loadDemoIndex}}
     demoIndex: dmi{{{index}}},
-    {{/isMarkdown}}
+    {{/loadDemoIndex}}
     {{#tabs}}
     tabs: {{{tabs}}},
     {{/tabs}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dumi",
-  "version": "2.4.35",
+  "version": "2.4.37",
   "description": "📖 Documentation Generator of React Component",
   "keywords": [
     "generator",