dumi 2.4.48-alpha.0 → 2.4.48

package/dist/loaders/markdown/index.js

@@ -29,16 +29,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/loaders/markdown/index.ts
 var markdown_exports = {};
 __export(markdown_exports, {
-  addDemoFileDependency: () => addDemoFileDependency,
-  createDependencyReader: () => createDependencyReader,
-  createStableTransform: () => createStableTransform,
   default: () => mdLoader,
-  emitDemo: () => emitDemo,
   getDemoSourceFiles: () => getDemoSourceFiles,
-  getDepsCacheKey: () => getDepsCacheKey,
-  getMdLoaderCacheResult: () => getMdLoaderCacheResult,
-  getMdLoaderCacheSync: () => getMdLoaderCacheSync,
-  getMdTransformCacheKeys: () => getMdTransformCacheKeys
+  getMdLoaderCacheSync: () => getMdLoaderCacheSync
 });
 module.exports = __toCommonJS(markdown_exports);
 var import_utoopackLoaders = require("../../features/compile/utoopackLoaders");
@@ -47,61 +40,8 @@ var import_utils = require("../../utils");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_plugin_utils = require("umi/plugin-utils");
-var import_sharedCache = require("./sharedCache");
 var import_transformer = __toESM(require("./transformer"));
 var import_rehypeText = require("./transformer/rehypeText");
