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

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js

@@ -0,0 +1,849 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["parseImportsResult", "remaining"];
+import { parseImports } from "../loaderUtils/index.js";
+import { parseFunctionArguments, isTypeAssertion, isFunction, isGeneric, isArray, isArrowFunction, isObjectLiteral } from "./parseFunctionArguments.js";
+
+/**
+ * Parse options for create* factory call parsing
+ */
+
+/**
+ * Helper function to extract string value from parser output, removing quotes if present
+ */
+function extractStringValue(value) {
+  if (typeof value !== 'string') {
+    return String(value);
+  }
+
+  // Remove surrounding quotes if present
+  var trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+
+  // Handle template literals
+  if (trimmed.startsWith('`') && trimmed.endsWith('`')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+/**
+ * Helper function to recursively clean up structured data from parser for user consumption,
+ * removing quotes from strings and converting basic types
+ */
+function cleanStructuredData(data) {
+  // Check all structured data types first using the parser helpers
+
+  // Check for function calls
+  var functionCall = isFunction(data);
+  if (functionCall) {
+    // Build a function call string like "console.log('test')"
+    var argStr = functionCall.arguments.map(function (arg) {
+      if (Array.isArray(arg)) {
+        return arg.map(function (a) {
+          return typeof a === 'string' ? a : String(a);
+        }).join(', ');
+      }
+      return typeof arg === 'string' ? arg : String(arg);
+    }).join(', ');
+    return "".concat(functionCall.name, "(").concat(argStr, ")");
+  }
+
+  // Check for generic structures
+  var generic = isGeneric(data);
+  if (generic) {
+    // Build a generic string like "Component<{ foo: string }>"
+    var genericsStr = generic.generics.map(function (g) {
+      return typeof g === 'string' ? g : JSON.stringify(g);
+    }).join(', ');
+    if (generic.arguments && generic.arguments.length > 0) {
+      // Function with generics: Component<T>(args)
+      var argsStr = generic.arguments.map(function (p) {
+        return typeof p === 'string' ? p : String(p);
+      }).join(', ');
+      return "".concat(generic.name, "<").concat(genericsStr, ">(").concat(argsStr, ")");
+    }
+    // Type with generics: Component<T>
+    return "".concat(generic.name, "<").concat(genericsStr, ">");
+  }
+
+  // Check for type assertions
+  var typeAssertion = isTypeAssertion(data);
+  if (typeAssertion) {
+    var cleanedExpression = cleanStructuredData(typeAssertion.expression);
+    return "".concat(cleanedExpression, " as ").concat(typeAssertion.type);
+  }
+
+  // Check for arrow functions
+  var arrowFunction = isArrowFunction(data);
+  if (arrowFunction) {
+    var _argsStr = arrowFunction.args.map(function (p) {
+      return typeof p === 'string' ? p : String(p);
+    }).join(', ');
+    if (arrowFunction.types) {
+      // Typed arrow function
+      var _arrowFunction$types = _slicedToArray(arrowFunction.types, 2),
+        inputType = _arrowFunction$types[0],
+        outputType = _arrowFunction$types[1];
+      var _returnValue = cleanStructuredData(arrowFunction.returnValue);
+      return "(".concat(_argsStr, ": ").concat(inputType, "): ").concat(outputType, " => ").concat(_returnValue);
+    }
+
+    // Simple arrow function
+    var returnValue = cleanStructuredData(arrowFunction.returnValue);
+    return "(".concat(_argsStr, ") => ").concat(returnValue);
+  }
+
+  // Check for literal arrays
+  var arrayLiteral = isArray(data);
+  if (arrayLiteral) {
+    return arrayLiteral.items[0].map(cleanStructuredData);
+  }
+
+  // Check for object literals
+  var objectLiteral = isObjectLiteral(data);
+  if (objectLiteral) {
+    var cleaned = {};
+    for (var _i = 0, _Object$entries = Object.entries(objectLiteral.properties); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        value = _Object$entries$_i[1];
+      cleaned[key] = cleanStructuredData(value);
+    }
+    return cleaned;
+  }
+
+  // Handle basic types after structured data checks
+
+  if (typeof data === 'string') {
+    // First extract string value (handle quotes)
+    var extracted = extractStringValue(data);
+
+    // Then try type conversion
+    if (extracted === 'true') {
+      return true;
+    }
+    if (extracted === 'false') {
+      return false;
+    }
+
+    // Check if it's a number (but be conservative about version strings like "1.0")
+    if (/^\d+(\.\d+)?$/.test(extracted)) {
+      var num = Number(extracted);
+      if (!Number.isNaN(num) && Number.isFinite(num)) {
+        // Don't convert simple version-like patterns (e.g., "1.0", "2.0", but convert "123.45")
+        if (extracted.includes('.')) {
+          // For decimals, only convert if it's not a simple version pattern
+          // Version patterns are typically single digit followed by .0 or simple patterns
+          if (!/^\d{1,2}\.0$/.test(extracted)) {
+            return num;
+          }
+        } else {
+          // Convert all integers
+          return num;
+        }
+      }
+    }
+    return extracted;
+  }
+  if (Array.isArray(data)) {
+    // Fallback for arrays that don't match structured patterns
+    return data.map(cleanStructuredData);
+  }
+  if (data && _typeof(data) === 'object') {
+    // Fallback for objects that don't match structured patterns
+    var _cleaned = {};
+    for (var _i2 = 0, _Object$entries2 = Object.entries(data); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+        _key = _Object$entries2$_i[0],
+        _value = _Object$entries2$_i[1];
+      _cleaned[_key] = cleanStructuredData(_value);
+    }
+    return _cleaned;
+  }
+  return data;
+}
+
+/**
+ * Helper function to con    );
+  }
+
+  // Throw error if the identifier is not found in imports
+  throw new Error(
+    `Invalid variants arguments in ${functionName} call in ${filePath}. ` +
+      `Component '${typeof structuredVariants === 'string' ? structuredVariants : JSON.stringify(structuredVariants)}' is not imported. Make sure to import it first.`,
+  );
+}
+
+/**
+ * Parse variants from object representation (new format)
+ */
+function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, functionName, filePath) {
+  var demoImports = {};
+  var namedExports = {};
+  for (var _i3 = 0, _Object$entries3 = Object.entries(obj); _i3 < _Object$entries3.length; _i3++) {
+    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+      key = _Object$entries3$_i[0],
+      value = _Object$entries3$_i[1];
+    // Handle both string values and structured values (arrays for TypeScript generics)
+    var importName = void 0;
+
+    // Use type discriminators to determine the structure type
+    var typeAssertion = isTypeAssertion(value);
+    if (typeAssertion) {
+      // This is a structured type assertion: ['as', 'React.FC<Props>', 'Component']
+      // Extract the actual component name from the expression
+      var expression = typeAssertion.expression;
+      importName = typeof expression === 'string' ? expression : String(expression);
+    } else if (typeof value === 'string') {
+      // Simple string value - strip TypeScript type assertions
+      var asIndex = value.indexOf(' as ');
+      importName = asIndex !== -1 ? value.substring(0, asIndex).trim() : value.trim();
+    } else {
+      // Handle other structured types (functions, generics, arrays)
+      var functionCall = isFunction(value);
+      var generic = isGeneric(value);
+      var arrayLiteral = isArray(value);
+      if (functionCall) {
+        // Function call: ['Component', [...]]
+        importName = functionCall.name;
+      } else if (generic) {
+        // Generic: ['Component', [...], [...]]
+        importName = generic.name;
+      } else if (arrayLiteral) {
+        // Array literal: handle first element
+        var firstItem = arrayLiteral.items[0];
+        importName = typeof firstItem === 'string' ? firstItem : String(firstItem);
+      } else if (Array.isArray(value) && value.length > 0) {
+        // Fallback for unrecognized array structures
+        var componentExpression = String(value[0]);
+        var _asIndex = componentExpression.indexOf(' as ');
+        importName = _asIndex !== -1 ? componentExpression.substring(0, _asIndex).trim() : componentExpression.trim();
+      } else {
+        // Final fallback - convert to string and extract
+        var valueStr = String(value);
+        var _asIndex2 = valueStr.indexOf(' as ');
+        importName = _asIndex2 !== -1 ? valueStr.substring(0, _asIndex2).trim() : valueStr.trim();
+      }
+    }
+    if (importMap.has(importName)) {
+      demoImports[key] = importMap.get(importName);
+      namedExports[key] = namedExportsMap.get(importName);
+    } else {
+      throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(importName, "' is not imported. Make sure to import it first."));
+    }
+  }
+  return {
+    variants: demoImports,
+    namedExports: namedExports
+  };
+}
+
+/**
+ * Helper function to convert the new parseImports format to a Map
+ * that maps import names to their resolved paths
+ */
+function buildImportMap(importResult, allowExternalVariants) {
+  var importMap = new Map();
+  Object.values(importResult.relative).forEach(function (_ref) {
+    var path = _ref.path,
+      names = _ref.names;
+    names.forEach(function (_ref2) {
+      var name = _ref2.name,
+        alias = _ref2.alias;
+      // Use alias if available, otherwise use the original name
+      var nameToUse = alias || name;
+      importMap.set(nameToUse, path);
+    });
+  });
+
+  // Include external imports if allowExternalVariants is enabled
+  if (allowExternalVariants) {
+    Object.entries(importResult.externals).forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        modulePath = _ref4[0],
+        externalImport = _ref4[1];
+      if (externalImport && externalImport.names) {
+        externalImport.names.forEach(function (_ref5) {
+          var name = _ref5.name,
+            alias = _ref5.alias;
+          // Use alias if available, otherwise use the original name
+          var nameToUse = alias || name;
+          importMap.set(nameToUse, modulePath);
+        });
+      }
+    });
+  }
+  return importMap;
+}
+
+/**
+ * Helper function to build a mapping from import aliases to their original named exports
+ */
+function buildNamedExportsMap(importResult, allowExternalVariants) {
+  var namedExportsMap = new Map();
+  Object.values(importResult.relative).forEach(function (_ref6) {
+    var names = _ref6.names;
+    names.forEach(function (_ref7) {
+      var name = _ref7.name,
+        alias = _ref7.alias,
+        type = _ref7.type;
+      // Use alias if available, otherwise use the original name as key
+      var nameToUse = alias || name;
+
+      // Only map to the original export name for named imports
+      // Default imports should map to undefined since they don't have a specific named export
+      if (type === 'named') {
+        namedExportsMap.set(nameToUse, name);
+      } else {
+        namedExportsMap.set(nameToUse, undefined); // undefined for default/namespace imports
+      }
+    });
+  });
+
+  // Include external imports if allowExternalVariants is enabled
+  if (allowExternalVariants) {
+    Object.entries(importResult.externals).forEach(function (_ref8) {
+      var _ref9 = _slicedToArray(_ref8, 2),
+        externalImport = _ref9[1];
+      if (externalImport && externalImport.names) {
+        externalImport.names.forEach(function (_ref0) {
+          var name = _ref0.name,
+            alias = _ref0.alias,
+            type = _ref0.type;
+          // Use alias if available, otherwise use the original name as key
+          var nameToUse = alias || name;
+
+          // Only map to the original export name for named imports
+          // Default imports should map to undefined since they don't have a specific named export
+          if (type === 'named') {
+            namedExportsMap.set(nameToUse, name);
+          } else {
+            namedExportsMap.set(nameToUse, undefined); // undefined for default/namespace imports
+          }
+        });
+      }
+    });
+  }
+  return namedExportsMap;
+}
+/**
+ * Parses a variants object using pre-parsed structured data
+ */
+function parseVariantsObjectFromStructured(structuredData, importMap, namedExportsMap, functionName, filePath) {
+  var demoImports = {};
+  var namedExports = {};
+  var _iterator = _createForOfIteratorHelper(structuredData),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      // If it's a string, process it directly
+      if (typeof item === 'string') {
+        var trimmedPart = item.trim();
+
+        // Check if this part contains a colon (key: value syntax)
+        var colonIndex = trimmedPart.indexOf(':');
+        if (colonIndex !== -1) {
+          // Handle "key: value" syntax
+          var key = trimmedPart.substring(0, colonIndex).trim();
+          var valueExpression = trimmedPart.substring(colonIndex + 1).trim();
+
+          // Strip TypeScript type assertions (e.g., "Component as React.ComponentType<...>" -> "Component")
+          var asIndex = valueExpression.indexOf(' as ');
+          var importName = asIndex !== -1 ? valueExpression.substring(0, asIndex).trim() : valueExpression;
+          if (importMap.has(importName)) {
+            demoImports[key] = importMap.get(importName);
+            namedExports[key] = namedExportsMap.get(importName);
+          } else {
+            throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(importName, "' is not imported. Make sure to import it first."));
+          }
+        } else {
+          // Handle shorthand syntax (just the component name)
+          var _importName = trimmedPart;
+          if (importMap.has(_importName)) {
+            demoImports[_importName] = importMap.get(_importName);
+            namedExports[_importName] = namedExportsMap.get(_importName);
+          } else {
+            throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(_importName, "' is not imported. Make sure to import it first."));
+          }
+        }
+      }
+      // If it's an array (nested structure), we don't expect this in variants parsing
+      // but we could handle it if needed in the future
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    variants: demoImports,
+    namedExports: namedExports
+  };
+}
+
+/**
+ * Parses variants argument using pre-parsed structured data
+ */
+function parseVariantsArgumentFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath) {
+  // If it's an object (Record<string, string>)
+  if (_typeof(structuredVariants) === 'object' && !Array.isArray(structuredVariants)) {
+    // We have an object with key-value pairs
+    return parseVariantsObjectFromObject(structuredVariants, importMap, namedExportsMap, functionName, filePath);
+  }
+
+  // If it's an array (object literal parsed into structured data)
+  if (Array.isArray(structuredVariants)) {
+    // Parse the object contents using structured data
+    return parseVariantsObjectFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath);
+  }
+
+  // If it's a single identifier string
+  if (typeof structuredVariants === 'string') {
+    var componentName = structuredVariants.trim();
+    if (importMap.has(componentName)) {
+      return {
+        variants: {
+          Default: importMap.get(componentName)
+        },
+        namedExports: {
+          Default: namedExportsMap.get(componentName)
+        }
+      };
+    }
+
+    // Throw error if the identifier is not found in imports
+    throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Component '".concat(componentName, "' is not imported. Make sure to import it first."));
+  }
+
+  // If we reach here, the structured data format is unexpected
+  throw new Error("Unexpected structured variants format in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected string, array, or object but got: ".concat(_typeof(structuredVariants)));
+}
+
+/**
+ * Validates that a URL argument follows the expected convention
+ */
+function validateUrlArgument(url, functionName, filePath) {
+  var trimmedUrl = url.trim();
+
+  // Only accept import.meta.url
+  if (trimmedUrl === 'import.meta.url') {
+    return;
+  }
+
+  // For error messages, show the argument as parsed by parseFunctionArguments
+  // Simple string literals preserve their quotes, complex expressions are shown as parsed
+  var errorUrl = trimmedUrl;
+  throw new Error("Invalid URL argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 'import.meta.url' but got: ".concat(errorUrl));
+}
+
+/**
+ * Validates that a variants argument is either an object mapping to imports or a single identifier
+ */
+function validateVariantsArgument(structuredVariants, functionName, filePath) {
+  if (!structuredVariants) {
+    throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object mapping variant names to imports or a single component identifier.");
+  }
+
+  // Check if it's a valid single identifier (string)
+  if (typeof structuredVariants === 'string') {
+    var trimmed = structuredVariants.trim();
+    if (!trimmed || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(trimmed)) {
+      throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected a valid component identifier, but got: \"".concat(trimmed, "\""));
+    }
+    return; // Valid identifier
+  }
+
+  // Check if it's an array (object literal structure) or object (parsed key-value pairs)
+  if (Array.isArray(structuredVariants) || _typeof(structuredVariants) === 'object' && structuredVariants !== null) {
+    return; // Valid object structure
+  }
+  throw new Error("Invalid variants argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object mapping variant names to imports or a single component identifier, but got: ".concat(_typeof(structuredVariants)));
+}
+
+/**
+ * Parses a file to extract a single create* factory call and its variants and options
+ * Returns the parsed result with remaining content included
+ * Returns null if no create* call is found
+ */
+export function parseCreateFactoryCall(_x, _x2) {
+  return _parseCreateFactoryCall.apply(this, arguments);
+}
+
+/**
+ * Parses all create* factory calls in a file sequentially
+ * Returns a record of export names mapped to their parsed factory calls
+ */
+function _parseCreateFactoryCall() {
+  _parseCreateFactoryCall = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(code, filePath) {
+    var parseOptions,
+      parseImportsResult,
+      createFactoryMatches,
+      match,
+      functionName,
+      fullMatch,
+      urlArg,
+      structuredVariants,
+      optionsStructured,
+      hasOptions,
+      argumentsStartIndex,
+      argumentsEndIndex,
+      allowExternalVariants,
+      importMap,
+      namedExportsMap,
+      externals,
+      _parseOptions$metadat2,
+      metadataOnly,
+      url,
+      variants,
+      namedExports,
+      variantsResult,
+      options,
+      skipPrecomputeValue,
+      transformedExternals,
+      _i4,
+      _Object$entries4,
+      _Object$entries4$_i,
+      modulePath,
+      externalImport,
+      remaining,
+      parsed,
+      _args = arguments,
+      _t;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          parseOptions = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+          parseImportsResult = _args.length > 3 ? _args[3] : undefined;
+          // Find all create* calls in the code
+          createFactoryMatches = findCreateFactoryCalls(code, filePath, parseOptions); // Enforce single create* call per file unless allowMultipleFactories is true
+          if (!(!parseOptions.allowMultipleFactories && createFactoryMatches.length > 1)) {
+            _context.n = 1;
+            break;
+          }
+          throw new Error("Multiple create* factory calls found in ".concat(filePath, ". Only one create* call per file is supported. Found ").concat(createFactoryMatches.length, " calls."));
+        case 1:
+          if (!(createFactoryMatches.length === 0)) {
+            _context.n = 2;
+            break;
+          }
+          return _context.a(2, null);
+        case 2:
+          match = createFactoryMatches[0];
+          functionName = match.functionName, fullMatch = match.fullMatch, urlArg = match.urlArg, structuredVariants = match.structuredVariants, optionsStructured = match.optionsStructured, hasOptions = match.hasOptions, argumentsStartIndex = match.argumentsStartIndex, argumentsEndIndex = match.argumentsEndIndex; // Get import mappings from precomputed imports or parse them
+          _t = parseImportsResult;
+          if (_t) {
+            _context.n = 4;
+            break;
+          }
+          _context.n = 3;
+          return parseImports(code, filePath);
+        case 3:
+          _t = _context.v;
+        case 4:
+          parseImportsResult = _t;
+          allowExternalVariants = parseOptions.allowExternalVariants || false;
+          importMap = buildImportMap(parseImportsResult, allowExternalVariants);
+          namedExportsMap = buildNamedExportsMap(parseImportsResult, allowExternalVariants);
+          externals = parseImportsResult.externals; // Validate URL argument
+          validateUrlArgument(urlArg, functionName, filePath);
+
+          // Validate variants argument (skip in metadata-only mode)
+          _parseOptions$metadat2 = parseOptions.metadataOnly, metadataOnly = _parseOptions$metadat2 === void 0 ? false : _parseOptions$metadat2;
+          if (!metadataOnly && structuredVariants !== undefined) {
+            validateVariantsArgument(structuredVariants, functionName, filePath);
+          }
+
+          // Extract URL (typically import.meta.url)
+          url = urlArg.trim(); // Resolve variants using structured data (skip in metadata-only mode)
+          if (!metadataOnly && structuredVariants !== undefined) {
+            variantsResult = parseVariantsArgumentFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath);
+            variants = variantsResult.variants;
+            namedExports = variantsResult.namedExports;
+          }
+
+          // Parse options object
+          // Initialize with all options from structured data, then override specific fields
+          options = optionsStructured && _typeof(optionsStructured) === 'object' ? cleanStructuredData(optionsStructured) : {}; // Override with specific processing for known fields that need special handling
+          if (optionsStructured && _typeof(optionsStructured) === 'object') {
+            if ('name' in optionsStructured) {
+              options.name = extractStringValue(optionsStructured.name);
+            }
+            if ('slug' in optionsStructured) {
+              options.slug = extractStringValue(optionsStructured.slug);
+            }
+            if ('skipPrecompute' in optionsStructured) {
+              skipPrecomputeValue = optionsStructured.skipPrecompute;
+              if (skipPrecomputeValue === 'true' || skipPrecomputeValue === true) {
+                options.skipPrecompute = true;
+              } else if (skipPrecomputeValue === 'false' || skipPrecomputeValue === false) {
+                options.skipPrecompute = false;
+              }
+            }
+
+            // Handle precompute from structured data - clean for user consumption
+            if ('precompute' in optionsStructured) {
+              options.precompute = cleanStructuredData(optionsStructured.precompute);
+            }
+          }
+
+          // Transform externals from parseImports format to simplified format
+          // Only include side-effect imports (where names array is empty)
+          transformedExternals = {};
+          for (_i4 = 0, _Object$entries4 = Object.entries(externals); _i4 < _Object$entries4.length; _i4++) {
+            _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2), modulePath = _Object$entries4$_i[0], externalImport = _Object$entries4$_i[1];
+            // Only include side-effect imports (empty names array)
+            if (externalImport.names.length === 0) {
+              transformedExternals[modulePath] = []; // Empty array for side-effect imports
+            }
+          }
+
+          // Calculate remaining content after the function call
+          remaining = code.substring(match.functionEndIndex + 1);
+          parsed = {
+            functionName: functionName,
+            url: url,
+            variants: variants,
+            namedExports: namedExports,
+            options: options,
+            fullMatch: fullMatch,
+            hasOptions: hasOptions,
+            externals: transformedExternals,
+            argumentsStartIndex: argumentsStartIndex,
+            argumentsEndIndex: argumentsEndIndex,
+            // Add structured data for serialization - this preserves quotes for proper output
+            structuredUrl: urlArg,
+            structuredVariants: structuredVariants,
+            structuredOptions: optionsStructured,
+            // Use original structured data, not cleaned options
+            remaining: remaining,
+            parseImportsResult: parseImportsResult // Include import data for reuse
+          };
+          return _context.a(2, parsed);
+      }
+    }, _callee);
+  }));
+  return _parseCreateFactoryCall.apply(this, arguments);
+}
+export function parseAllCreateFactoryCalls(_x3, _x4) {
+  return _parseAllCreateFactoryCalls.apply(this, arguments);
+}
+
+/**
+ * Finds create* factory calls in code, handling multiline cases
+ */
+function _parseAllCreateFactoryCalls() {
+  _parseAllCreateFactoryCalls = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(code, filePath) {
+    var parseOptions,
+      results,
+      currentCode,
+      parseImportsResult,
+      result,
+      exportMatch,
+      exportName,
+      unusedResult,
+      unusedRemaining,
+      parsedFactory,
+      _args2 = arguments;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          parseOptions = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+          results = {}; // Process the code sequentially, reusing import data from the first call
+          currentCode = code;
+        case 1:
+          if (!currentCode.trim()) {
+            _context2.n = 5;
+            break;
+          }
+          _context2.n = 2;
+          return parseCreateFactoryCall(currentCode, filePath, _extends(_extends({}, parseOptions), {}, {
+            allowMultipleFactories: true
+          }),
+          // Allow multiple factories for this function
+          parseImportsResult // undefined for first call, reused for subsequent calls
+          );
+        case 2:
+          result = _context2.v;
+          if (result) {
+            _context2.n = 3;
+            break;
+          }
+          return _context2.a(3, 5);
+        case 3:
+          // Extract export name from the function call context
+          exportMatch = currentCode.match(/export\s+const\s+(\w+)\s*=/);
+          exportName = (exportMatch == null ? void 0 : exportMatch[1]) || 'unknown'; // Capture import data from the first successful call for reuse
+          parseImportsResult = result.parseImportsResult || parseImportsResult;
+
+          // Remove the parseImportsResult before storing (we don't need it in the final result)
+          unusedResult = result.parseImportsResult, unusedRemaining = result.remaining, parsedFactory = _objectWithoutPropertiesLoose(result, _excluded);
+          results[exportName] = parsedFactory;
+
+          // Move to the remaining code after this export
+          if (result.remaining) {
+            _context2.n = 4;
+            break;
+          }
+          currentCode = '';
+          return _context2.a(3, 5);
+        case 4:
+          currentCode = result.remaining;
+          _context2.n = 1;
+          break;
+        case 5:
+          return _context2.a(2, results);
+      }
+    }, _callee2);
+  }));
+  return _parseAllCreateFactoryCalls.apply(this, arguments);
+}
+function findCreateFactoryCalls(code, filePath) {
+  var parseOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var results = [];
+
+  // Find all create* function calls
+  var createFactoryRegex = /\b(create\w*)\s*\(/g;
+  var match = createFactoryRegex.exec(code);
+  while (match !== null) {
+    var functionName = match[1];
+    var startIndex = match.index;
+    var parenIndex = match.index + match[0].length - 1; // Position of opening parenthesis
+
+    // Find the matching closing parenthesis
+    var parenCount = 0;
+    var endIndex = -1;
+    for (var i = parenIndex; i < code.length; i += 1) {
+      if (code[i] === '(') {
+        parenCount += 1;
+      } else if (code[i] === ')') {
+        parenCount -= 1;
+        if (parenCount === 0) {
+          endIndex = i;
+          break;
+        }
+      }
+    }
+    if (endIndex === -1) {
+      match = createFactoryRegex.exec(code);
+      continue;
+    }
+    var fullMatch = code.substring(startIndex, endIndex + 1);
+    var content = code.substring(parenIndex + 1, endIndex);
+
+    // Split by commas at the top level, handling nested structures and comments
+    var structured = parseFunctionArguments(content);
+
+    // Validate the function follows the convention
+    var _parseOptions$metadat = parseOptions.metadataOnly,
+      metadataOnly = _parseOptions$metadat === void 0 ? false : _parseOptions$metadat;
+    if (metadataOnly) {
+      // For metadata-only mode: expect 1-2 arguments (url, options?)
+      if (structured.length < 1 || structured.length > 2) {
+        throw new Error("Invalid ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 1-2 arguments (url, options?) but got ".concat(structured.length, " arguments. ") + "In metadata-only mode, functions should follow: create*(url, options?)");
+      }
+    } else if (structured.length < 2 || structured.length > 3) {
+      // Normal mode: expect 2-3 arguments (url, variants, options?)
+      throw new Error("Invalid ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected 2-3 arguments (url, variants, options?) but got ".concat(structured.length, " arguments. ") + "Functions starting with 'create' must follow the convention: create*(url, variants, options?)");
+    }
+
+    // Handle different argument patterns based on mode
+    if (metadataOnly) {
+      // Metadata-only mode: expect 1-2 arguments (url, options?)
+      if (structured.length === 1) {
+        var _structured = _slicedToArray(structured, 1),
+          urlArg = _structured[0];
+        results.push({
+          functionName: functionName,
+          fullMatch: fullMatch,
+          urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
+          structuredVariants: undefined,
+          // No variants in metadata-only mode
+          optionsStructured: undefined,
+          hasOptions: false,
+          functionStartIndex: startIndex,
+          functionEndIndex: endIndex,
+          argumentsStartIndex: parenIndex + 1,
+          argumentsEndIndex: endIndex
+        });
+      } else if (structured.length === 2) {
+        var _structured2 = _slicedToArray(structured, 2),
+          _urlArg = _structured2[0],
+          optionsStructured = _structured2[1];
+
+        // Options should be an object
+        if (typeof optionsStructured === 'string' || !Array.isArray(optionsStructured) && _typeof(optionsStructured) !== 'object') {
+          throw new Error("Invalid options argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but got: ".concat(typeof optionsStructured === 'string' ? optionsStructured : JSON.stringify(optionsStructured)));
+        }
+        results.push({
+          functionName: functionName,
+          fullMatch: fullMatch,
+          urlArg: typeof _urlArg === 'string' ? _urlArg.trim() : String(_urlArg),
+          structuredVariants: undefined,
+          // No variants in metadata-only mode
+          optionsStructured: _typeof(optionsStructured) === 'object' && optionsStructured !== null ? optionsStructured : undefined,
+          hasOptions: true,
+          functionStartIndex: startIndex,
+          functionEndIndex: endIndex,
+          argumentsStartIndex: parenIndex + 1,
+          argumentsEndIndex: endIndex
+        });
+      }
+    }
+
+    // Normal mode: expect 2-3 arguments (url, variants, options?)
+    if (!metadataOnly) {
+      if (structured.length === 2) {
+        var _structured3 = _slicedToArray(structured, 2),
+          _urlArg2 = _structured3[0],
+          variantsStructured = _structured3[1];
+        results.push({
+          functionName: functionName,
+          fullMatch: fullMatch,
+          urlArg: typeof _urlArg2 === 'string' ? _urlArg2.trim() : String(_urlArg2),
+          structuredVariants: variantsStructured,
+          optionsStructured: undefined,
+          hasOptions: false,
+          // No options argument was provided
+          functionStartIndex: startIndex,
+          functionEndIndex: endIndex,
+          argumentsStartIndex: parenIndex + 1,
+          argumentsEndIndex: endIndex
+        });
+      } else if (structured.length === 3) {
+        var _structured4 = _slicedToArray(structured, 3),
+          _urlArg3 = _structured4[0],
+          _variantsStructured = _structured4[1],
+          _optionsStructured = _structured4[2];
+
+        // Options should be an object (Record<string, any>) or an empty object
+        if (typeof _optionsStructured === 'string' || !Array.isArray(_optionsStructured) && _typeof(_optionsStructured) !== 'object') {
+          throw new Error("Invalid options argument in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected an object but got: ".concat(typeof _optionsStructured === 'string' ? _optionsStructured : JSON.stringify(_optionsStructured)));
+        }
+        results.push({
+          functionName: functionName,
+          fullMatch: fullMatch,
+          urlArg: typeof _urlArg3 === 'string' ? _urlArg3.trim() : String(_urlArg3),
+          structuredVariants: _variantsStructured,
+          optionsStructured: _typeof(_optionsStructured) === 'object' && _optionsStructured !== null ? _optionsStructured : undefined,
+          hasOptions: true,
+          // Options argument was provided
+          functionStartIndex: startIndex,
+          functionEndIndex: endIndex,
+          argumentsStartIndex: parenIndex + 1,
+          argumentsEndIndex: endIndex
+        });
+      }
+    }
+    match = createFactoryRegex.exec(code);
+  }
+  return results;
+}