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

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js

@@ -1,12 +1,10 @@
-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 _extends from "@babel/runtime/helpers/esm/extends";
 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 { parseImportsAndComments } from "../loaderUtils/index.js";
 import { parseFunctionArguments, isTypeAssertion, isFunction, isGeneric, isArray, isArrowFunction, isObjectLiteral } from "./parseFunctionArguments.js";
 
 /**
@@ -203,9 +201,17 @@ function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, function
       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();
+      // Simple string value - strip TypeScript type assertions and typeof expressions
+      var processedValue = value.trim();
+      var asIndex = processedValue.indexOf(' as ');
+      if (asIndex !== -1) {
+        processedValue = processedValue.substring(0, asIndex).trim();
+      }
+      // Handle typeof expressions
+      if (processedValue.startsWith('typeof ')) {
+        processedValue = processedValue.substring(7).trim();
+      }
+      importName = processedValue;
     } else {
       // Handle other structured types (functions, generics, arrays)
       var functionCall = isFunction(value);
@@ -247,7 +253,7 @@ function parseVariantsObjectFromObject(obj, importMap, namedExportsMap, function
 }
 
 /**
- * Helper function to convert the new parseImports format to a Map
+ * Helper function to convert the new parseImportsAndComments format to a Map
  * that maps import names to their resolved paths
  */
 function buildImportMap(importResult, allowExternalVariants) {
@@ -409,6 +415,17 @@ function parseVariantsArgumentFromStructured(structuredVariants, importMap, name
   // If it's a single identifier string
   if (typeof structuredVariants === 'string') {
     var componentName = structuredVariants.trim();
+
+    // Handle TypeScript type assertions in single component syntax
+    var asIndex = componentName.indexOf(' as ');
+    if (asIndex !== -1) {
+      componentName = componentName.substring(0, asIndex).trim();
+    }
+
+    // Handle typeof expressions in single component syntax
+    if (componentName.startsWith('typeof ')) {
+      componentName = componentName.substring(7).trim();
+    }
     if (importMap.has(componentName)) {
       return {
         variants: {
@@ -428,6 +445,56 @@ function parseVariantsArgumentFromStructured(structuredVariants, importMap, name
   throw new Error("Unexpected structured variants format in ".concat(functionName, " call in ").concat(filePath, ". ") + "Expected string, array, or object but got: ".concat(_typeof(structuredVariants)));
 }
 
+/**
+ * Parse TypeScript generic definitions to extract variants mapping
+ * e.g., "{ VariantA: ComponentA, VariantB: ComponentB }" -> { VariantA: "ComponentA", VariantB: "ComponentB" }
+ * e.g., "Component" -> { Default: "Component" }
+ */
+function parseGenericDefinitions(genericContent) {
+  if (!genericContent.trim()) {
+    return {};
+  }
+
+  // Handle object literals directly (most common case)
+  var trimmed = genericContent.trim();
+  if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+    // Parse as object literal using the existing parser
+    var _parsed = parseFunctionArguments(trimmed);
+    if (_parsed.length === 1 && _typeof(_parsed[0]) === 'object' && !Array.isArray(_parsed[0])) {
+      return _parsed[0];
+    }
+  }
+
+  // Parse the generic content using the existing parser
+  var parsed = parseFunctionArguments(genericContent);
+
+  // If it's a single object, return it
+  if (parsed.length === 1 && _typeof(parsed[0]) === 'object' && !Array.isArray(parsed[0])) {
+    return parsed[0];
+  }
+
+  // If it's a single string (single component), treat as Default variant
+  if (parsed.length === 1 && typeof parsed[0] === 'string') {
+    return {
+      Default: parsed[0]
+    };
+  }
+
+  // If it's multiple elements, try to interpret as an object
+  if (parsed.length > 1) {
+    var result = {};
+    parsed.forEach(function (item, index) {
+      if (typeof item === 'string') {
+        result["Variant".concat(index + 1)] = item;
+      } else if (_typeof(item) === 'object' && item !== null) {
+        Object.assign(result, item);
+      }
+    });
+    return result;
+  }
+  return {};
+}
+
 /**
  * Validates that a URL argument follows the expected convention
  */
@@ -485,75 +552,154 @@ export function parseCreateFactoryCall(_x, _x2) {
 function _parseCreateFactoryCall() {
   _parseCreateFactoryCall = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(code, filePath) {
     var parseOptions,
-      parseImportsResult,
-      createFactoryMatches,
+      importsAndComments,
       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,
+      secondMatch,
       parsed,
+      remaining,
       _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)) {
+          importsAndComments = _args.length > 3 ? _args[3] : undefined;
+          // Find the first create* call in the code
+          match = findFirstCreateFactoryCall(code, filePath, parseOptions); // Return null if no create* call found
+          if (match) {
             _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."));
+          return _context.a(2, null);
         case 1:
-          if (!(createFactoryMatches.length === 0)) {
+          if (parseOptions.allowMultipleFactories) {
             _context.n = 2;
             break;
           }
-          return _context.a(2, null);
+          secondMatch = findFirstCreateFactoryCall(code, filePath, parseOptions, match.functionEndIndex + 1);
+          if (!secondMatch) {
+            _context.n = 2;
+            break;
+          }
+          throw new Error("Multiple create* factory calls found in ".concat(filePath, ". Only one create* call per file is supported. Found 2 calls."));
         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;
+          _t = importsAndComments;
           if (_t) {
             _context.n = 4;
             break;
           }
           _context.n = 3;
-          return parseImports(code, filePath);
+          return parseImportsAndComments(code, filePath);
         case 3:
           _t = _context.v;
         case 4:
-          parseImportsResult = _t;
+          importsAndComments = _t;
+          _context.n = 5;
+          return processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments);
+        case 5:
+          parsed = _context.v;
+          // Calculate remaining content after the function call
+          remaining = code.substring(match.functionEndIndex + 1);
+          return _context.a(2, _extends(_extends({}, parsed), {}, {
+            remaining: remaining,
+            importsAndComments: importsAndComments // Include import data for reuse
+          }));
+      }
+    }, _callee);
+  }));
+  return _parseCreateFactoryCall.apply(this, arguments);
+}
+export function parseAllCreateFactoryCalls(_x3, _x4) {
+  return _parseAllCreateFactoryCalls.apply(this, arguments);
+}
+
+/**
+ * Processes a matched create* factory call into a ParsedCreateFactory object
+ * Handles all the common logic for validation, parsing, and transformation
+ */
+function _parseAllCreateFactoryCalls() {
+  _parseAllCreateFactoryCalls = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(code, filePath) {
+    var parseOptions,
+      results,
+      importsAndComments,
+      searchIndex,
+      match,
+      beforeMatch,
+      exportMatch,
+      exportName,
+      parsedFactory,
+      _args2 = arguments,
+      _t2;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          parseOptions = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+          results = {};
+          searchIndex = 0; // Process the code using single-pass approach
+        case 1:
+          if (!(searchIndex < code.length)) {
+            _context2.n = 6;
+            break;
+          }
+          // Find the next create* call
+          match = findFirstCreateFactoryCall(code, filePath, parseOptions, searchIndex);
+          if (match) {
+            _context2.n = 2;
+            break;
+          }
+          return _context2.a(3, 6);
+        case 2:
+          // Extract export name from the function call context
+          beforeMatch = code.substring(0, match.functionStartIndex);
+          exportMatch = beforeMatch.match(/export\s+const\s+(\w+)\s*=\s*$/m);
+          exportName = (exportMatch == null ? void 0 : exportMatch[1]) || 'unknown'; // Get import mappings from precomputed imports or parse them
+          // eslint-disable-next-line no-await-in-loop
+          _t2 = importsAndComments;
+          if (_t2) {
+            _context2.n = 4;
+            break;
+          }
+          _context2.n = 3;
+          return parseImportsAndComments(code, filePath);
+        case 3:
+          _t2 = _context2.v;
+        case 4:
+          importsAndComments = _t2;
+          _context2.n = 5;
+          return processCreateFactoryMatch(match, code, filePath, parseOptions, importsAndComments);
+        case 5:
+          parsedFactory = _context2.v;
+          results[exportName] = parsedFactory;
+
+          // Continue searching from after this function call
+          searchIndex = match.functionEndIndex + 1;
+          _context2.n = 1;
+          break;
+        case 6:
+          return _context2.a(2, results);
+      }
+    }, _callee2);
+  }));
+  return _parseAllCreateFactoryCalls.apply(this, arguments);
+}
+function processCreateFactoryMatch(_x5, _x6, _x7, _x8, _x9) {
+  return _processCreateFactoryMatch.apply(this, arguments);
+}
+/**
+ * Finds the first create* factory call in code, starting from a given index
+ * Returns null if no create* call is found
+ */
+function _processCreateFactoryMatch() {
+  _processCreateFactoryMatch = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(match, code, filePath, parseOptions, importsAndComments) {
+    var functionName, fullMatch, urlArg, structuredVariants, optionsStructured, hasOptions, argumentsStartIndex, argumentsEndIndex, allowExternalVariants, importMap, namedExportsMap, externals, _parseOptions$metadat2, metadataOnly, url, variants, namedExports, variantsResult, _variantsResult, options, skipPrecomputeValue, transformedExternals, _i5, _Object$entries4, _Object$entries4$_i, modulePath, externalImport;
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
+        case 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;
           allowExternalVariants = parseOptions.allowExternalVariants || false;
-          importMap = buildImportMap(parseImportsResult, allowExternalVariants);
-          namedExportsMap = buildNamedExportsMap(parseImportsResult, allowExternalVariants);
-          externals = parseImportsResult.externals; // Validate URL argument
+          importMap = buildImportMap(importsAndComments, allowExternalVariants);
+          namedExportsMap = buildNamedExportsMap(importsAndComments, allowExternalVariants);
+          externals = importsAndComments.externals; // Validate URL argument
           validateUrlArgument(urlArg, functionName, filePath);
 
           // Validate variants argument (skip in metadata-only mode)
@@ -564,10 +710,18 @@ function _parseCreateFactoryCall() {
 
           // 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;
+          if (!metadataOnly) {
+            if (structuredVariants !== undefined) {
+              // Use regular variants argument
+              variantsResult = parseVariantsArgumentFromStructured(structuredVariants, importMap, namedExportsMap, functionName, filePath);
+              variants = variantsResult.variants;
+              namedExports = variantsResult.namedExports;
+            } else if (match.hasGenerics && match.structuredGenerics && Object.keys(match.structuredGenerics).length > 0) {
+              // Use generics as variants when no variants argument is provided and generics are not empty
+              _variantsResult = parseVariantsArgumentFromStructured(match.structuredGenerics, importMap, namedExportsMap, functionName, filePath);
+              variants = _variantsResult.variants;
+              namedExports = _variantsResult.namedExports;
+            }
           }
 
           // Parse options object
@@ -595,20 +749,17 @@ function _parseCreateFactoryCall() {
             }
           }
 
-          // Transform externals from parseImports format to simplified format
+          // Transform externals from parseImportsAndComments 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];
+          for (_i5 = 0, _Object$entries4 = Object.entries(externals); _i5 < _Object$entries4.length; _i5++) {
+            _Object$entries4$_i = _slicedToArray(_Object$entries4[_i5], 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 = {
+          return _context3.a(2, {
             functionName: functionName,
             url: url,
             variants: variants,
@@ -624,226 +775,260 @@ function _parseCreateFactoryCall() {
             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);
+            hasGenerics: match.hasGenerics,
+            structuredGenerics: match.structuredGenerics
+          });
       }
-    }, _callee);
+    }, _callee3);
   }));
