@mui/internal-docs-infra 0.1.1-alpha.1 → 0.1.1-alpha.10

package/CodeHighlighter/loadFallbackCode.js

@@ -1,10 +1,11 @@
 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 "../loaderUtils/index.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) {
@@ -16,51 +17,66 @@ function _getFileSource() {
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
-          filename = requestedFilename || variant.fileName; // If requesting the main file and we have its source
+          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 = 3;
+            _context.next = 7;
             break;
           }
           return _context.abrupt("return", {
             source: variant.source,
             filename: filename
           });
-        case 3:
+        case 7:
           if (!(filename !== variant.fileName && variant.extraFiles)) {
-            _context.next = 14;
+            _context.next = 18;
             break;
           }
           extraFile = variant.extraFiles[filename];
           if (!(extraFile && typeof extraFile !== 'string' && extraFile.source !== undefined)) {
-            _context.next = 7;
+            _context.next = 11;
             break;
           }
           return _context.abrupt("return", {
             source: extraFile.source,
             filename: filename
           });
-        case 7:
+        case 11:
           if (!(typeof extraFile === 'string' && loadSource)) {
-            _context.next = 12;
+            _context.next = 16;
             break;
           }
-          _context.next = 10;
+          _context.next = 14;
           return loadSource(extraFile);
-        case 10:
+        case 14:
           loadResult = _context.sent;
           return _context.abrupt("return", {
             source: loadResult.source,
             filename: filename
           });
-        case 12:
+        case 16:
           if (!(extraFile && typeof extraFile !== 'string' && !extraFile.source && loadSource)) {
-            _context.next = 14;
+            _context.next = 18;
             break;
           }
           throw new Error("Extra file ".concat(filename, " has no source or URL to load from"));
-        case 14:
+        case 18:
           throw new Error("File ".concat(filename, " not found in variant or cannot be loaded"));
-        case 15:
+        case 19:
         case "end":
           return _context.stop();
       }
@@ -68,55 +84,57 @@ function _getFileSource() {
   }));
   return _getFileSource.apply(this, arguments);
 }
-export function loadFallbackCode(_x4, _x5, _x6, _x7, _x8, _x9, _x0, _x1, _x10, _x11, _x12, _x13) {
+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 _callee3(url, initialVariant, loaded, shouldHighlight, fallbackUsesExtraFiles, fallbackUsesAllVariants, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, initialFilename, variants) {
-    var initial, _allFileNames, fileSource, actualFilename, result, parseSource, quickVariant, _allFileNames2, _fileSource, _actualFilename, _result, _parseSource, _yield$loadVariant, loadedVariant, allFileNames, allVariants, variantPromises, variantResults, finalInitial, finalFileSource, finalFilename, _result2;
-    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
+  _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) {
-            _context3.next = 17;
+            _context4.next = 17;
             break;
           }
           if (loadCodeMeta) {
-            _context3.next = 5;
+            _context4.next = 5;
             break;
           }
           throw new Error('"loadCodeMeta" function is required when initial variant is not provided');
         case 5:
-          _context3.prev = 5;
-          _context3.next = 8;
+          _context4.prev = 5;
+          _context4.next = 8;
           return loadCodeMeta(url);
         case 8:
-          loaded = _context3.sent;
-          _context3.next = 14;
+          loaded = _context4.sent;
+          _context4.next = 14;
           break;
         case 11:
-          _context3.prev = 11;
-          _context3.t0 = _context3["catch"](5);
-          throw new Error("Failed to load code from URL: ".concat(url, ". Error: ").concat(JSON.stringify(_context3.t0)));
+          _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) {
-            _context3.next = 17;
+            _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)) {
-            _context3.next = 45;
+            _context4.next = 48;
             break;
           }
           // Collect all file names from the loaded code
           _allFileNames = new Set();
