@mui/internal-docs-infra 0.1.1-canary.8 → 0.2.0-alpha.1

package/esm/CodeHighlighter/transformCode.js

@@ -0,0 +1,251 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _extends from "@babel/runtime/helpers/esm/extends";
+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__*/_regenerator().m(function _callee2(variant, variantCode, parseSource) {
+    var mainTransformResult, transformedExtraFiles, hastNodes, sourceString, transformedVariant;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          if (!(_typeof(variantCode) !== 'object' || !variantCode)) {
+            _context2.n = 1;
+            break;
+          }
+          return _context2.a(2, variantCode);
+        case 1:
+          if (!(variantCode.transforms && variantCode.source && typeof variantCode.source !== 'string' && !('hastJson' in variantCode.source))) {
+            _context2.n = 3;
+            break;
+          }
+          hastNodes = variantCode.source;
+          sourceString = toText(hastNodes, {
+            whitespace: 'pre'
+          });
+          _context2.n = 2;
+          return transformParsedSource(sourceString, hastNodes, variant,
+          // fileName
+          variantCode.transforms, parseSource);
+        case 2:
+          mainTransformResult = _context2.v;
+        case 3:
+          if (!variantCode.extraFiles) {
+            _context2.n = 5;
+            break;
+          }
+          _context2.n = 4;
+          return Promise.all(Object.entries(variantCode.extraFiles).map(/*#__PURE__*/function () {
+            var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref3) {
+              var _ref5, fileName, fileContent, extraHastNodes, extraSourceString, extraTransformResult, _t;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.p = _context.n) {
+                  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.n = 4;
+                      break;
+                    }
+                    _context.p = 1;
+                    extraHastNodes = fileContent.source;
+                    extraSourceString = toText(extraHastNodes, {
+                      whitespace: 'pre'
+                    });
+                    _context.n = 2;
+                    return transformParsedSource(extraSourceString, extraHastNodes, fileName, fileContent.transforms, parseSource);
+                  case 2:
+                    extraTransformResult = _context.v;
+                    return _context.a(2, [fileName, _extends(_extends({}, fileContent), {}, {
+                      transforms: extraTransformResult
+                    })]);
+                  case 3:
+                    _context.p = 3;
+                    _t = _context.v;
+                    console.error("Failed to transform extraFile ".concat(fileName, ":"), _t);
+                    return _context.a(2, [fileName, fileContent]);
+                  case 4:
+                    return _context.a(2, [fileName, fileContent]);
+                }
+              }, _callee, null, [[1, 3]]);
+            }));
+            return function (_x6) {
+              return _ref4.apply(this, arguments);
+            };
+          }())).then(function (entries) {
+            return Object.fromEntries(entries);
+          });
+        case 4:
+          transformedExtraFiles = _context2.v;
+        case 5:
+          // Update the variant with the computed results
+          transformedVariant = _extends(_extends(_extends({}, variantCode), mainTransformResult && {
+            transforms: mainTransformResult
+          }), transformedExtraFiles && {
+            extraFiles: transformedExtraFiles
+          });
+          return _context2.a(2, transformedVariant);
+      }
+    }, _callee2);
+  }));
+  return _transformVariant.apply(this, arguments);
+}
+export function applyTransforms(_x4, _x5) {
+  return _applyTransforms.apply(this, arguments);
+}
+function _applyTransforms() {
+  _applyTransforms = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(parsedCode, parseSource) {
+    var variantsToTransform, results, enhancedCode, _iterator, _step, _step$value, variant, transformedVariant;
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.n) {
+        case 0:
+          variantsToTransform = getVariantsToTransform(parsedCode);
+          if (!(variantsToTransform.length === 0)) {
+            _context4.n = 1;
+            break;
+          }
+          return _context4.a(2, parsedCode);
+        case 1:
+          _context4.n = 2;
+          return Promise.all(variantsToTransform.map(/*#__PURE__*/function () {
+            var _ref7 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(_ref6) {
+              var _ref8, variant, variantCode, transformedVariant, _t2;
+              return _regenerator().w(function (_context3) {
+                while (1) switch (_context3.p = _context3.n) {
+                  case 0:
+                    _ref8 = _slicedToArray(_ref6, 2), variant = _ref8[0], variantCode = _ref8[1];
+                    _context3.p = 1;
+                    _context3.n = 2;
+                    return transformVariant(variant, variantCode, parseSource);
+                  case 2:
+                    transformedVariant = _context3.v;
+                    return _context3.a(2, {
+                      variant: variant,
+                      transformedVariant: transformedVariant
+                    });
+                  case 3:
+                    _context3.p = 3;
+                    _t2 = _context3.v;
+                    // Keep original variant if transformation fails
+                    console.error("Failed to transform variant ".concat(variant, ":"), _t2);
+                    return _context3.a(2, {
+                      variant: variant,
+                      transformedVariant: variantCode
+                    });
+                }
+              }, _callee3, null, [[1, 3]]);
+            }));
+            return function (_x7) {
+              return _ref7.apply(this, arguments);
+            };
+          }()));
+        case 2:
+          results = _context4.v;
+          // Apply the transformations to create the enhanced code
+          enhancedCode = _extends({}, 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.a(2, enhancedCode);
+      }
+    }, _callee4);
+  }));
+  return _applyTransforms.apply(this, arguments);
+}

package/esm/CodeHighlighter/transformParsedSource.d.ts

