dumi
Version:
📖 Documentation Generator of React Component
662 lines (657 loc) • 25.2 kB
JavaScript
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(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
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,
emitDefault: () => emitDefault,
emitFrontmatter: () => emitFrontmatter,
emitRenderText: () => emitRenderText,
emitText: () => emitText,
getDemoSourceFiles: () => getDemoSourceFiles,
getMdLoaderCacheSync: () => getMdLoaderCacheSync
});
module.exports = __toCommonJS(markdown_exports);
var import_utils = require("../../features/tabs/utils");
var import_constants = require("../constants");
var import_utils2 = require("../../utils");
var import_utils3 = require("@umijs/utils");
var import_fs = __toESM(require("fs"));
var import_path = __toESM(require("path"));
var import_transformer = __toESM(require("./transformer"));
var MD_LOADER_CACHE_VERSION = 1;
function isMalformedCacheError(err) {
return err instanceof SyntaxError || err instanceof Error && /Unexpected end of JSON input|Unterminated string in JSON/.test(
err.message
);
}
function getMdLoaderCacheSync(cache, key, defaultValue) {
try {
return cache.getSync(key, defaultValue);
} catch (err) {
if (isMalformedCacheError(err))
return defaultValue;
throw err;
}
}
function getDemoSidecarFiles(file) {
const { dir, name } = import_path.default.parse(file);
const mdFile = import_path.default.join(dir, `${name}.md`);
return import_fs.default.existsSync(mdFile) ? [mdFile] : [];
}
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);
getDemoSidecarFiles(file).forEach(
(sidecarFile) => files.add(sidecarFile)
);
});
}
});
return Array.from(files);
}
function isRelativePath(path2) {
return /^\.{1,2}(?!\w)/.test(path2);
}
function normalizeRouteFile(file) {
return (0, import_utils3.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 sharedDemoProps = ret.meta.demoSharedProps ?? [];
const isTabContent = (0, import_utils.isTabRouteFile)(this.resourcePath);
const wrapper = isTabContent ? "" : "DumiPage";
const textMode = import_constants.UTOOPACK_LOADER_CTX_KEY in opts && process.env.NODE_ENV !== "production" ? "text-render" : "text";
if (demos && opts.onResolveDemos) {
opts.onResolveDemos(demos);
}
if (demos && opts.demoAssetsFile) {
const assets = demos.reduce((acc, demo) => {
if ("asset" in demo)
acc.push(JSON.stringify(demo.asset));
return acc;
}, []);
if (assets.length) {
import_fs.default.mkdirSync(import_path.default.dirname(opts.demoAssetsFile), { recursive: true });
import_fs.default.appendFileSync(opts.demoAssetsFile, `${assets.join("\n")}
`);
}
}
if (frontmatter.atomId && opts.onResolveAtomMeta) {
opts.onResolveAtomMeta(frontmatter.atomId, frontmatter);
}
const embeddedMdFiles = (ret.meta.embeds ?? []).filter(
(filePath) => filePath.endsWith(".md") && !filePath.includes("node_modules")
);
return `${Object.values(opts.builtins).map((item) => `import ${item.specifier} from '${(0, import_utils3.winPath)(item.source)}';`).join("\n")}
${embeddedMdFiles.map(
(md) => `
import '${(0, import_utils3.winPath)(md)}?watch=parent';
`
).join("\n")}
import LoadingComponent from '@@/dumi/theme/loading';
import React, { Suspense } from 'react';
import { DumiPage } from 'dumi';
import { texts as ${import_constants.CONTENT_TEXTS_OBJ_NAME} } from '${(0, import_utils3.winPath)(
this.resourcePath
)}?type=${textMode}';
${sharedDemoProps.length ? `const __dumi_demo_shared_props__ = ${JSON.stringify(sharedDemoProps)};` : ""}
// 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 (
<${wrapper}>
<Suspense fallback={<LoadingComponent />}>
${ret.content}
</Suspense>
</${wrapper}>
)
}
export default DumiMarkdownContent;`;
}
function emitDemo(opts, ret) {
const { demos } = ret.meta;
const shareDepsMap = {};
const demoDepsMap = {};
const relativeDepsMap = {};
const sideEffectDepsMap = /* @__PURE__ */ new Map();
demos == null ? void 0 : demos.forEach((demo) => {
var _a, _b;
if ("resolveMap" in demo && "asset" in demo) {
const entryFileName = Object.keys(demo.asset.dependencies)[0];
demoDepsMap[_a = demo.id] ?? (demoDepsMap[_a] = {});
relativeDepsMap[_b = demo.id] ?? (relativeDepsMap[_b] = {});
Object.keys(demo.resolveMap).forEach((key, index) => {
var _a2;
const specifier = `${demo.id.replace(/[^\w\d]/g, "_")}_deps_${index}`;
if (key !== entryFileName) {
const isRelative = isRelativePath(key);
const normalizedKey = isRelative ? (0, import_utils3.winPath)(demo.resolveMap[key]) : key;
sideEffectDepsMap.set(
normalizedKey,
sideEffectDepsMap.get(normalizedKey) !== false && ((_a2 = demo.sideEffectStyles) == null ? void 0 : _a2.includes(normalizedKey)) === true
);
if (!shareDepsMap[normalizedKey]) {
demoDepsMap[demo.id][normalizedKey] = specifier;
shareDepsMap[normalizedKey] = specifier;
} else {
demoDepsMap[demo.id][normalizedKey] = shareDepsMap[normalizedKey];
}
if (isRelative) {
relativeDepsMap[demo.id][key] = `{{{${shareDepsMap[normalizedKey] || specifier}}}}`;
}
}
});
}
});
const dedupedDemosDeps = opts.disableLiveDemo ? [] : Object.entries(demoDepsMap).reduce((acc, [, deps]) => {
return acc.concat(
Object.entries(deps).map(([key, specifier]) => {
const existingIndex = acc.findIndex((obj) => obj.key === key);
if (existingIndex === -1) {
return {
key,
specifier,
// Preserve webpack's namespace behavior, including custom style exports.
sideEffectOnly: Boolean(opts[import_constants.UTOOPACK_LOADER_CTX_KEY]) && sideEffectDepsMap.get(key) === true
};
}
return void 0;
}).filter((item) => item !== void 0)
);
}, []);
const routeId = getRouteId(opts, this.resourcePath);
return import_utils3.Mustache.render(
`import React from 'react';
import '${(0, import_utils3.winPath)(this.resourcePath)}?watch=parent';
{{#dedupedDemosDeps}}
{{#sideEffectOnly}}
import '{{{key}}}';
const {{{specifier}}} = {};
{{/sideEffectOnly}}
{{^sideEffectOnly}}
import * as {{{specifier}}} from '{{{key}}}';
{{/sideEffectOnly}}
{{/dedupedDemosDeps}}
export const demos = {
{{#demos}}
'{{{id}}}': {
{{#component}}
component: {{{component}}},
{{/component}}
asset: {{{renderAsset}}},
{{#routeId}}
routeId: '{{{routeId}}}',
{{/routeId}}
context: {{{renderContext}}},
renderOpts: {{{renderRenderOpts}}},
},
{{/demos}}
};`,
{
demos,
dedupedDemosDeps,
routeId,
renderAsset: function renderAsset() {
if (!("asset" in this))
return "null";
let { asset } = this;
const { resolveMap } = this;
Object.keys(this.resolveMap).forEach((file) => {
var _a;
if (((_a = asset.dependencies[file]) == null ? void 0 : _a.type) === "FILE") {
let assetValue = `{{{require('-!${resolveMap[file]}?dumi-raw').default}}}`;
if (process.env.OKAM || opts[import_constants.UTOOPACK_LOADER_CTX_KEY]) {
assetValue = `{{{require('${resolveMap[file]}?dumi-raw').default}}}`;
}
asset = import_utils3.lodash.cloneDeep(asset);
asset.dependencies[file].value = assetValue;
}
});
return JSON.stringify(asset, null, 2).replace(/"{{{|}}}"/g, "");
},
renderContext: function renderContext() {
if (!("resolveMap" in this) || !("asset" in this) || opts.disableLiveDemo)
return "undefined";
const context = Object.entries(demoDepsMap[this.id]).reduce(
(acc, [key, specifier]) => ({
...acc,
...{ [key]: `{{{${specifier}}}}` }
}),
relativeDepsMap[this.id]
);
return JSON.stringify(context, null, 2).replace(/"{{{|}}}"/g, "");
},
renderRenderOpts: function renderRenderOpts() {
if (!("renderOpts" in this) || opts.disableLiveDemo) {
return "undefined";
}
const renderOpts = this.renderOpts;
const propertyArray = [];
if (renderOpts.compilePath) {
propertyArray.push(`
compile: async (...args) => {
return (await import('${(0, import_utils3.winPath)(
renderOpts.compilePath
)}')).default(...args);
},`);
}
if (renderOpts.rendererPath) {
propertyArray.push(`
renderer: (await import('${(0, import_utils3.winPath)(
renderOpts.rendererPath
)}')).default,`);
}
if (renderOpts.preflightPath) {
propertyArray.push(`
preflight: (await import('${(0, import_utils3.winPath)(
renderOpts.preflightPath
)}')).default,`);
}
if (propertyArray.length === 0)
return "undefined";
return `{
${propertyArray.join("\n")}
}`;
}
}
);
}
function renderDemoIndex(resourcePath, opts, demos) {
return import_utils3.Mustache.render(
`
export const demoIndex = {
ids: {{{ids}}},
getter: {{{getter}}}
};`,
{
ids: JSON.stringify(demos == null ? void 0 : demos.map((demo) => demo.id)),
getter: `() => import(/* webpackChunkName: "${(0, import_utils2.generateMetaChunkName)(
resourcePath,
opts.cwd,
opts.locales.map(({ id }) => id)
)}" */'${(0, import_utils3.winPath)(resourcePath)}?type=demo')`
}
);
}
function emitDemoIndex(opts, ret) {
const { demos } = ret.meta;
return `import '${(0, import_utils3.winPath)(this.resourcePath)}?watch=parent';
${renderDemoIndex(this.resourcePath, opts, demos)}`;
}
function emitFrontmatter(opts, ret) {
const { demos } = ret.meta;
const frontmatter = ret.meta.frontmatter;
const toc = ret.meta.toc ?? [];
const resourcePath = (0, import_utils3.winPath)(this.resourcePath);
const isUtoopack = import_constants.UTOOPACK_LOADER_CTX_KEY in opts;
const enableUtoopackHMR = isUtoopack && process.env.NODE_ENV !== "production";
const routeMetaHMRPath = enableUtoopackHMR ? (0, import_utils3.winPath)(require.resolve("../../client/theme-api/routeMetaHMR")) : void 0;
const routeId = getRouteId(opts, this.resourcePath);
const demoIndex = renderDemoIndex(this.resourcePath, opts, demos);
if (isUtoopack) {
const routeStructureHash = (0, import_utils2.getContentHash)(
JSON.stringify({
atomId: frontmatter.atomId,
demoIds: demos == null ? void 0 : demos.map(({ id }) => id),
filename: frontmatter.filename,
group: frontmatter.group,
nav: frontmatter.nav,
order: frontmatter.order,
title: frontmatter.title
})
);
const rendered = import_utils3.Mustache.render(
`{{#enableUtoopackHMR}}
import { notifyRouteMetaHMR } from {{{routeMetaHMRSpecifier}}};
{{/enableUtoopackHMR}}
import '${resourcePath}?watch=parent';
globalThis.__DUMI_FM__ = globalThis.__DUMI_FM__ || {};
globalThis.__DUMI_TOC__ = globalThis.__DUMI_TOC__ || {};
{{#enableUtoopackHMR}}
const hadPreviousMeta = Object.prototype.hasOwnProperty.call(globalThis.__DUMI_FM__, '${resourcePath}');
globalThis.__DUMI_META_STRUCTURE_HASH__ = globalThis.__DUMI_META_STRUCTURE_HASH__ || {};
const previousRouteStructureHash = globalThis.__DUMI_META_STRUCTURE_HASH__['${resourcePath}'];
const didRouteStructureChange = previousRouteStructureHash !== undefined && previousRouteStructureHash !== '{{{routeStructureHash}}}';
globalThis.__DUMI_META_STRUCTURE_HASH__['${resourcePath}'] = '{{{routeStructureHash}}}';
const nextFrontmatter = {{{frontmatter}}};
const nextToc = {{{toc}}};
const frontmatter = globalThis.__DUMI_FM__['${resourcePath}'] || {};
const toc = globalThis.__DUMI_TOC__['${resourcePath}'] || [];
Object.keys(frontmatter).forEach((key) => delete frontmatter[key]);
Object.assign(frontmatter, nextFrontmatter);
toc.splice(0, toc.length, ...nextToc);
globalThis.__DUMI_FM__['${resourcePath}'] = frontmatter;
globalThis.__DUMI_TOC__['${resourcePath}'] = toc;
{{/enableUtoopackHMR}}
{{^enableUtoopackHMR}}
globalThis.__DUMI_FM__['${resourcePath}'] = {{{frontmatter}}};
globalThis.__DUMI_TOC__['${resourcePath}'] = {{{toc}}};
const frontmatter = globalThis.__DUMI_FM__['${resourcePath}'];
const toc = globalThis.__DUMI_TOC__['${resourcePath}'];
{{/enableUtoopackHMR}}
export { frontmatter, toc };
{{#enableUtoopackHMR}}
export const routeStructureHash = '{{{routeStructureHash}}}';
{{/enableUtoopackHMR}}
{{{demoIndex}}}
{{#enableUtoopackHMR}}
if (module.hot) {
module.hot.accept();
if (didRouteStructureChange) {
module.hot.invalidate();
}{{#routeId}} else if (hadPreviousMeta) {
notifyRouteMetaHMR({{{routeId}}});
}{{/routeId}}{{^routeId}} else if (hadPreviousMeta) {
module.hot.invalidate();
}{{/routeId}}
}
{{/enableUtoopackHMR}}`,
{
toc: JSON.stringify(toc),
frontmatter: JSON.stringify(frontmatter),
demoIndex,
enableUtoopackHMR,
routeId: routeId ? JSON.stringify(routeId) : void 0,
routeMetaHMRSpecifier: routeMetaHMRPath ? JSON.stringify(routeMetaHMRPath) : void 0,
routeStructureHash
}
);
return rendered;
}
return import_utils3.Mustache.render(
`import '${resourcePath}?watch=parent';
export const toc = new Proxy({{{toc}}}, {});
export const frontmatter = new Proxy({{{frontmatter}}}, {});
{{{demoIndex}}}`,
{
toc: JSON.stringify(toc),
frontmatter: JSON.stringify(frontmatter),
demoIndex
}
);
}
function emitText(opts, ret) {
const texts = ret.meta.texts ?? [];
const resourcePath = (0, import_utils3.winPath)(this.resourcePath);
const enableUtoopackHMR = import_constants.UTOOPACK_LOADER_CTX_KEY in opts && process.env.NODE_ENV !== "production";
if (enableUtoopackHMR) {
const routeId = getRouteId(opts, this.resourcePath);
const routeMetaHMRSpecifier = JSON.stringify(
(0, import_utils3.winPath)(require.resolve("../../client/theme-api/routeMetaHMR"))
);
return import_utils3.Mustache.render(
`import { notifyRouteMetaHMR } from {{{routeMetaHMRSpecifier}}};
import {{{watchSpecifier}}};
globalThis.__DUMI_TEXTS__ = globalThis.__DUMI_TEXTS__ || {};
const hadPreviousTexts = Object.prototype.hasOwnProperty.call(globalThis.__DUMI_TEXTS__, {{{resourceSpecifier}}});
const nextTexts = {{{texts}}};
const texts = globalThis.__DUMI_TEXTS__[{{{resourceSpecifier}}}] || [];
texts.splice(0, texts.length, ...nextTexts);
globalThis.__DUMI_TEXTS__[{{{resourceSpecifier}}}] = texts;
export { texts };
if (module.hot) {
module.hot.accept();
{{#routeId}}if (hadPreviousTexts) {
notifyRouteMetaHMR({{{routeId}}});
}{{/routeId}}{{^routeId}}if (hadPreviousTexts) {
module.hot.invalidate();
}{{/routeId}}
}`,
{
resourceSpecifier: JSON.stringify(resourcePath),
routeId: routeId ? JSON.stringify(routeId) : void 0,
routeMetaHMRSpecifier,
texts: JSON.stringify(texts),
watchSpecifier: JSON.stringify(`${resourcePath}?watch=parent`)
}
);
}
return import_utils3.Mustache.render(
`
import '${resourcePath}?watch=parent';
export const texts = {{{texts}}};
`,
{
texts: JSON.stringify(texts)
}
);
}
function emitRenderText(_opts, ret) {
return import_utils3.Mustache.render(
`
import {{{watchSpecifier}}};
export const texts = {{{texts}}};
`,
{
texts: JSON.stringify(ret.meta.texts ?? []),
watchSpecifier: JSON.stringify(
`${(0, import_utils3.winPath)(this.resourcePath)}?watch=parent`
)
}
);
}
function emit(opts, ret) {
const { demos, embeds } = ret.meta;
embeds.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) {
case "demo":
return emitDemo.call(this, opts, ret);
case "demo-index":
return emitDemoIndex.call(this, opts, ret);
case "frontmatter":
return emitFrontmatter.call(this, opts, ret);
case "text":
return emitText.call(this, opts, ret);
case "text-render":
return emitRenderText.call(this, opts, ret);
default:
return emitDefault.call(this, opts, ret);
}
}
function getDepsCacheKey(deps = [], cacheSession) {
if (!cacheSession) {
return JSON.stringify(
deps.map(
(file) => `${file}:${(0, import_utils2.getContentHash)(import_fs.default.readFileSync(file, "utf-8"))}`
)
);
}
const files = Array.from(
new Set(deps.concat(deps.flatMap(getDemoSidecarFiles)))
);
try {
return JSON.stringify(
files.map(
(file) => `${file}:${(0, import_utils2.getContentHash)(import_fs.default.readFileSync(file, "utf-8"))}`
)
);
} catch (err) {
const code = err.code;
if (code === "ENOENT" || code === "ENOTDIR") {
return void 0;
}
throw err;
}
}
var deferrer = {};
var depsMapping = {};
var loaderContextHashes = /* @__PURE__ */ new WeakMap();
function mdLoader(content) {
var _a, _b, _c;
let opts = this.getOptions();
let cacheSession;
const loaderContextPath = opts[import_constants.UTOOPACK_LOADER_CTX_KEY];
const useUtoopackDemoHMR = process.env.NODE_ENV !== "production" && Boolean(loaderContextPath);
if (loaderContextPath) {
const contextModuleId = useUtoopackDemoHMR && process.env.DUMI_CACHE !== "none" ? require.resolve(loaderContextPath) : void 0;
const cachedContextModule = contextModuleId ? require.cache[contextModuleId] : void 0;
const initialContextHash = contextModuleId && !cachedContextModule ? (0, import_utils2.getContentHash)(import_fs.default.readFileSync(loaderContextPath, "utf-8"), 32) : void 0;
let ctx = require(loaderContextPath);
if (contextModuleId && ctx.cacheSession) {
const contextHash = initialContextHash ?? (0, import_utils2.getContentHash)(import_fs.default.readFileSync(loaderContextPath, "utf-8"), 32);
if (cachedContextModule && loaderContextHashes.get(cachedContextModule) !== contextHash) {
const parents = /* @__PURE__ */ new Set([
cachedContextModule.parent,
typeof module === "undefined" ? void 0 : module,
...Object.values(require.cache)
]);
for (const parent of parents) {
const children = parent == null ? void 0 : parent.children;
const index = (children == null ? void 0 : children.indexOf(cachedContextModule)) ?? -1;
if (index !== -1)
children.splice(index, 1);
}
delete require.cache[contextModuleId];
ctx = require(contextModuleId);
}
const contextModule = require.cache[contextModuleId];
if (contextModule)
loaderContextHashes.set(contextModule, contextHash);
}
cacheSession = useUtoopackDemoHMR && process.env.DUMI_CACHE !== "none" ? ctx.cacheSession : void 0;
if (!((_a = opts.techStacks) == null ? void 0 : _a.length)) {
opts.techStacks = ctx.techStacks;
}
if (ctx.alias !== void 0) {
opts = { ...opts, alias: ctx.alias };
}
if (ctx.builtins && !Object.keys(opts.builtins ?? {}).length) {
opts.builtins = ctx.builtins;
}
if (ctx.routes && !Object.keys(opts.routes ?? {}).length) {
opts.routes = ctx.routes;
}
if (ctx.extraRemarkPlugins && !((_b = opts.extraRemarkPlugins) == null ? void 0 : _b.length)) {
opts.extraRemarkPlugins = ctx.extraRemarkPlugins;
}
if (ctx.extraRehypePlugins && !((_c = opts.extraRehypePlugins) == null ? void 0 : _c.length)) {
opts.extraRehypePlugins = ctx.extraRehypePlugins;
}
if (ctx.demoAssetsFile && !opts.demoAssetsFile) {
opts.demoAssetsFile = ctx.demoAssetsFile;
}
}
const cb = this.async();
if (process.env.NODE_ENV === "production" && ["onResolveDemos", "onResolveAtomMeta", "demoAssetsFile"].some(
(k) => k in opts
)) {
this.cacheable(false);
}
const cache = (0, import_utils2.getCache)("md-loader");
let optionsCacheKey = JSON.stringify(
import_utils3.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"])
);
if (cacheSession)
optionsCacheKey = (0, import_utils2.getContentHash)(optionsCacheKey, 32);
const baseCacheKey = [
MD_LOADER_CACHE_VERSION,
this.resourcePath,
(0, import_utils2.getContentHash)(content),
useUtoopackDemoHMR,
optionsCacheKey
].join(":");
const depsCacheKey = cacheSession ? `deps:${baseCacheKey}` : void 0;
const depsMappingKey = cacheSession ? `${cacheSession}:${this.resourcePath}` : this.resourcePath;
const cachedDeps = depsCacheKey ? getMdLoaderCacheSync(
cache,
depsCacheKey,
void 0
) : void 0;
const deps = cachedDeps && cachedDeps.cacheSession === cacheSession && Array.isArray(cachedDeps.deps) && cachedDeps.deps.every((file) => typeof file === "string") ? cachedDeps.deps : depsMapping[depsMappingKey];
const depsKey = getDepsCacheKey(deps, cacheSession);
const cacheKey = [baseCacheKey, depsKey].join(":");
const cacheRet = depsKey === void 0 ? "" : getMdLoaderCacheSync(cache, cacheKey, "");
const matchesSession = !cacheSession || !(deps == null ? void 0 : deps.length) || cacheRet && cacheRet.__dumiCacheSession === cacheSession;
const deferrerKey = cacheSession ? `${cacheSession}:${cacheKey}` : cacheKey;
if (cacheRet && matchesSession) {
cb(null, emit.call(this, opts, cacheRet));
return;
} else if (deferrerKey in deferrer) {
deferrer[deferrerKey].then((res) => {
cb(null, emit.call(this, opts, res));
}).catch(cb);
return;
}
deferrer[deferrerKey] = (0, import_transformer.default)(content, {
...import_utils3.lodash.omit(opts, ["mode", "builtins", "onResolveDemos"]),
fileAbsPath: (0, import_utils3.winPath)(this.resourcePath),
useUtoopackDemoHMR,
collectSideEffectStyles: Boolean(loaderContextPath)
});
deferrer[deferrerKey].then((ret) => {
depsMapping[depsMappingKey] = ret.meta.embeds.concat(
getDemoSourceFiles(ret.meta.demos)
);
const finalDepsKey = getDepsCacheKey(
depsMapping[depsMappingKey],
cacheSession
);
if (finalDepsKey !== void 0) {
cache.setSync(
[baseCacheKey, finalDepsKey].join(":"),
cacheSession && depsMapping[depsMappingKey].length ? { ...ret, __dumiCacheSession: cacheSession } : ret
);
if (depsCacheKey)
cache.setSync(depsCacheKey, {
cacheSession,
deps: depsMapping[depsMappingKey]
});
}
cb(null, emit.call(this, opts, ret));
delete deferrer[deferrerKey];
}).catch((err) => {
delete deferrer[deferrerKey];
cb(err);
});
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
emitDefault,
emitFrontmatter,
emitRenderText,
emitText,
getDemoSourceFiles,
getMdLoaderCacheSync
});