-          _allFileNames.add(initial.fileName);
+          if (initial.fileName) {
+            _allFileNames.add(initial.fileName);
+          }
           if (initial.extraFiles) {
             Object.keys(initial.extraFiles).forEach(function (fileName) {
               return _allFileNames.add(fileName);
@@ -124,39 +142,60 @@ function _loadFallbackCode() {
           }
 
           // Get the source for the requested filename (or main file if not specified)
-          _context3.prev = 21;
-          _context3.next = 24;
+          _context4.prev = 21;
+          _context4.next = 24;
           return getFileSource(initial, initialFilename, loadSource);
         case 24:
-          result = _context3.sent;
+          result = _context4.sent;
           fileSource = result.source;
           actualFilename = result.filename;
-          _context3.next = 32;
+          _context4.next = 32;
           break;
         case 29:
-          _context3.prev = 29;
-          _context3.t1 = _context3["catch"](21);
-          throw new Error("Failed to get source for file ".concat(initialFilename || initial.fileName, " in variant ").concat(initialVariant, ": ").concat(_context3.t1));
+          _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)) {
-            _context3.next = 43;
+          if (!(shouldHighlight && typeof fileSource === 'string' && sourceParser && actualFilename)) {
+            _context4.next = 45;
             break;
           }
-          _context3.prev = 33;
-          _context3.next = 36;
+          _context4.prev = 33;
+          _context4.next = 36;
           return sourceParser;
         case 36:
-          parseSource = _context3.sent;
+          parseSource = _context4.sent;
           fileSource = parseSource(fileSource, actualFilename);
-          _context3.next = 43;
+          _context4.next = 43;
           break;
         case 40:
-          _context3.prev = 40;
-          _context3.t2 = _context3["catch"](33);
-          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(actualFilename, "): ").concat(JSON.stringify(_context3.t2)));
+          _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 === initial.fileName) {
+          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
             });
@@ -164,47 +203,49 @@ function _loadFallbackCode() {
           }
 
           // Early return - we have all the info we need
-          return _context3.abrupt("return", {
+          return _context4.abrupt("return", {
             code: loaded,
             initialFilename: actualFilename,
             initialSource: fileSource,
             initialExtraFiles: initial.extraFiles || {},
             allFileNames: Array.from(_allFileNames)
           });
-        case 45:
+        case 48:
           if (!(typeof initial === 'string')) {
-            _context3.next = 89;
+            _context4.next = 95;
             break;
           }
-          _context3.prev = 46;
+          _context4.prev = 49;
           if (!loadVariantMeta) {
-            _context3.next = 53;
+            _context4.next = 56;
             break;
           }
-          _context3.next = 50;
+          _context4.next = 53;
           return loadVariantMeta(initialVariant, initial);
-        case 50:
-          quickVariant = _context3.sent;
-          _context3.next = 54;
-          break;
         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 54:
+        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)) {
-            _context3.next = 84;
+            _context4.next = 90;
             break;
           }
           // Collect all file names from the quick load
           _allFileNames2 = new Set();
-          _allFileNames2.add(quickVariant.fileName);
+          if (quickVariant.fileName) {
+            _allFileNames2.add(quickVariant.fileName);
+          }
           if (quickVariant.extraFiles) {
             Object.keys(quickVariant.extraFiles).forEach(function (fileName) {
               return _allFileNames2.add(fileName);
@@ -212,39 +253,60 @@ function _loadFallbackCode() {
           }
 
           // Get the source for the requested filename (or main file if not specified)
-          _context3.prev = 60;
-          _context3.next = 63;
+          _context4.prev = 63;
+          _context4.next = 66;
           return getFileSource(quickVariant, initialFilename, loadSource);
-        case 63:
-          _result = _context3.sent;
+        case 66:
+          _result = _context4.sent;
           _fileSource = _result.source;
           _actualFilename = _result.filename;
-          _context3.next = 71;
+          _context4.next = 74;
           break;
-        case 68:
-          _context3.prev = 68;
-          _context3.t3 = _context3["catch"](60);
-          throw new Error("Failed to get source for file ".concat(initialFilename || quickVariant.fileName, " in variant ").concat(initialVariant, ": ").concat(_context3.t3));
         case 71:
-          if (!(shouldHighlight && typeof _fileSource === 'string' && sourceParser)) {
-            _context3.next = 82;
+          _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;
           }
-          _context3.prev = 72;
-          _context3.next = 75;
+          _context4.prev = 75;
+          _context4.next = 78;
           return sourceParser;
-        case 75:
-          _parseSource = _context3.sent;
+        case 78:
+          _parseSource = _context4.sent;
           _fileSource = _parseSource(_fileSource, _actualFilename);
-          _context3.next = 82;
+          _context4.next = 85;
           break;
-        case 79:
-          _context3.prev = 79;
-          _context3.t4 = _context3["catch"](72);
-          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(_actualFilename, "): ").concat(JSON.stringify(_context3.t4)));
         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 === quickVariant.fileName) {
+          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
             });