-var MD_LOADER_RUNTIME_OPTION_KEYS = [
-  "mode",
-  "builtins",
-  "onResolveDemos",
-  "onResolveAtomMeta",
-  "demoAssetsFile",
-  "cacheDirectory",
-  "cacheEpoch"
-];
-function getMdTransformCacheKeys({
-  resourcePath,
-  content,
-  useUtoopackDemoHMR,
-  opts
-}) {
-  const depsHintKey = [
-    resourcePath,
-    useUtoopackDemoHMR,
-    JSON.stringify(import_plugin_utils.lodash.omit(opts, MD_LOADER_RUNTIME_OPTION_KEYS))
-  ].join(":");
-  return {
-    depsHintKey,
-    baseCacheKey: [depsHintKey, (0, import_utils.getContentHash)(content)].join(":")
-  };
-}
-function getStatRevision(stat) {
-  return [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs].map(String).join(":");
-}
-async function getFileRevision(file) {
-  return getStatRevision(await import_fs.default.promises.stat(file, { bigint: true }));
-}
-function isMissingFsError(err) {
-  return (err == null ? void 0 : err.code) === "ENOENT" || (err == null ? void 0 : err.code) === "ENOTDIR";
-}
-async function getMissingParentRevision(file) {
-  let current = file;
-  while (true) {
-    try {
-      const revision = getStatRevision(
-        await import_fs.default.promises.stat(current, { bigint: true })
-      );
-      return `${import_path.default.normalize(current)}:${current === file ? "<appeared>:" : ""}${revision}`;
-    } catch (err) {
-      if (!isMissingFsError(err))
-        throw err;
-      const parent = import_path.default.dirname(current);
-      if (parent === current)
-        return `${current}:<missing>`;
-      current = parent;
-    }
-  }
-}
 function isMalformedCacheError(err) {
   return err instanceof SyntaxError || err instanceof Error && /Unexpected end of JSON input|Unterminated string in JSON/.test(
     err.message
@@ -116,40 +56,25 @@ function getMdLoaderCacheSync(cache, key, defaultValue) {
     throw err;
   }
 }
-function getDemoSidecarFile(file) {
+function getDemoSidecarFiles(file) {
   const { dir, name } = import_path.default.parse(file);
-  return import_path.default.join(dir, `${name}.md`);
+  const mdFile = import_path.default.join(dir, `${name}.md`);
+  return import_fs.default.existsSync(mdFile) ? [mdFile] : [];
 }
-function collectDemoSourceFiles(demos = [], includeMissingSidecars = false) {
+function getDemoSourceFiles(demos = []) {
   const files = /* @__PURE__ */ new Set();
   demos.forEach((demo) => {
     if ("resolveMap" in demo) {
       Object.values(demo.resolveMap).filter((p) => import_path.default.isAbsolute(p)).forEach((file) => {
         files.add(file);
-        const sidecarFile = getDemoSidecarFile(file);
-        if (includeMissingSidecars || import_fs.default.existsSync(sidecarFile)) {
-          files.add(sidecarFile);
-        }
+        getDemoSidecarFiles(file).forEach(
+          (sidecarFile) => files.add(sidecarFile)
+        );
       });
     }
   });
   return Array.from(files);
 }
-function getDemoSourceFiles(demos = []) {
-  return collectDemoSourceFiles(demos);
-}
-function getDemoCacheFiles(demos = []) {
-  return collectDemoSourceFiles(demos, true);
-}
-function addDemoFileDependency(loaderContext, opts, file) {
-  if (import_fs.default.existsSync(file) || import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY in opts) {
-    loaderContext.addDependency(file);
-  } else if (loaderContext.addMissingDependency) {
-    loaderContext.addMissingDependency(file);
-  } else {
-    loaderContext.addDependency(file);
-  }
-}
 function isRelativePath(path2) {
   return /^\.{1,2}(?!\w)/.test(path2);
 }
@@ -218,21 +143,6 @@ export default DumiMarkdownContent;`;
 }
 function emitDemo(opts, ret) {
   const { demos } = ret.meta;
-  const demoHMRVersions = Object.fromEntries(
-    (demos ?? []).flatMap((demo) => {
-      const hmrVersion = demo.__dumiUtoopackHMRVersion;
-      return typeof hmrVersion === "string" ? [[demo.id, hmrVersion]] : [];
-    })
-  );
-  const enableDemoHMR = opts.useUtoopackDemoHMR === true && Object.keys(demoHMRVersions).length > 0;
-  const demoHMRModuleId = JSON.stringify(
-    (0, import_plugin_utils.winPath)(`${this.resourcePath}?type=demo`)
-  );
-  const enableUtoopackSelfAccept = enableDemoHMR && import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY in opts;
-  const renderedDemos = demos == null ? void 0 : demos.map((demo) => ({
-    ...demo,
-    renderedPreviewerProps: "previewerProps" in demo && demo.previewerProps ? JSON.stringify(demo.previewerProps) : void 0
-  }));
   const shareDepsMap = {};
   const demoDepsMap = {};
   const relativeDepsMap = {};
@@ -275,9 +185,6 @@ function emitDemo(opts, ret) {
   return import_plugin_utils.Mustache.render(
     `import React from 'react';
 import '${(0, import_plugin_utils.winPath)(this.resourcePath)}?watch=parent';
-{{#enableDemoHMR}}
-import { registerDemoHMRModule } from 'dumi/dist/client/theme-api/DumiDemo/hmr';
-{{/enableDemoHMR}}
 {{#dedupedDemosDeps}}
 import * as {{{specifier}}} from '{{{key}}}';
 {{/dedupedDemosDeps}}
@@ -292,29 +199,13 @@ export const demos = {
     routeId: '{{{routeId}}}',
     {{/routeId}}
     context: {{{renderContext}}},
-    {{#previewerProps}}
-    previewerProps: {{{renderedPreviewerProps}}},
-    {{/previewerProps}}
     renderOpts: {{{renderRenderOpts}}},
   },
   {{/demos}}
-};{{#enableUtoopackSelfAccept}}
-if (
-  typeof __turbopack_context__ !== 'undefined' &&
-  typeof __turbopack_context__.m?.hot?.accept === 'function'
-) {
-  __turbopack_context__.m.hot.accept();
-}
-{{/enableUtoopackSelfAccept}}{{#enableDemoHMR}}
-registerDemoHMRModule({{{demoHMRModuleId}}}, {{{demoHMRVersions}}});
-{{/enableDemoHMR}}`,
+};`,
     {
-      demos: renderedDemos,
+      demos,
       dedupedDemosDeps,
-      demoHMRModuleId,
-      demoHMRVersions: JSON.stringify(demoHMRVersions),
-      enableDemoHMR,
-      enableUtoopackSelfAccept,
       routeId,
       renderAsset: function renderAsset() {
         if (!("asset" in this))
@@ -454,9 +345,7 @@ function emit(opts, ret) {
   const { demos, embeds } = ret.meta;
   embeds.forEach((file) => this.addDependency(file));
   if (opts.mode !== "demo-index") {
-    getDemoCacheFiles(demos).forEach(
-      (file) => addDemoFileDependency(this, opts, file)
-    );
+    getDemoSourceFiles(demos).forEach((file) => this.addDependency(file));
   }
   if (this.resourceQuery.includes("watch=parent"))
     return null;
@@ -473,108 +362,20 @@ function emit(opts, ret) {
       return emitDefault.call(this, opts, ret);
   }
 }
-function normalizeDeps(deps = []) {
-  return Array.from(new Set(deps)).sort();
-}
-var readDependencyFromFs = (file) => import_fs.default.promises.readFile(file, "utf-8");
-async function getDepsCacheKey(deps = [], readDependency = readDependencyFromFs) {
+function getDepsCacheKey(deps = []) {
   return JSON.stringify(
-    await Promise.all(
-      normalizeDeps(deps).map(async (file) => {
-        try {
-          const content = await readDependency(file);
-          return `${file}:${(0, import_utils.getContentHash)(content)}:${await getFileRevision(
-            file
-          )}`;
-        } catch (err) {
-          if (isMissingFsError(err)) {
-            return `${file}:<missing>:${await getMissingParentRevision(file)}`;
-          }
-          throw err;
-        }
-      })
+    deps.map(
+      (file) => `${file}:${(0, import_utils.getContentHash)(import_fs.default.readFileSync(file, "utf-8"))}`
     )
   );
 }
-function getMdLoaderCacheRecord(cache, key) {
-  const record = getMdLoaderCacheSync(
-    cache,
-    key,
-    void 0
-  );
-  return (record == null ? void 0 : record.version) === 2 ? record : void 0;
-}
-async function getValidMdLoaderCacheRecord(cache, key, readDependency = readDependencyFromFs) {
-  const record = getMdLoaderCacheRecord(cache, key);
-  if (!record)
-    return void 0;
-  if (record.depsKey === await getDepsCacheKey(record.deps, readDependency)) {
-    return record;
-  }
-  return void 0;
-}
-async function getMdLoaderCacheResult(cache, key, readDependency = readDependencyFromFs) {
-  var _a;
-  return (_a = await getValidMdLoaderCacheRecord(cache, key, readDependency)) == null ? void 0 : _a.result;
-}
-async function createStableTransform({
-  initialDeps,
-  createValue,
-  getDeps,
-  readDependency = readDependencyFromFs,
-  onDepsDiscovered,
-  maxAttempts = 3
-}) {
-  let expectedDeps = initialDeps && normalizeDeps(initialDeps);
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const beforeKey = expectedDeps ? await getDepsCacheKey(expectedDeps, readDependency) : void 0;
-    const result = await createValue();
-    const deps = normalizeDeps(getDeps(result));
-    const depsKey = await getDepsCacheKey(deps, readDependency);
-    onDepsDiscovered == null ? void 0 : onDepsDiscovered(deps);
-    if (expectedDeps && JSON.stringify(expectedDeps) === JSON.stringify(deps) && beforeKey === depsKey) {
-      return { version: 2, deps, depsKey, result };
-    }
-    expectedDeps = deps;
-  }
-  throw Object.assign(
-    new Error("Markdown dependencies changed repeatedly while transforming"),
-    { code: "EDEPSUNSTABLE" }
-  );
-}
-function createDependencyReader(loaderContext, useUtoopack, mode) {
-  var _a;
-  if (useUtoopack && mode !== "demo-index" && ((_a = loaderContext.fs) == null ? void 0 : _a.readFile)) {
-    return (file) => new Promise((resolve, reject) => {
-      loaderContext.fs.readFile(
-        file,
-        (err, data) => {
-          if (err)
-            reject(err);
-          else
-            resolve(
-              Buffer.isBuffer(data) ? data.toString("utf-8") : String(data)
-            );
-        }
-      );
-    });
-  }
-  return readDependencyFromFs;
-}
-function getMdTransformDepsHint(cache, key) {
-  const hint = getMdLoaderCacheSync(
-    cache,
-    key,
-    void 0
-  );
-  return (hint == null ? void 0 : hint.version) === 1 ? normalizeDeps(hint.deps) : void 0;
-}
 var deferrer = {};
+var depsMapping = {};
 function mdLoader(content) {
   var _a, _b, _c;
   let opts = this.getOptions();
   const loaderContextPath = opts[import_utoopackLoaders.UTOOPACK_LOADER_CTX_KEY];
-  const useUtoopackDemoHMR = opts.useUtoopackDemoHMR === true && Boolean(loaderContextPath);
+  const useUtoopackDemoHMR = process.env.NODE_ENV !== "production" && Boolean(loaderContextPath);
   if (loaderContextPath) {
     const ctx = require(loaderContextPath);
     if (!((_a = opts.techStacks) == null ? void 0 : _a.length)) {
@@ -602,119 +403,47 @@ function mdLoader(content) {
   )) {
     this.cacheable(false);
   }
-  const cacheEpoch = opts.cacheEpoch;
-  const cacheNamespace = useUtoopackDemoHMR && cacheEpoch ? (0, import_utoopackLoaders.getUtoopackMdCacheNamespace)(cacheEpoch) : "md-loader";
-  const cache = (0, import_utils.getCache)(cacheNamespace, opts.cacheDirectory);
-  const depsHintCache = (0, import_utils.getCache)("md-loader-deps", opts.cacheDirectory);
-  const readDependency = createDependencyReader(
-    this,
-    useUtoopackDemoHMR,
-    opts.mode
-  );
-  const { baseCacheKey, depsHintKey } = getMdTransformCacheKeys({
-    resourcePath: this.resourcePath,
-    content,
+  const cache = (0, import_utils.getCache)("md-loader");
+  const baseCacheKey = [
+    this.resourcePath,
+    (0, import_utils.getContentHash)(content),
     useUtoopackDemoHMR,
-    opts
+    JSON.stringify(import_plugin_utils.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]))
+  ].join(":");
+  const cacheKey = [
+    baseCacheKey,
+    getDepsCacheKey(depsMapping[this.resourcePath])
+  ].join(":");
+  const cacheRet = getMdLoaderCacheSync(cache, cacheKey, "");
+  if (cacheRet) {
+    cb(null, emit.call(this, opts, cacheRet));
+    return;
+  } else if (cacheKey in deferrer) {
+    deferrer[cacheKey].then((res) => {
+      cb(null, emit.call(this, opts, res));
+    }).catch(cb);
+    return;
+  }
+  deferrer[cacheKey] = (0, import_transformer.default)(content, {
+    ...import_plugin_utils.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]),
+    fileAbsPath: (0, import_plugin_utils.winPath)(this.resourcePath),
+    useUtoopackDemoHMR
   });
-  const createTransform = async () => {
-    return (0, import_transformer.default)(content, {
-      ...import_plugin_utils.lodash.omit(opts, [
-        "mode",
-        "builtins",
-        "onResolveDemos",
-        "cacheDirectory",
-        "cacheEpoch"
-      ]),
-      fileAbsPath: (0, import_plugin_utils.winPath)(this.resourcePath),
-      useUtoopackDemoHMR
-    });
-  };
-  const getTransformDeps = (ret) => normalizeDeps(ret.meta.embeds.concat(getDemoCacheFiles(ret.meta.demos)));
-  const saveDepsHint = (deps) => {
-    depsHintCache.setSync(depsHintKey, {
-      version: 1,
-      deps: normalizeDeps(deps)
-    });
-  };
-  const cacheWithPath = cache;
-  const getTransform = async () => {
-    var _a2;
-    const cached = await getValidMdLoaderCacheRecord(
-      cache,
-      baseCacheKey,
-      readDependency
-    );
-    if (cached)
-      return cached;
-    const initialDeps = getMdTransformDepsHint(depsHintCache, depsHintKey) ?? ((_a2 = getMdLoaderCacheRecord(cache, baseCacheKey)) == null ? void 0 : _a2.deps);
-    const depsFingerprint = initialDeps ? await getDepsCacheKey(initialDeps, readDependency) : "<discover>";
-    const deferrerKey = [cacheNamespace, baseCacheKey, depsFingerprint].join(
-      ":"
+  deferrer[cacheKey].then((ret) => {
+    depsMapping[this.resourcePath] = ret.meta.embeds.concat(
+      getDemoSourceFiles(ret.meta.demos)
     );
-    if (deferrerKey in deferrer)
-      return deferrer[deferrerKey];
-    const createRecord = async () => {
-      if (useUtoopackDemoHMR) {
-        return createStableTransform({
-          initialDeps,
-          createValue: createTransform,
-          getDeps: getTransformDeps,
-          readDependency,
-          onDepsDiscovered: saveDepsHint
-        });
-      }
-      const result = await createTransform();
-      const deps = getTransformDeps(result);
-      const record = {
-        version: 2,
-        deps,
-        depsKey: await getDepsCacheKey(deps),
-        result
-      };
-      saveDepsHint(deps);
-      return record;
-    };
-    const saveRecord = (record) => {
-      cache.setSync(baseCacheKey, record);
-      saveDepsHint(record.deps);
-    };
-    const pending = useUtoopackDemoHMR && cacheWithPath.path ? (0, import_sharedCache.getOrCreateWithFileLock)({
-      lockPath: `${cacheWithPath.path(`transform:${baseCacheKey}`)}.lock`,
-      getValue: () => getValidMdLoaderCacheRecord(cache, baseCacheKey, readDependency),
-      createValue: createRecord,
-      setValue: saveRecord
-    }) : (async () => {
-      const current = await getValidMdLoaderCacheRecord(
-        cache,
-        baseCacheKey,
-        readDependency
-      );
-      if (current)
-        return current;
-      const created = await createRecord();
-      saveRecord(created);
-      return created;
-    })();
-    deferrer[deferrerKey] = pending;
-    try {
-      return await pending;
-    } finally {
-      if (deferrer[deferrerKey] === pending)
-        delete deferrer[deferrerKey];
-    }
-  };
-  getTransform().then((record) => cb(null, emit.call(this, opts, record.result))).catch(cb);
+    const finalCacheKey = [
+      baseCacheKey,
+      getDepsCacheKey(depsMapping[this.resourcePath])
+    ].join(":");
+    cache.setSync(finalCacheKey, ret);
+    cb(null, emit.call(this, opts, ret));
+    delete deferrer[cacheKey];
+  }).catch(cb);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  addDemoFileDependency,
-  createDependencyReader,
-  createStableTransform,
-  emitDemo,
   getDemoSourceFiles,
-  getDepsCacheKey,
-  getMdLoaderCacheResult,
-  getMdLoaderCacheSync,
-  getMdTransformCacheKeys
+  getMdLoaderCacheSync
 });

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

@@ -1,5 +1,4 @@
 import type { IParsedBlockAsset } from '../../../assetParsers/block';
-import type { IDumiDemoProps } from '@/client/theme-api/DumiDemo';
 import type { ILocalesConfig, IRouteMeta } from '@/client/theme-api/types';
 import type { IApi, IDumiConfig, IDumiTechStack } from '../../../types';
 import { type ResolveOptions } from 'enhanced-resolve';
@@ -24,9 +23,6 @@ declare module 'vfile' {
             component: string;
             asset: IParsedBlockAsset['asset'];
             resolveMap: IParsedBlockAsset['resolveMap'];
-            previewerProps?: IDumiDemoProps['previewerProps'];
-            /** Internal semantic version used by the utoopack demo HMR runtime. */
-            __dumiUtoopackHMRVersion?: string;
             renderOpts: {
                 type?: string;
                 rendererPath?: string;