@mui/internal-docs-infra
Version:
MUI Infra - internal documentation creation tools.
263 lines (255 loc) • 12 kB
JavaScript
import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
import _typeof from "@babel/runtime/helpers/esm/typeof";
import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import { toText } from 'hast-util-to-text';
import { transformParsedSource } from "./transformParsedSource.js";
/**
* Pure function to identify which variants need transformation.
* Returns entries of variants that have transforms requiring processing.
*/
export function getVariantsToTransform(parsedCode) {
return Object.entries(parsedCode).filter(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
variantCode = _ref2[1];
if (!variantCode || _typeof(variantCode) !== 'object') {
return false;
}
// Check if main source has transforms and needs processing
var mainSourceNeedsTransform = variantCode.transforms && variantCode.source && typeof variantCode.source !== 'string' && !('hastJson' in variantCode.source);
// Check if any extraFiles have transforms and need processing
var extraFilesNeedTransform = variantCode.extraFiles ? Object.values(variantCode.extraFiles).some(function (fileContent) {
return _typeof(fileContent) === 'object' && fileContent && fileContent.transforms && fileContent.source && typeof fileContent.source !== 'string' && !('hastJson' in fileContent.source);
}) : false;
return mainSourceNeedsTransform || extraFilesNeedTransform;
});
}
/**
* Pure function to get available transforms from a specific variant.
* Only includes transforms that have actual deltas (file changes), not just filename changes.
*/
export function getAvailableTransforms(parsedCode, variantName) {
var currentVariant = parsedCode == null ? void 0 : parsedCode[variantName];
if (!currentVariant || _typeof(currentVariant) !== 'object') {
return [];
}
var transforms = new Set();
// Check main variant transforms
if (currentVariant.transforms) {
Object.keys(currentVariant.transforms).forEach(function (transformKey) {
var transformData = currentVariant.transforms[transformKey];
// Only include transforms that have actual deltas (file changes)
// Check if delta exists and is not empty
if (transformData && _typeof(transformData) === 'object' && 'delta' in transformData) {
var delta = transformData.delta;
// Check if delta has meaningful content (not just an empty object)
var hasContent = delta && _typeof(delta) === 'object' && Object.keys(delta).length > 0;
if (hasContent) {
transforms.add(transformKey);
}
}
});
}
// Check extraFiles for transforms with deltas
if (currentVariant.extraFiles) {
Object.values(currentVariant.extraFiles).forEach(function (fileData) {
if (fileData && _typeof(fileData) === 'object' && 'transforms' in fileData && fileData.transforms) {
Object.keys(fileData.transforms).forEach(function (transformKey) {
var transformData = fileData.transforms[transformKey];
// Only include transforms that have actual deltas (file changes)
// Check if delta exists and is not empty
if (transformData && _typeof(transformData) === 'object' && 'delta' in transformData) {
var delta = transformData.delta;
// Check if delta has meaningful content (not just an empty object)
var hasContent = delta && _typeof(delta) === 'object' && Object.keys(delta).length > 0;
if (hasContent) {
transforms.add(transformKey);
}
}
});
}
});
}
return Array.from(transforms);
}
/**
* Pure async function to transform a single variant's code and extraFiles.
* Returns the transformed variant or the original if transformation fails.
*/
export function transformVariant(_x, _x2, _x3) {
return _transformVariant.apply(this, arguments);
}
/**
* Pure async function to apply transformations to all variants that need them.
* Returns the enhanced code with computed transforms.
*/
function _transformVariant() {
_transformVariant = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(variant, variantCode, parseSource) {
var mainTransformResult, transformedExtraFiles, hastNodes, sourceString, transformedVariant;
return _regeneratorRuntime().wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
if (!(_typeof(variantCode) !== 'object' || !variantCode)) {
_context2.next = 2;
break;
}
return _context2.abrupt("return", variantCode);
case 2:
if (!(variantCode.transforms && variantCode.source && typeof variantCode.source !== 'string' && !('hastJson' in variantCode.source))) {
_context2.next = 8;
break;
}
hastNodes = variantCode.source;
sourceString = toText(hastNodes, {
whitespace: 'pre'
});
_context2.next = 7;
return transformParsedSource(sourceString, hastNodes, variant,
// fileName
variantCode.transforms, parseSource);
case 7:
mainTransformResult = _context2.sent;
case 8:
if (!variantCode.extraFiles) {
_context2.next = 12;
break;
}
_context2.next = 11;
return Promise.all(Object.entries(variantCode.extraFiles).map(/*#__PURE__*/function () {
var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref3) {
var _ref5, fileName, fileContent, extraHastNodes, extraSourceString, extraTransformResult;
return _regeneratorRuntime().wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_ref5 = _slicedToArray(_ref3, 2), fileName = _ref5[0], fileContent = _ref5[1];
if (!(_typeof(fileContent) === 'object' && fileContent && fileContent.transforms && fileContent.source && typeof fileContent.source !== 'string' && !('hastJson' in fileContent.source))) {
_context.next = 15;
break;
}
_context.prev = 2;
extraHastNodes = fileContent.source;
extraSourceString = toText(extraHastNodes, {
whitespace: 'pre'
});
_context.next = 7;
return transformParsedSource(extraSourceString, extraHastNodes, fileName, fileContent.transforms, parseSource);
case 7:
extraTransformResult = _context.sent;
return _context.abrupt("return", [fileName, _objectSpread(_objectSpread({}, fileContent), {}, {
transforms: extraTransformResult
})]);
case 11:
_context.prev = 11;
_context.t0 = _context["catch"](2);
console.error("Failed to transform extraFile ".concat(fileName, ":"), _context.t0);
return _context.abrupt("return", [fileName, fileContent]);
case 15:
return _context.abrupt("return", [fileName, fileContent]);
case 16:
case "end":
return _context.stop();
}
}, _callee, null, [[2, 11]]);
}));
return function (_x6) {
return _ref4.apply(this, arguments);
};
}())).then(function (entries) {
return Object.fromEntries(entries);
});
case 11:
transformedExtraFiles = _context2.sent;
case 12:
// Update the variant with the computed results
transformedVariant = _objectSpread(_objectSpread(_objectSpread({}, variantCode), mainTransformResult && {
transforms: mainTransformResult
}), transformedExtraFiles && {
extraFiles: transformedExtraFiles
});
return _context2.abrupt("return", transformedVariant);
case 14:
case "end":
return _context2.stop();
}
}, _callee2);
}));
return _transformVariant.apply(this, arguments);
}
export function applyTransforms(_x4, _x5) {
return _applyTransforms.apply(this, arguments);
}
function _applyTransforms() {
_applyTransforms = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(parsedCode, parseSource) {
var variantsToTransform, results, enhancedCode, _iterator, _step, _step$value, variant, transformedVariant;
return _regeneratorRuntime().wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
variantsToTransform = getVariantsToTransform(parsedCode);
if (!(variantsToTransform.length === 0)) {
_context4.next = 3;
break;
}
return _context4.abrupt("return", parsedCode);
case 3:
_context4.next = 5;
return Promise.all(variantsToTransform.map(/*#__PURE__*/function () {
var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref6) {
var _ref8, variant, variantCode, transformedVariant;
return _regeneratorRuntime().wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
_ref8 = _slicedToArray(_ref6, 2), variant = _ref8[0], variantCode = _ref8[1];
_context3.prev = 1;
_context3.next = 4;
return transformVariant(variant, variantCode, parseSource);
case 4:
transformedVariant = _context3.sent;
return _context3.abrupt("return", {
variant: variant,
transformedVariant: transformedVariant
});
case 8:
_context3.prev = 8;
_context3.t0 = _context3["catch"](1);
// Keep original variant if transformation fails
console.error("Failed to transform variant ".concat(variant, ":"), _context3.t0);
return _context3.abrupt("return", {
variant: variant,
transformedVariant: variantCode
});
case 12:
case "end":
return _context3.stop();
}
}, _callee3, null, [[1, 8]]);
}));
return function (_x7) {
return _ref7.apply(this, arguments);
};
}()));
case 5:
results = _context4.sent;
// Apply the transformations to create the enhanced code
enhancedCode = _objectSpread({}, parsedCode);
_iterator = _createForOfIteratorHelper(results);
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
_step$value = _step.value, variant = _step$value.variant, transformedVariant = _step$value.transformedVariant;
enhancedCode[variant] = transformedVariant;
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
return _context4.abrupt("return", enhancedCode);
case 10:
case "end":
return _context4.stop();
}
}, _callee4);
}));
return _applyTransforms.apply(this, arguments);
}