@@ -252,46 +314,120 @@ function _loadFallbackCode() {
           }
 
           // Early return - we have all the info we need
-          return _context3.abrupt("return", {
+          return _context4.abrupt("return", {
             code: loaded,
             initialFilename: _actualFilename,
             initialSource: _fileSource,
             initialExtraFiles: quickVariant.extraFiles || {},
             allFileNames: Array.from(_allFileNames2)
           });
-        case 84:
-          _context3.next = 89;
+        case 90:
+          _context4.next = 95;
           break;
-        case 86:
-          _context3.prev = 86;
-          _context3.t5 = _context3["catch"](46);
-          throw new Error("Failed to load initial variant code (variant: ".concat(initialVariant, ", url: ").concat(initial, "): ").concat(JSON.stringify(_context3.t5)));
-        case 89:
-          _context3.prev = 89;
-          _context3.next = 92;
+        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
+            disableParsing: !shouldHighlight,
+            // Only parse if highlighting is needed
+            globalsCode: resolvedGlobalsCode // Pass resolved globalsCode
           });
-        case 92:
-          _yield$loadVariant = _context3.sent;
+        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;
-          _context3.next = 101;
+          _context4.next = 116;
           break;
-        case 98:
-          _context3.prev = 98;
-          _context3.t6 = _context3["catch"](89);
-          throw new Error("Failed to load initial variant using loadVariant (variant: ".concat(initialVariant, ", url: ").concat(url, "): ").concat(JSON.stringify(_context3.t6)));
-        case 101:
+        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();
-          allFileNames.add(initial.fileName);
+          if (initial.fileName) {
+            allFileNames.add(initial.fileName);
+          }
 
           // Add extra files from the initial variant
           if (initial.extraFiles) {
@@ -302,32 +438,32 @@ function _loadFallbackCode() {
 
           // Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
           if (!fallbackUsesAllVariants) {
-            _context3.next = 115;
+            _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)) {
-            _context3.next = 110;
+            _context4.next = 125;
             break;
           }
           console.warn('No variants found for fallbackUsesAllVariants processing');
-          _context3.next = 115;
+          _context4.next = 130;
           break;
-        case 110:
+        case 125:
           // Process all required variants, not just the ones already loaded
           variantPromises = allVariants.map(/*#__PURE__*/function () {
-            var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(variantName) {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(variantName) {
               var _loaded;
               var variant, allCode, _yield$loadVariant2, _loadedVariant, fileNames;
-              return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-                while (1) switch (_context2.prev = _context2.next) {
+              return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
                   case 0:
                     if (!(variantName === initialVariant)) {
-                      _context2.next = 2;
+                      _context3.next = 2;
                       break;
                     }
-                    return _context2.abrupt("return", {
+                    return _context3.abrupt("return", {
                       variantName: variantName,
                       loadedVariant: null,
                       fileNames: []
@@ -335,90 +471,111 @@ function _loadFallbackCode() {
                   case 2:
                     variant = (_loaded = loaded) == null ? void 0 : _loaded[variantName]; // If variant is not loaded yet, load it first using loadCodeMeta
                     if (!(!variant && loadCodeMeta)) {
-                      _context2.next = 16;
+                      _context3.next = 16;
                       break;
                     }
-                    _context2.prev = 4;
-                    _context2.next = 7;
+                    _context3.prev = 4;
+                    _context3.next = 7;
                     return loadCodeMeta(url);
                   case 7:
-                    allCode = _context2.sent;
+                    allCode = _context3.sent;
                     variant = allCode[variantName];
                     // Update loaded with all variants from loadCodeMeta
                     loaded = _objectSpread(_objectSpread({}, loaded), allCode);
-                    _context2.next = 16;
+                    _context3.next = 16;
                     break;
                   case 12:
-                    _context2.prev = 12;
-                    _context2.t0 = _context2["catch"](4);
-                    console.warn("Failed to load code meta for variant ".concat(variantName, ": ").concat(_context2.t0));
-                    return _context2.abrupt("return", {
+                    _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) {
-                      _context2.next = 19;
+                      _context3.next = 19;
                       break;
                     }
                     console.warn("Variant ".concat(variantName, " not found after loading code meta"));
-                    return _context2.abrupt("return", {
+                    return _context3.abrupt("return", {
                       variantName: variantName,
                       loadedVariant: null,
                       fileNames: []
                     });
                   case 19:
-                    _context2.prev = 19;
-                    _context2.next = 22;
+                    _context3.prev = 19;
+                    _context3.next = 22;
                     return loadVariant(url, variantName, variant, sourceParser, loadSource, loadVariantMeta, undefined,
                     // sourceTransformers
                     {
                       disableTransforms: true,
-                      disableParsing: !shouldHighlight
+                      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 = _context2.sent;
+                    _yield$loadVariant2 = _context3.sent;
                     _loadedVariant = _yield$loadVariant2.code;
                     // Collect file names from this variant
-                    fileNames = [_loadedVariant.fileName];
+                    fileNames = _loadedVariant.fileName ? [_loadedVariant.fileName] : [];
                     if (_loadedVariant.extraFiles) {
                       fileNames.push.apply(fileNames, _toConsumableArray(Object.keys(_loadedVariant.extraFiles)));
                     }
-                    return _context2.abrupt("return", {
+                    return _context3.abrupt("return", {
                       variantName: variantName,
                       loadedVariant: _loadedVariant,
                       fileNames: fileNames
                     });
                   case 29:
-                    _context2.prev = 29;
-                    _context2.t1 = _context2["catch"](19);
+                    _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(_context2.t1));
-                    return _context2.abrupt("return", {
+                    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 _context2.stop();
+                    return _context3.stop();
                 }
-              }, _callee2, null, [[4, 12], [19, 29]]);
+              }, _callee3, null, [[4, 12], [19, 29]]);
             }));
-            return function (_x14) {
-              return _ref.apply(this, arguments);
+            return function (_x16) {
+              return _ref2.apply(this, arguments);
             };
           }());
-          _context3.next = 113;
+          _context4.next = 128;
           return Promise.all(variantPromises);
-        case 113:
-          variantResults = _context3.sent;
+        case 128:
+          variantResults = _context4.sent;
           // Update loaded code and collect file names
-          variantResults.forEach(function (_ref2) {
-            var variantName = _ref2.variantName,
-              loadedVariant = _ref2.loadedVariant,
-              fileNames = _ref2.fileNames;
+          variantResults.forEach(function (_ref3) {
+            var variantName = _ref3.variantName,
+              loadedVariant = _ref3.loadedVariant,
+              fileNames = _ref3.fileNames;
             if (loadedVariant) {
               loaded = _objectSpread(_objectSpread({}, loaded), {}, _defineProperty({}, variantName, loadedVariant));
             }
@@ -426,43 +583,50 @@ function _loadFallbackCode() {
               return allFileNames.add(fileName);
             });
           });
-        case 115:
+        case 130:
           // Ensure we have the latest initial variant data
           finalInitial = loaded[initialVariant];
           if (!(!finalInitial || typeof finalInitial === 'string')) {
-            _context3.next = 118;
+            _context4.next = 133;
             break;
           }
           throw new Error("Failed to process initial variant: ".concat(initialVariant));
-        case 118:
-          _context3.prev = 118;
-          _context3.next = 121;
+        case 133:
+          _context4.prev = 133;
+          _context4.next = 136;
           return getFileSource(finalInitial, initialFilename, loadSource);
-        case 121:
-          _result2 = _context3.sent;
+        case 136:
+          _result2 = _context4.sent;
           finalFileSource = _result2.source;
           finalFilename = _result2.filename;
-          _context3.next = 130;
+          _context4.next = 147;
           break;
-        case 126:
-          _context3.prev = 126;
-          _context3.t7 = _context3["catch"](118);
-          // If we can't get the specific file, fall back to the main file
+        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 130:
-          return _context3.abrupt("return", {
+        case 147:
+          return _context4.abrupt("return", {
             code: loaded,
             initialFilename: finalFilename,
             initialSource: finalFileSource,
             initialExtraFiles: finalInitial.extraFiles || {},
-            allFileNames: Array.from(allFileNames)
+            allFileNames: Array.from(allFileNames),
+            processedGlobalsCode: globalsCodeObjects
           });
-        case 131:
+        case 148:
         case "end":
-          return _context3.stop();
+          return _context4.stop();
       }
-    }, _callee3, null, [[5, 11], [21, 29], [33, 40], [46, 86], [60, 68], [72, 79], [89, 98], [118, 126]]);
+    }, _callee4, null, [[5, 11], [21, 29], [33, 40], [49, 92], [63, 71], [75, 82], [104, 113], [133, 141]]);
   }));
   return _loadFallbackCode.apply(this, arguments);
 }