@mui/internal-docs-infra
Version:
MUI Infra - internal documentation creation tools.
632 lines (623 loc) • 27.6 kB
JavaScript
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import { loadVariant } from "./loadVariant.js";
import { getFileNameFromUrl } from "../pipeline/loaderUtils/index.js";
// Helper function to get the source for a specific filename from a variant
function getFileSource(_x, _x2, _x3) {
return _getFileSource.apply(this, arguments);
}
function _getFileSource() {
_getFileSource = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(variant, requestedFilename, loadSource) {
var filename, extraFile, loadResult;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
filename = requestedFilename || variant.fileName;
if (filename) {
_context.next = 5;
break;
}
if (!(variant.source !== undefined)) {
_context.next = 4;
break;
}
return _context.abrupt("return", {
source: variant.source,
filename: undefined
});
case 4:
throw new Error('No filename available and no source in variant');
case 5:
if (!(filename === variant.fileName && variant.source !== undefined)) {
_context.next = 7;
break;
}
return _context.abrupt("return", {
source: variant.source,
filename: filename
});
case 7:
if (!(filename !== variant.fileName && variant.extraFiles)) {
_context.next = 18;
break;
}
extraFile = variant.extraFiles[filename];
if (!(extraFile && typeof extraFile !== 'string' && extraFile.source !== undefined)) {
_context.next = 11;
break;
}
return _context.abrupt("return", {
source: extraFile.source,
filename: filename
});
case 11:
if (!(typeof extraFile === 'string' && loadSource)) {
_context.next = 16;
break;
}
_context.next = 14;
return loadSource(extraFile);
case 14:
loadResult = _context.sent;
return _context.abrupt("return", {
source: loadResult.source,
filename: filename
});
case 16:
if (!(extraFile && typeof extraFile !== 'string' && !extraFile.source && loadSource)) {
_context.next = 18;
break;
}
throw new Error("Extra file ".concat(filename, " has no source or URL to load from"));
case 18:
throw new Error("File ".concat(filename, " not found in variant or cannot be loaded"));
case 19:
case "end":
return _context.stop();
}
}, _callee);
}));
return _getFileSource.apply(this, arguments);
}
export function loadFallbackCode(_x4, _x5, _x6, _x7, _x8, _x9, _x0, _x1, _x10, _x11, _x12, _x13, _x14) {
return _loadFallbackCode.apply(this, arguments);
}
function _loadFallbackCode() {
_loadFallbackCode = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(url, initialVariant, loaded, shouldHighlight, fallbackUsesExtraFiles, fallbackUsesAllVariants, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, initialFilename, variants, globalsCode) {
var initial, _allFileNames, fileSource, actualFilename, result, parseSource, quickVariant, _allFileNames2, _fileSource, _actualFilename, _result, _parseSource, globalsCodeObjects, hasStringUrls, globalsPromises, resolvedGlobalsCode, _iterator, _step, codeObj, targetVariant, _yield$loadVariant, loadedVariant, allFileNames, allVariants, variantPromises, variantResults, finalInitial, finalFileSource, finalFilename, _result2;
return _regeneratorRuntime().wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
loaded = _objectSpread({}, loaded);
// Step 1: Ensure we have the initial variant loaded
initial = loaded[initialVariant];
if (initial) {
_context4.next = 17;
break;
}
if (loadCodeMeta) {
_context4.next = 5;
break;
}
throw new Error('"loadCodeMeta" function is required when initial variant is not provided');
case 5:
_context4.prev = 5;
_context4.next = 8;
return loadCodeMeta(url);
case 8:
loaded = _context4.sent;
_context4.next = 14;
break;
case 11:
_context4.prev = 11;
_context4.t0 = _context4["catch"](5);
throw new Error("Failed to load code from URL: ".concat(url, ". Error: ").concat(JSON.stringify(_context4.t0)));
case 14:
initial = loaded[initialVariant];
if (initial) {
_context4.next = 17;
break;
}
throw new Error("Initial variant \"".concat(initialVariant, "\" not found in loaded code."));
case 17:
if (!(typeof initial !== 'string' && initial.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
_context4.next = 48;
break;
}
// Collect all file names from the loaded code
_allFileNames = new Set();
if (initial.fileName) {
_allFileNames.add(initial.fileName);
}
if (initial.extraFiles) {
Object.keys(initial.extraFiles).forEach(function (fileName) {
return _allFileNames.add(fileName);
});
}
// Get the source for the requested filename (or main file if not specified)
_context4.prev = 21;
_context4.next = 24;
return getFileSource(initial, initialFilename, loadSource);
case 24:
result = _context4.sent;
fileSource = result.source;
actualFilename = result.filename;
_context4.next = 32;
break;
case 29:
_context4.prev = 29;
_context4.t1 = _context4["catch"](21);
throw new Error("Failed to get source for file ".concat(initialFilename || initial.fileName, " in variant ").concat(initialVariant, ": ").concat(_context4.t1));
case 32:
if (!(shouldHighlight && typeof fileSource === 'string' && sourceParser && actualFilename)) {
_context4.next = 45;
break;
}
_context4.prev = 33;
_context4.next = 36;
return sourceParser;
case 36:
parseSource = _context4.sent;
fileSource = parseSource(fileSource, actualFilename);
_context4.next = 43;
break;
case 40:
_context4.prev = 40;
_context4.t2 = _context4["catch"](33);
throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(actualFilename, "): ").concat(JSON.stringify(_context4.t2)));
case 43:
_context4.next = 46;
break;
case 45:
if (shouldHighlight && typeof fileSource === 'string' && !actualFilename) {
// Create basic HAST node when we can't parse due to missing filename
// This marks that the source has passed through the parsing pipeline
fileSource = {
type: 'root',
children: [{
type: 'text',
value: fileSource
}]
};
}
case 46:
// Update the loaded code with any changes we made
if (actualFilename && actualFilename === initial.fileName) {
initial = _objectSpread(_objectSpread({}, initial), {}, {
source: fileSource
});
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, initial));
} else if (!actualFilename && !initial.fileName) {
// If both are undefined, we're dealing with the main source
initial = _objectSpread(_objectSpread({}, initial), {}, {
source: fileSource
});
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, initial));
}
// Early return - we have all the info we need
return _context4.abrupt("return", {
code: loaded,
initialFilename: actualFilename,
initialSource: fileSource,
initialExtraFiles: initial.extraFiles || {},
allFileNames: Array.from(_allFileNames)
});
case 48:
if (!(typeof initial === 'string')) {
_context4.next = 95;
break;
}
_context4.prev = 49;
if (!loadVariantMeta) {
_context4.next = 56;
break;
}
_context4.next = 53;
return loadVariantMeta(initialVariant, initial);
case 53:
quickVariant = _context4.sent;
_context4.next = 57;
break;
case 56:
// Create a basic variant using fallback logic
quickVariant = {
url: initial,
fileName: getFileNameFromUrl(initial).fileName
};
case 57:
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, quickVariant));
initial = quickVariant;
// If we have all files listed and don't need extra file processing, we can optimize
if (!(quickVariant.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
_context4.next = 90;
break;
}
// Collect all file names from the quick load
_allFileNames2 = new Set();
if (quickVariant.fileName) {
_allFileNames2.add(quickVariant.fileName);
}
if (quickVariant.extraFiles) {
Object.keys(quickVariant.extraFiles).forEach(function (fileName) {
return _allFileNames2.add(fileName);
});
}
// Get the source for the requested filename (or main file if not specified)
_context4.prev = 63;
_context4.next = 66;
return getFileSource(quickVariant, initialFilename, loadSource);
case 66:
_result = _context4.sent;
_fileSource = _result.source;
_actualFilename = _result.filename;
_context4.next = 74;
break;
case 71:
_context4.prev = 71;
_context4.t3 = _context4["catch"](63);
throw new Error("Failed to get source for file ".concat(initialFilename || quickVariant.fileName, " in variant ").concat(initialVariant, ": ").concat(_context4.t3));
case 74:
if (!(shouldHighlight && typeof _fileSource === 'string' && sourceParser && _actualFilename)) {
_context4.next = 87;
break;
}
_context4.prev = 75;
_context4.next = 78;
return sourceParser;
case 78:
_parseSource = _context4.sent;
_fileSource = _parseSource(_fileSource, _actualFilename);
_context4.next = 85;
break;
case 82:
_context4.prev = 82;
_context4.t4 = _context4["catch"](75);
throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(_actualFilename, "): ").concat(JSON.stringify(_context4.t4)));
case 85:
_context4.next = 88;
break;
case 87:
if (shouldHighlight && typeof _fileSource === 'string' && !_actualFilename) {
// Create basic HAST node when we can't parse due to missing filename
// This marks that the source has passed through the parsing pipeline
_fileSource = {
type: 'root',
children: [{
type: 'text',
value: _fileSource
}]
};
}
case 88:
// Update the loaded code with any changes we made
if (_actualFilename && _actualFilename === quickVariant.fileName) {
initial = _objectSpread(_objectSpread({}, quickVariant), {}, {
source: _fileSource
});
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, initial));
} else if (!_actualFilename && !quickVariant.fileName) {
// If both are undefined, we're dealing with the main source
initial = _objectSpread(_objectSpread({}, quickVariant), {}, {
source: _fileSource
});
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, initial));
}
// Early return - we have all the info we need
return _context4.abrupt("return", {
code: loaded,
initialFilename: _actualFilename,
initialSource: _fileSource,
initialExtraFiles: quickVariant.extraFiles || {},
allFileNames: Array.from(_allFileNames2)
});
case 90:
_context4.next = 95;
break;
case 92:
_context4.prev = 92;
_context4.t5 = _context4["catch"](49);
throw new Error("Failed to load initial variant code (variant: ".concat(initialVariant, ", url: ").concat(initial, "): ").concat(JSON.stringify(_context4.t5)));
case 95:
if (!(globalsCode && globalsCode.length > 0)) {
_context4.next = 103;
break;
}
hasStringUrls = globalsCode.some(function (item) {
return typeof item === 'string';
});
if (!(hasStringUrls && !loadCodeMeta)) {
_context4.next = 99;
break;
}
throw new Error('loadCodeMeta function is required when globalsCode contains string URLs');
case 99:
// Load all string URLs in parallel, keep Code objects as-is
globalsPromises = globalsCode.map(/*#__PURE__*/function () {
var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(globalItem) {
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
if (!(typeof globalItem === 'string')) {
_context2.next = 12;
break;
}
_context2.prev = 1;
_context2.next = 4;
return loadCodeMeta(globalItem);
case 4:
return _context2.abrupt("return", _context2.sent);
case 7:
_context2.prev = 7;
_context2.t0 = _context2["catch"](1);
throw new Error("Failed to load globalsCode from URL: ".concat(globalItem, ". Error: ").concat(JSON.stringify(_context2.t0)));
case 10:
_context2.next = 13;
break;
case 12:
return _context2.abrupt("return", globalItem);
case 13:
case "end":
return _context2.stop();
}
}, _callee2, null, [[1, 7]]);
}));
return function (_x15) {
return _ref.apply(this, arguments);
};
}());
_context4.next = 102;
return Promise.all(globalsPromises);
case 102:
globalsCodeObjects = _context4.sent;
case 103:
if (globalsCodeObjects && globalsCodeObjects.length > 0) {
resolvedGlobalsCode = [];
_iterator = _createForOfIteratorHelper(globalsCodeObjects);
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
codeObj = _step.value;
// Only use the variant that matches the current initialVariant
targetVariant = codeObj[initialVariant];
if (targetVariant) {
resolvedGlobalsCode.push(targetVariant);
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
}
_context4.prev = 104;
_context4.next = 107;
return loadVariant(url, initialVariant, initial, sourceParser, loadSource, loadVariantMeta, undefined,
// sourceTransformers - skip transforms for fallback
{
disableTransforms: true,
// Don't apply transforms for fallback
disableParsing: !shouldHighlight,
// Only parse if highlighting is needed
globalsCode: resolvedGlobalsCode // Pass resolved globalsCode
});
case 107:
_yield$loadVariant = _context4.sent;
loadedVariant = _yield$loadVariant.code;
// Update the loaded code with the processed variant
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, initialVariant, loadedVariant));
initial = loadedVariant;
_context4.next = 116;
break;
case 113:
_context4.prev = 113;
_context4.t6 = _context4["catch"](104);
throw new Error("Failed to load initial variant using loadVariant (variant: ".concat(initialVariant, ", url: ").concat(url, "): ").concat(JSON.stringify(_context4.t6)));
case 116:
// Step 3: Collect all file names
allFileNames = new Set();
if (initial.fileName) {
allFileNames.add(initial.fileName);
}
// Add extra files from the initial variant
if (initial.extraFiles) {
Object.keys(initial.extraFiles).forEach(function (fileName) {
return allFileNames.add(fileName);
});
}
// Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
if (!fallbackUsesAllVariants) {
_context4.next = 130;
break;
}
// Determine all variants to process - use provided variants or infer from loaded code
allVariants = variants || Object.keys(loaded || {});
if (!(allVariants.length === 0)) {
_context4.next = 125;
break;
}
console.warn('No variants found for fallbackUsesAllVariants processing');
_context4.next = 130;
break;
case 125:
// Process all required variants, not just the ones already loaded
variantPromises = allVariants.map(/*#__PURE__*/function () {
var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(variantName) {
var _loaded;
var variant, allCode, _yield$loadVariant2, _loadedVariant, fileNames;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
if (!(variantName === initialVariant)) {
_context3.next = 2;
break;
}
return _context3.abrupt("return", {
variantName: variantName,
loadedVariant: null,
fileNames: []
});
case 2:
variant = (_loaded = loaded) == null ? void 0 : _loaded[variantName]; // If variant is not loaded yet, load it first using loadCodeMeta
if (!(!variant && loadCodeMeta)) {
_context3.next = 16;
break;
}
_context3.prev = 4;
_context3.next = 7;
return loadCodeMeta(url);
case 7:
allCode = _context3.sent;
variant = allCode[variantName];
// Update loaded with all variants from loadCodeMeta
loaded = _objectSpread(_objectSpread({}, loaded), allCode);
_context3.next = 16;
break;
case 12:
_context3.prev = 12;
_context3.t0 = _context3["catch"](4);
console.warn("Failed to load code meta for variant ".concat(variantName, ": ").concat(_context3.t0));
return _context3.abrupt("return", {
variantName: variantName,
loadedVariant: null,
fileNames: []
});
case 16:
if (variant) {
_context3.next = 19;
break;
}
console.warn("Variant ".concat(variantName, " not found after loading code meta"));
return _context3.abrupt("return", {
variantName: variantName,
loadedVariant: null,
fileNames: []
});
case 19:
_context3.prev = 19;
_context3.next = 22;
return loadVariant(url, variantName, variant, sourceParser, loadSource, loadVariantMeta, undefined,
// sourceTransformers
{
disableTransforms: true,
disableParsing: !shouldHighlight,
globalsCode: globalsCodeObjects && globalsCodeObjects.length > 0 ? function () {
// Convert globalsCodeObjects to VariantCode | string for this specific variant
var variantGlobalsCode = [];
var _iterator2 = _createForOfIteratorHelper(globalsCodeObjects),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var _codeObj = _step2.value;
// Only use the variant that matches the current variantName
var _targetVariant = _codeObj[variantName];
if (_targetVariant) {
variantGlobalsCode.push(_targetVariant);
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
return variantGlobalsCode;
}() : undefined
});
case 22:
_yield$loadVariant2 = _context3.sent;
_loadedVariant = _yield$loadVariant2.code;
// Collect file names from this variant
fileNames = _loadedVariant.fileName ? [_loadedVariant.fileName] : [];
if (_loadedVariant.extraFiles) {
fileNames.push.apply(fileNames, _toConsumableArray(Object.keys(_loadedVariant.extraFiles)));
}
return _context3.abrupt("return", {
variantName: variantName,
loadedVariant: _loadedVariant,
fileNames: fileNames
});
case 29:
_context3.prev = 29;
_context3.t1 = _context3["catch"](19);
// Log but don't fail - we want to get as many file names as possible
console.warn("Failed to load variant ".concat(variantName, " for file listing: ").concat(_context3.t1));
return _context3.abrupt("return", {
variantName: variantName,
loadedVariant: null,
fileNames: []
});
case 33:
case "end":
return _context3.stop();
}
}, _callee3, null, [[4, 12], [19, 29]]);
}));
return function (_x16) {
return _ref2.apply(this, arguments);
};
}());
_context4.next = 128;
return Promise.all(variantPromises);
case 128:
variantResults = _context4.sent;
// Update loaded code and collect file names
variantResults.forEach(function (_ref3) {
var variantName = _ref3.variantName,
loadedVariant = _ref3.loadedVariant,
fileNames = _ref3.fileNames;
if (loadedVariant) {
loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, variantName, loadedVariant));
}
fileNames.forEach(function (fileName) {
return allFileNames.add(fileName);
});
});
case 130:
// Ensure we have the latest initial variant data
finalInitial = loaded[initialVariant];
if (!(!finalInitial || typeof finalInitial === 'string')) {
_context4.next = 133;
break;
}
throw new Error("Failed to process initial variant: ".concat(initialVariant));
case 133:
_context4.prev = 133;
_context4.next = 136;
return getFileSource(finalInitial, initialFilename, loadSource);
case 136:
_result2 = _context4.sent;
finalFileSource = _result2.source;
finalFilename = _result2.filename;
_context4.next = 147;
break;
case 141:
_context4.prev = 141;
_context4.t7 = _context4["catch"](133);
if (!(!finalInitial.fileName && !finalInitial.source)) {
_context4.next = 145;
break;
}
throw new Error("Cannot determine filename for initial variant \"".concat(initialVariant, "\". ") + "No fileName available in variant definition, no initialFilename provided, and no source available.");
case 145:
// Fall back to the main file with proper validation
finalFileSource = finalInitial.source || '';
finalFilename = finalInitial.fileName;
case 147:
return _context4.abrupt("return", {
code: loaded,
initialFilename: finalFilename,
initialSource: finalFileSource,
initialExtraFiles: finalInitial.extraFiles || {},
allFileNames: Array.from(allFileNames),
processedGlobalsCode: globalsCodeObjects
});
case 148:
case "end":
return _context4.stop();
}
}, _callee4, null, [[5, 11], [21, 29], [33, 40], [49, 92], [63, 71], [75, 82], [104, 113], [133, 141]]);
}));
return _loadFallbackCode.apply(this, arguments);
}