@@ -0,0 +1,3 @@
+import type { Nodes } from 'hast';
+import { ParseSource, Transforms } from "./types.js";
+export declare function transformParsedSource(source: string, parsedSource: Nodes, filename: string, transforms: Transforms, parseSource: ParseSource): Promise<Record<string, any>>;

package/esm/CodeHighlighter/transformParsedSource.js

@@ -0,0 +1,60 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { create, patch } from 'jsondiffpatch';
+var differ = create({
+  omitRemovedValues: true,
+  cloneDiffValues: true
+});
+export function transformParsedSource(_x, _x2, _x3, _x4, _x5) {
+  return _transformParsedSource.apply(this, arguments);
+}
+function _transformParsedSource() {
+  _transformParsedSource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source, parsedSource, filename, transforms, parseSource) {
+    var transformed;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          _context2.n = 1;
+          return Promise.all(Object.entries(transforms).map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+              var _ref3, key, transform, patched, transformedSource, parsedTransform, delta;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.n) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), key = _ref3[0], transform = _ref3[1];
+                    patched = patch(source.split('\n'), transform.delta);
+                    if (Array.isArray(patched)) {
+                      _context.n = 1;
+                      break;
+                    }
+                    throw new Error("Patch for ".concat(key, " did not return an array"));
+                  case 1:
+                    transformedSource = patched.join('\n');
+                    _context.n = 2;
+                    return parseSource(transformedSource, transform.fileName || filename);
+                  case 2:
+                    parsedTransform = _context.v;
+                    // TODO: further optimize this delta, it looks a little noisy
+                    delta = differ.diff(parsedSource, parsedTransform);
+                    return _context.a(2, _defineProperty({}, key, _extends(_extends({}, transform), {}, {
+                      delta: delta
+                    })));
+                }
+              }, _callee);
+            }));
+            return function (_x6) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 1:
+          transformed = _context2.v;
+          return _context2.a(2, Object.assign.apply(Object, [{}].concat(_toConsumableArray(transformed))));
+      }
+    }, _callee2);
+  }));
+  return _transformParsedSource.apply(this, arguments);
+}

package/esm/CodeHighlighter/transformSource.d.ts

@@ -0,0 +1,2 @@
+import type { VariantSource, SourceTransformers, Transforms } from "./types.js";
+export declare function transformSource(source: VariantSource, fileName: string, sourceTransformers: SourceTransformers): Promise<Transforms | undefined>;

package/esm/CodeHighlighter/transformSource.js

@@ -0,0 +1,103 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { create } from 'jsondiffpatch';
+import { toText } from 'hast-util-to-text';
+var differ = create({
+  omitRemovedValues: true,
+  cloneDiffValues: true
+});
+export function transformSource(_x, _x2, _x3) {
+  return _transformSource.apply(this, arguments);
+}
+function _transformSource() {
+  _transformSource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source, fileName, sourceTransformers) {
+    var transforms;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          _context2.n = 1;
+          return Promise.all(sourceTransformers.map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+              var extensions, transformer, sourceString, transformed, splitSource, _t;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.p = _context.n) {
+                  case 0:
+                    extensions = _ref.extensions, transformer = _ref.transformer;
+                    if (extensions.some(function (ext) {
+                      return fileName.endsWith(".".concat(ext));
+                    })) {
+                      _context.n = 1;
+                      break;
+                    }
+                    return _context.a(2, undefined);
+                  case 1:
+                    _context.p = 1;
+                    if (typeof source === 'string') {
+                      sourceString = source;
+                    } else if ('hastJson' in source) {
+                      sourceString = toText(JSON.parse(source.hastJson));
+                    } else {
+                      sourceString = toText(source);
+                    }
+                    _context.n = 2;
+                    return transformer(sourceString, fileName);
+                  case 2:
+                    transformed = _context.v;
+                    if (!transformed) {
+                      _context.n = 3;
+                      break;
+                    }
+                    splitSource = sourceString.split('\n');
+                    return _context.a(2, Object.keys(transformed).reduce(function (acc, key) {
+                      var delta = differ.diff(splitSource, transformed[key].source.split('\n'));
+                      acc[key] = {
+                        delta: delta,
+                        fileName: transformed[key].fileName
+                      };
+                      return acc;
+                    }, {}));
+                  case 3:
+                    return _context.a(2, undefined);
+                  case 4:
+                    _context.p = 4;
+                    _t = _context.v;
+                    throw new Error("Failed to transform source code (file: ".concat(fileName, "): ").concat(_t instanceof Error && _t.message));
+                  case 5:
+                    return _context.a(2);
+                }
+              }, _callee, null, [[1, 4]]);
+            }));
+            return function (_x4) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 1:
+          transforms = _context2.v;
+          if (!(transforms.length === 0 || transforms.every(function (t) {
+            return t === undefined;
+          }))) {
+            _context2.n = 2;
+            break;
+          }
+          return _context2.a(2, undefined);
+        case 2:
+          return _context2.a(2, transforms.reduce(function (acc, transform) {
+            if (transform) {
+              Object.entries(transform).forEach(function (_ref3) {
+                var _ref4 = _slicedToArray(_ref3, 2),
+                  key = _ref4[0],
+                  value = _ref4[1];
+                if (acc[key]) {
+                  throw new Error("Duplicate key found in source transformations: ".concat(key));
+                }
+                acc[key] = value;
+              });
+            }
+            return acc;
+          }, {}));
+      }
+    }, _callee2);
+  }));
+  return _transformSource.apply(this, arguments);
+}