-  return _parseCreateFactoryCall.apply(this, arguments);
-}
-export function parseAllCreateFactoryCalls(_x3, _x4) {
-  return _parseAllCreateFactoryCalls.apply(this, arguments);
+  return _processCreateFactoryMatch.apply(this, arguments);
 }
+function findFirstCreateFactoryCall(code, filePath) {
+  var parseOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var startIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var createFunctionRegex = /\b(create\w*)\s*/g;
+  createFunctionRegex.lastIndex = startIndex;
+  var match = createFunctionRegex.exec(code);
+  if (!match) {
+    return null;
+  }
+  var functionName = match[1];
+  var matchStartIndex = match.index;
+  var currentIndex = match.index + match[0].length;
 
-/**
- * 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;
+  // Skip any whitespace after function name
+  while (currentIndex < code.length && /\s/.test(code[currentIndex])) {
+    currentIndex += 1;
+  }
+  if (currentIndex >= code.length) {
+    // No opening parenthesis found, try to find the next create* call
+    return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
+  }
+  var genericContent = '';
+  var hasGenerics = false;
 
-          // 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;
+  // Check if we have generics (starts with <)
+  if (code[currentIndex] === '<') {
+    hasGenerics = true;
+    var angleCount = 1;
+    var genericEndIndex = -1;
 
-          // 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;
+    // Find the matching closing angle bracket, handling nesting
+    for (var i = currentIndex + 1; i < code.length; i += 1) {
+      var _char = code[i];
+      if (_char === '<') {
+        angleCount += 1;
+      } else if (_char === '>') {
+        angleCount -= 1;
+        if (angleCount === 0) {
+          genericEndIndex = i;
           break;
         }
       }
     }
-    if (endIndex === -1) {
-      match = createFactoryRegex.exec(code);
-      continue;
+    if (genericEndIndex === -1) {
+      // Unmatched angle brackets, try to find the next create* call
+      return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
     }
-    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?)");
+    genericContent = code.substring(currentIndex + 1, genericEndIndex);
+    currentIndex = genericEndIndex + 1;
+
+    // Skip whitespace after generics
+    while (currentIndex < code.length && /\s/.test(code[currentIndex])) {
+      currentIndex += 1;
     }
+  }
 
-    // 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
-        });
+  // Now look for the opening parenthesis
+  if (currentIndex >= code.length || code[currentIndex] !== '(') {
+    // No opening parenthesis found, try to find the next create* call
+    return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
+  }
+  var parenIndex = currentIndex;
+
+  // Find the matching closing parenthesis
+  var parenCount = 0;
+  var endIndex = -1;
+  for (var _i4 = parenIndex; _i4 < code.length; _i4 += 1) {
+    if (code[_i4] === '(') {
+      parenCount += 1;
+    } else if (code[_i4] === ')') {
+      parenCount -= 1;
+      if (parenCount === 0) {
+        endIndex = _i4;
+        break;
       }
     }
+  }
+  if (endIndex === -1) {
+    // Unmatched parentheses, try to find the next create* call
+    return findFirstCreateFactoryCall(code, filePath, parseOptions, match.index + match[0].length);
+  }
+  var fullMatch = code.substring(matchStartIndex, endIndex + 1);
+  var content = code.substring(parenIndex + 1, endIndex);
+
+  // Parse generic content if present
+  var structuredGenerics;
+  if (hasGenerics) {
+    // Parse the generic content as TypeScript type definitions
+    structuredGenerics = parseGenericDefinitions(genericContent);
+  }
+
+  // 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 (hasGenerics && structured.length <= 2) {
+    // When generics are present AND we have 1-2 arguments, expect (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. ") + "Functions with TypeScript generics should follow: create*<variants>(url, options?)");
+    }
+  } else if (!hasGenerics && (structured.length < 2 || structured.length > 3)) {
     // 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({
+    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];
+      return {
+        functionName: functionName,
+        fullMatch: fullMatch,
+        urlArg: typeof urlArg === 'string' ? urlArg.trim() : String(urlArg),
+        structuredVariants: hasGenerics ? structuredGenerics : undefined,
+        // Use generics as variants in metadata-only mode
+        optionsStructured: undefined,
+        hasOptions: false,
+        hasGenerics: hasGenerics,
+        structuredGenerics: structuredGenerics,
+        functionStartIndex: matchStartIndex,
+        functionEndIndex: endIndex,
+        argumentsStartIndex: parenIndex + 1,
+        argumentsEndIndex: endIndex
+      };
+    }
+    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)));
+      }
+      return {
+        functionName: functionName,
+        fullMatch: fullMatch,
+        urlArg: typeof _urlArg === 'string' ? _urlArg.trim() : String(_urlArg),
+        structuredVariants: hasGenerics ? structuredGenerics : undefined,
+        // Use generics as variants in metadata-only mode
+        optionsStructured: _typeof(optionsStructured) === 'object' && optionsStructured !== null ? optionsStructured : undefined,
+        hasOptions: true,
+        hasGenerics: hasGenerics,
+        structuredGenerics: structuredGenerics,
+        functionStartIndex: matchStartIndex,
+        functionEndIndex: endIndex,
+        argumentsStartIndex: parenIndex + 1,
+        argumentsEndIndex: endIndex
+      };
+    }
+  } else if (!metadataOnly && hasGenerics && structured.length === 1) {
+    // Generics-only mode (non-metadata): expect 1 argument (url) - use generics as variants
+    var _structured3 = _slicedToArray(structured, 1),
+      _urlArg2 = _structured3[0];
+    return {
+      functionName: functionName,
+      fullMatch: fullMatch,
+      urlArg: typeof _urlArg2 === 'string' ? _urlArg2.trim() : String(_urlArg2),
+      structuredVariants: undefined,
+      // No explicit variants, will use generics later
+      optionsStructured: undefined,
+      hasOptions: false,
+      hasGenerics: hasGenerics,
+      structuredGenerics: structuredGenerics,
+      functionStartIndex: matchStartIndex,
+      functionEndIndex: endIndex,
+      argumentsStartIndex: parenIndex + 1,
+      argumentsEndIndex: endIndex
+    };
+  } else if (!metadataOnly && structured.length >= 2) {
+    // Normal mode: expect 2-3 arguments (url, variants, options?)
+    if (structured.length === 2) {
+      var _structured4 = _slicedToArray(structured, 2),
+        _urlArg3 = _structured4[0],
+        secondArg = _structured4[1];
+      if (hasGenerics) {
+        // With generics: 2 arguments means (url, options) - use generics as variants
+        return {
           functionName: functionName,
           fullMatch: fullMatch,
           urlArg: typeof _urlArg3 === 'string' ? _urlArg3.trim() : String(_urlArg3),
-          structuredVariants: _variantsStructured,
-          optionsStructured: _typeof(_optionsStructured) === 'object' && _optionsStructured !== null ? _optionsStructured : undefined,
+          structuredVariants: undefined,
+          // Use generics
+          optionsStructured: _typeof(secondArg) === 'object' && secondArg !== null ? secondArg : undefined,
           hasOptions: true,
-          // Options argument was provided
-          functionStartIndex: startIndex,
+          hasGenerics: hasGenerics,
+          structuredGenerics: structuredGenerics,
+          functionStartIndex: matchStartIndex,
           functionEndIndex: endIndex,
           argumentsStartIndex: parenIndex + 1,
           argumentsEndIndex: endIndex
-        });
+        };
+      }
+      // Without generics: 2 arguments means (url, variants) - use second arg as variants
+      return {
+        functionName: functionName,
+        fullMatch: fullMatch,
+        urlArg: typeof _urlArg3 === 'string' ? _urlArg3.trim() : String(_urlArg3),
+        structuredVariants: secondArg,
+        optionsStructured: undefined,
+        hasOptions: false,
+        hasGenerics: hasGenerics,
+        structuredGenerics: structuredGenerics,
+        functionStartIndex: matchStartIndex,
+        functionEndIndex: endIndex,
+        argumentsStartIndex: parenIndex + 1,
+        argumentsEndIndex: endIndex
+      };
+    }
+    if (structured.length === 3) {
+      var _structured5 = _slicedToArray(structured, 3),
+        _urlArg4 = _structured5[0],
+        variantsStructured = _structured5[1],
+        _optionsStructured = _structured5[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)));
       }
+      return {
+        functionName: functionName,
+        fullMatch: fullMatch,
+        urlArg: typeof _urlArg4 === 'string' ? _urlArg4.trim() : String(_urlArg4),
+        structuredVariants: variantsStructured,
+        optionsStructured: _typeof(_optionsStructured) === 'object' && _optionsStructured !== null ? _optionsStructured : undefined,
+        hasOptions: true,
+        // Options argument was provided
+        hasGenerics: hasGenerics,
+        structuredGenerics: structuredGenerics,
+        functionStartIndex: matchStartIndex,
+        functionEndIndex: endIndex,
+        argumentsStartIndex: parenIndex + 1,
+        argumentsEndIndex: endIndex
+      };
     }
-    match = createFactoryRegex.exec(code);
   }
-  return results;
+
+  // Should not reach here due to validation above
+  return null;
 }