@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.5

package/esm/pipeline/loadCodeVariant/addCodeVariantPaths.js

@@ -1,5 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
 /**
  * Add path utility to add path property to each file in a variant
  * Uses calculateMainFilePath utility and URL resolution for simplified path calculation
@@ -11,31 +9,32 @@ import { calculateMainFilePath } from "./calculateMainFilePath.js";
  * Add flat paths to all files in a variant
  */
 export function addPathsToVariant(variant) {
-  var url = variant.url || '';
-  var fileName = variant.fileName || '';
+  const url = variant.url || '';
+  const fileName = variant.fileName || '';
 
   // Calculate actual back navigation needed based on extraFiles
-  var backNavResult = variant.extraFiles ? calculateMaxBackNavigation(variant.extraFiles) : {
+  const backNavResult = variant.extraFiles ? calculateMaxBackNavigation(variant.extraFiles) : {
     maxBackNavigation: 0,
     maxSourceBackNavigation: 0
   };
 
   // Create a synthetic URL for variants without URL to ensure consistent processing
-  var effectiveUrl = url;
+  let effectiveUrl = url;
   if (!url && fileName) {
-    effectiveUrl = "file:///".concat(fileName);
+    effectiveUrl = `file:///${fileName}`;
   }
 
   // Calculate main file path using only the back navigation needed by source files
-  var mainFileUrl = effectiveUrl ? calculateMainFilePath(effectiveUrl, backNavResult.maxBackNavigation, backNavResult.maxSourceBackNavigation, variant.metadataPrefix, fileName || undefined // Only pass fileName if it's not empty
+  const mainFileUrl = effectiveUrl ? calculateMainFilePath(effectiveUrl, backNavResult.maxBackNavigation, backNavResult.maxSourceBackNavigation, variant.metadataPrefix, fileName || undefined // Only pass fileName if it's not empty
   ) : undefined;
 
   // Extract just the path part from the file:// URL and remove leading slash
-  var path = mainFileUrl ? new URL(mainFileUrl).pathname.slice(1) : undefined;
-  return _extends(_extends({}, variant), {}, {
-    path: path,
-    extraFiles: calculateExtraFilesPaths(variant.extraFiles, mainFileUrl || "file:///".concat(backNavResult.maxBackNavigation > 0 ? "".concat(createSyntheticDirectories(backNavResult.maxBackNavigation).join('/'), "/") : '', "temp.txt"))
-  });
+  const path = mainFileUrl ? new URL(mainFileUrl).pathname.slice(1) : undefined;
+  return {
+    ...variant,
+    path,
+    extraFiles: calculateExtraFilesPaths(variant.extraFiles, mainFileUrl || `file:///${backNavResult.maxBackNavigation > 0 ? `${createSyntheticDirectories(backNavResult.maxBackNavigation).join('/')}/` : ''}temp.txt`)
+  };
 }
 
 /**
@@ -45,24 +44,25 @@ function calculateExtraFilesPaths(extraFiles, mainFileUrl) {
   if (!extraFiles) {
     return undefined;
   }
-  var result = {};
-  for (var _i = 0, _Object$entries = Object.entries(extraFiles); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      relativePath = _Object$entries$_i[0],
-      fileContent = _Object$entries$_i[1];
+  const result = {};
+  for (const [relativePath, fileContent] of Object.entries(extraFiles)) {
     // Resolve the relative path against the main file URL
     try {
-      var resolvedUrl = new URL(relativePath, mainFileUrl);
-      var file = typeof fileContent === 'string' ? {
+      const resolvedUrl = new URL(relativePath, mainFileUrl);
+      const file = typeof fileContent === 'string' ? {
         source: fileContent
       } : fileContent;
-      result[relativePath] = _extends(_extends({}, file), {}, {
+      result[relativePath] = {
+        ...file,
         path: resolvedUrl.pathname.slice(1)
-      });
-    } catch (_unused) {
+      };
+    } catch {
       // If URL resolution fails, skip this file
       continue;
     }
   }
-  return _extends(_extends({}, extraFiles), result);
+  return {
+    ...extraFiles,
+    ...result
+  };
 }

package/esm/pipeline/loadCodeVariant/applyCodeTransform.js

@@ -1,4 +1,3 @@
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import { patch, clone } from 'jsondiffpatch';
 /**
  * Applies a specific transform to a variant source and returns the transformed source
@@ -9,25 +8,25 @@ import { patch, clone } from 'jsondiffpatch';
  * @throws Error if the transform key doesn't exist or patching fails
  */
 export function applyCodeTransform(source, transforms, transformKey) {
-  var transform = transforms[transformKey];
+  const transform = transforms[transformKey];
   if (!transform) {
-    throw new Error("Transform \"".concat(transformKey, "\" not found in transforms"));
+    throw new Error(`Transform "${transformKey}" not found in transforms`);
   }
 
   // Determine the format of the source and apply the appropriate transform strategy
   if (typeof source === 'string') {
     // For string sources, deltas are typically line-array based (from transformSource)
-    var sourceLines = source.split('\n');
-    var patched = patch(sourceLines, transform.delta);
+    const sourceLines = source.split('\n');
+    const patched = patch(sourceLines, transform.delta);
     if (!Array.isArray(patched)) {
-      throw new Error("Patch for transform \"".concat(transformKey, "\" did not return an array"));
+      throw new Error(`Patch for transform "${transformKey}" did not return an array`);
     }
     return patched.join('\n');
   }
 
   // For Hast node sources, deltas are typically node-based (from diffHast)
-  var sourceRoot;
-  var isHastJson = 'hastJson' in source;
+  let sourceRoot;
+  const isHastJson = 'hastJson' in source;
   if (isHastJson) {
     sourceRoot = JSON.parse(source.hastJson);
   } else {
@@ -35,9 +34,9 @@ export function applyCodeTransform(source, transforms, transformKey) {
   }
 
   // Apply the node-based delta
-  var patchedNodes = patch(clone(sourceRoot), transform.delta);
+  const patchedNodes = patch(clone(sourceRoot), transform.delta);
   if (!patchedNodes) {
-    throw new Error("Patch for transform \"".concat(transformKey, "\" returned null/undefined"));
+    throw new Error(`Patch for transform "${transformKey}" returned null/undefined`);
   }
 
   // Return in the same format as the input
@@ -58,18 +57,9 @@ export function applyCodeTransform(source, transforms, transformKey) {
  * @throws Error if any transform key doesn't exist or patching fails
  */
 export function applyCodeTransforms(source, transforms, transformKeys) {
-  var currentSource = source;
-  var _iterator = _createForOfIteratorHelper(transformKeys),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var transformKey = _step.value;
-      currentSource = applyCodeTransform(currentSource, transforms, transformKey);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  let currentSource = source;
+  for (const transformKey of transformKeys) {
+    currentSource = applyCodeTransform(currentSource, transforms, transformKey);
   }
   return currentSource;
 }

package/esm/pipeline/loadCodeVariant/calculateMainFilePath.js

@@ -1,9 +1,8 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { createSyntheticDirectories, buildPath } from "./pathUtils.js";
 export function calculateMainFilePath(url, maxBackNav, maxSourceBackNav, metadataPrefix, fileName) {
   // Handle optional parameters with defaults
-  var actualMaxSourceBackNav = maxSourceBackNav != null ? maxSourceBackNav : maxBackNav;
-  var actualMetadataPrefix = metadataPrefix != null ? metadataPrefix : '';
+  const actualMaxSourceBackNav = maxSourceBackNav ?? maxBackNav;
+  const actualMetadataPrefix = metadataPrefix ?? '';
 
   // Handle empty URL
   if (!url) {
@@ -11,15 +10,15 @@ export function calculateMainFilePath(url, maxBackNav, maxSourceBackNav, metadat
   }
 
   // Extract URL parts and filename
-  var urlSegments;
-  var filename;
-  var hasTrailingSlash = false;
+  let urlSegments;
+  let filename;
+  let hasTrailingSlash = false;
   try {
     // Try to parse as URL first
-    var urlObj = new URL(url);
+    const urlObj = new URL(url);
     hasTrailingSlash = urlObj.pathname.endsWith('/');
-    var pathSegments = urlObj.pathname.split('/').filter(Boolean);
-    var baseFilename;
+    const pathSegments = urlObj.pathname.split('/').filter(Boolean);
+    let baseFilename;
     if (hasTrailingSlash) {
       // If URL ends with /, there's no filename - all segments are path segments
       baseFilename = '';
@@ -36,73 +35,67 @@ export function calculateMainFilePath(url, maxBackNav, maxSourceBackNav, metadat
     } else {
       filename = baseFilename + urlObj.search + urlObj.hash;
       if (hasTrailingSlash && !baseFilename) {
-        filename = "".concat(filename, "/");
+        filename = `${filename}/`;
       }
     }
-  } catch (_unused) {
+  } catch {
     // Fallback to simple string parsing for relative paths
     hasTrailingSlash = url.endsWith('/');
-    var urlParts = url.split('/');
-    var _baseFilename;
+    const urlParts = url.split('/');
+    let baseFilename;
     if (hasTrailingSlash) {
       // If URL ends with /, there's no filename - all segments are path segments
-      _baseFilename = urlParts.pop() || ''; // Remove the empty string after trailing slash
-      urlSegments = urlParts.filter(function (part) {
-        return part !== '';
-      }); // Remove empty segments
+      baseFilename = urlParts.pop() || ''; // Remove the empty string after trailing slash
+      urlSegments = urlParts.filter(part => part !== ''); // Remove empty segments
     } else {
       // Normal case - last segment is the filename
-      _baseFilename = urlParts.pop() || '';
-      urlSegments = urlParts.filter(function (part) {
-        return part !== '';
-      }); // Remove empty segments
+      baseFilename = urlParts.pop() || '';
+      urlSegments = urlParts.filter(part => part !== ''); // Remove empty segments
     }
 
     // Use provided fileName or fallback to extracted baseFilename
     if (fileName !== undefined) {
       filename = fileName;
     } else {
-      filename = _baseFilename;
-      if (hasTrailingSlash && !_baseFilename) {
-        filename = "".concat(filename, "/");
+      filename = baseFilename;
+      if (hasTrailingSlash && !baseFilename) {
+        filename = `${filename}/`;
       }
     }
   }
 
   // Work with a copy of URL segments to avoid mutations
-  var remainingUrlSegments = _toConsumableArray(urlSegments);
+  const remainingUrlSegments = [...urlSegments];
 
   // Take actualMaxSourceBackNav items from the end for sourcePath
-  var sourcePath = remainingUrlSegments.splice(-actualMaxSourceBackNav, actualMaxSourceBackNav);
+  const sourcePath = remainingUrlSegments.splice(-actualMaxSourceBackNav, actualMaxSourceBackNav);
 
   // Calculate unhandledBackNav, accounting for missing sourcePath segments
-  var unhandledBackNav = maxBackNav - actualMaxSourceBackNav;
+  let unhandledBackNav = maxBackNav - actualMaxSourceBackNav;
 
   // Add any missing sourcePath segments to unhandledBackNav
-  var missingSourcePathSegments = actualMaxSourceBackNav - sourcePath.length;
+  const missingSourcePathSegments = actualMaxSourceBackNav - sourcePath.length;
   unhandledBackNav += missingSourcePathSegments;
 
   // Split actualMetadataPrefix and subtract that count from unhandledBackNav
-  var metadataPrefixSegments = actualMetadataPrefix.split('/').filter(function (part) {
-    return part !== '';
-  });
+  const metadataPrefixSegments = actualMetadataPrefix.split('/').filter(part => part !== '');
   unhandledBackNav -= metadataPrefixSegments.length;
 
   // Calculate metadataPath from remaining URL segments (what's left after sourcePath)
-  var metadataSegmentsNeeded = Math.max(0, unhandledBackNav);
-  var metadataSegmentsAvailable = Math.min(metadataSegmentsNeeded, remainingUrlSegments.length);
-  var metadataPath = remainingUrlSegments.splice(-metadataSegmentsAvailable, metadataSegmentsAvailable);
+  const metadataSegmentsNeeded = Math.max(0, unhandledBackNav);
+  const metadataSegmentsAvailable = Math.min(metadataSegmentsNeeded, remainingUrlSegments.length);
+  const metadataPath = remainingUrlSegments.splice(-metadataSegmentsAvailable, metadataSegmentsAvailable);
 
   // Update unhandledBackNav with segments we couldn't fulfill from URL
   unhandledBackNav = metadataSegmentsNeeded - metadataSegmentsAvailable;
 
   // Create synthetic directories for any remaining unhandledBackNav
-  var syntheticDirs = createSyntheticDirectories(unhandledBackNav);
+  const syntheticDirs = createSyntheticDirectories(unhandledBackNav);
 
   // Combine all parts to create the final path using buildPath utility
   // Order: [synthetic directories] + [metadataPath] + [metadataPrefix] + [sourcePath] + [filename]
-  var path = buildPath(syntheticDirs, metadataPath, metadataPrefixSegments, sourcePath, filename);
+  const path = buildPath(syntheticDirs, metadataPath, metadataPrefixSegments, sourcePath, filename);
 
   // Return as file:// URL unless the result is empty
-  return path ? "file:///".concat(path) : path;
+  return path ? `file:///${path}` : path;
 }

package/esm/pipeline/loadCodeVariant/computeHastDeltas.js

@@ -1,9 +1,3 @@
-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 { diffHast } from "./diffHast.js";
 
@@ -12,20 +6,16 @@ import { diffHast } from "./diffHast.js";
  * 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 Object.entries(parsedCode).filter(([, variantCode]) => {
+    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);
+    const 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;
+    const extraFilesNeedTransform = variantCode.extraFiles ? Object.values(variantCode.extraFiles).some(fileContent => typeof fileContent === 'object' && fileContent && fileContent.transforms && fileContent.source && typeof fileContent.source !== 'string' && !('hastJson' in fileContent.source)) : false;
     return mainSourceNeedsTransform || extraFilesNeedTransform;
   });
 }
@@ -35,22 +25,22 @@ export function getVariantsToTransform(parsedCode) {
  * 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') {
+  const currentVariant = parsedCode?.[variantName];
+  if (!currentVariant || typeof currentVariant !== 'object') {
     return [];
   }
-  var transforms = new Set();
+  const transforms = new Set();
 
   // Check main variant transforms
   if (currentVariant.transforms) {
-    Object.keys(currentVariant.transforms).forEach(function (transformKey) {
-      var transformData = currentVariant.transforms[transformKey];
+    Object.keys(currentVariant.transforms).forEach(transformKey => {
+      const 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;
+      if (transformData && typeof transformData === 'object' && 'delta' in transformData) {
+        const 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;
+        const hasContent = delta && typeof delta === 'object' && Object.keys(delta).length > 0;
         if (hasContent) {
           transforms.add(transformKey);
         }
@@ -60,16 +50,16 @@ export function getAvailableTransforms(parsedCode, variantName) {
 
   // 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];
+    Object.values(currentVariant.extraFiles).forEach(fileData => {
+      if (fileData && typeof fileData === 'object' && 'transforms' in fileData && fileData.transforms) {
+        Object.keys(fileData.transforms).forEach(transformKey => {
+          const 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;
+          if (transformData && typeof transformData === 'object' && 'delta' in transformData) {
+            const 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;
+            const hasContent = delta && typeof delta === 'object' && Object.keys(delta).length > 0;
             if (hasContent) {
               transforms.add(transformKey);
             }
@@ -85,8 +75,59 @@ export function getAvailableTransforms(parsedCode, variantName) {
  * Pure async function to transform a single variant's code and extraFiles.
  * Returns the transformed variant or the original if transformation fails.
  */
-export function computeVariantDeltas(_x, _x2, _x3) {
-  return _computeVariantDeltas.apply(this, arguments);
+export async function computeVariantDeltas(variant, variantCode, parseSource) {
+  // Type guard
+  if (typeof variantCode !== 'object' || !variantCode) {
+    return variantCode;
+  }
+  let mainTransformResult;
+  let transformedExtraFiles;
+
+  // Process main source transforms if applicable
+  if (variantCode.transforms && variantCode.source && typeof variantCode.source !== 'string' && !('hastJson' in variantCode.source)) {
+    const hastNodes = variantCode.source;
+    const sourceString = toText(hastNodes, {
+      whitespace: 'pre'
+    });
+    mainTransformResult = await diffHast(sourceString, hastNodes, variant,
+    // fileName
+    variantCode.transforms, parseSource);
+  }
+
+  // Process extraFiles transforms if applicable
+  if (variantCode.extraFiles) {
+    transformedExtraFiles = await Promise.all(Object.entries(variantCode.extraFiles).map(async ([fileName, fileContent]) => {
+      if (typeof fileContent === 'object' && fileContent && fileContent.transforms && fileContent.source && typeof fileContent.source !== 'string' && !('hastJson' in fileContent.source)) {
+        try {
+          const extraHastNodes = fileContent.source;
+          const extraSourceString = toText(extraHastNodes, {
+            whitespace: 'pre'
+          });
+          const extraTransformResult = await diffHast(extraSourceString, extraHastNodes, fileName, fileContent.transforms, parseSource);
+          return [fileName, {
+            ...fileContent,
+            transforms: extraTransformResult
+          }];
+        } catch (error) {
+          console.error(`Failed to transform extraFile ${fileName}:`, error);
+          return [fileName, fileContent];
+        }
+      }
+      return [fileName, fileContent];
+    })).then(entries => Object.fromEntries(entries));
+  }
+
+  // Update the variant with the computed results
+  const transformedVariant = {
+    ...variantCode,
+    ...(mainTransformResult && {
+      transforms: mainTransformResult
+    }),
+    ...(transformedExtraFiles && {
+      extraFiles: transformedExtraFiles
+    })
+  };
+  return transformedVariant;
 }
 
 /**
@@ -97,159 +138,40 @@ export function computeVariantDeltas(_x, _x2, _x3) {
  * @param parseSource - The parser function to parse source strings
  * @returns A promise that resolves to the code with computed transforms
  */
-function _computeVariantDeltas() {
-  _computeVariantDeltas = _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 diffHast(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 diffHast(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 _computeVariantDeltas.apply(this, arguments);
-}
-export function computeHastDeltas(_x4, _x5) {
-  return _computeHastDeltas.apply(this, arguments);
-}
-function _computeHastDeltas() {
-  _computeHastDeltas = _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 computeVariantDeltas(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);
+export async function computeHastDeltas(parsedCode, parseSource) {
+  const variantsToTransform = getVariantsToTransform(parsedCode);
+  if (variantsToTransform.length === 0) {
+    // No variants need transformation
+    return parsedCode;
+  }
+
+  // Process transformations for all variants
+  const results = await Promise.all(variantsToTransform.map(async ([variant, variantCode]) => {
+    try {
+      const transformedVariant = await computeVariantDeltas(variant, variantCode, parseSource);
+      return {
+        variant,
+        transformedVariant
+      };
+    } catch (error) {
+      // Keep original variant if transformation fails
+      console.error(`Failed to transform variant ${variant}:`, error);
+      return {
+        variant,
+        transformedVariant: variantCode
+      };
+    }
   }));
-  return _computeHastDeltas.apply(this, arguments);
+
+  // Apply the transformations to create the enhanced code
+  const enhancedCode = {
+    ...parsedCode
+  };
+  for (const {
+    variant,
+    transformedVariant
+  } of results) {
+    enhancedCode[variant] = transformedVariant;
+  }
+  return enhancedCode;
 }