@mui/internal-docs-infra 0.1.1-canary.9 → 0.2.0-alpha.2

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseFunctionArguments.js

@@ -0,0 +1,715 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+/**
+ * Utility function for parsing function arguments and handling nested structures
+ * in JavaScript/TypeScript code with structured representations.
+ */
+
+/**
+ * Structured argument types for discriminating between different code constructs:
+ * - `[Array]`: Literal array - e.g., `['1', '2', '3']`
+ * - `[String, Array]`: Function call - e.g., `['func', ['a', 'b']]`
+ * - `[String, Array, Array]`: Function with generics - e.g., `['Component', [{ foo: 'string' }], []]`
+ * - `[String, Array, null]`: Type with generics - e.g., `['Theme', ['"dark" | "light"'], null]`
+ * - `[Array, any]`: Simple arrow function - e.g., `[['evt'], 'evt.preventDefault()']`
+ * - `[Array, [any, any], any]`: Typed arrow function - e.g., `[['data'], ['string', 'Promise<string>'], ['Promise.resolve', ['data']]]`
+ * - `['as', string, any]`: TypeScript type assertion - e.g., `['as', 'React.FC<Props>', 'Component']`
+ * - `Record<string, any>`: Object literal - e.g., `{ key: 'value' }`
+ * - `string`: Plain string value
+ */
+
+/**
+ * Type guard and extractor for literal arrays
+ * @param value - The value to check
+ * @returns Object with items array if it's a literal array, false otherwise
+ */
+export function isArray(value) {
+  if (Array.isArray(value) && value.length === 1 && Array.isArray(value[0])) {
+    return {
+      items: value
+    };
+  }
+  return false;
+}
+
+/**
+ * Type guard and extractor for function calls
+ * @param value - The value to check
+ * @returns Object with name and arguments if it's a function call, false otherwise
+ */
+export function isFunction(value) {
+  if (Array.isArray(value) && value.length === 2 && typeof value[0] === 'string' && Array.isArray(value[1])) {
+    return {
+      name: value[0],
+      arguments: value[1]
+    };
+  }
+  return false;
+}
+
+/**
+ * Type guard and extractor for generics (both function and type generics)
+ * @param value - The value to check
+ * @returns Object with name, generics, and arguments (or null for types) if it's a generic, false otherwise
+ */
+export function isGeneric(value) {
+  if (Array.isArray(value) && value.length === 3 && typeof value[0] === 'string' && Array.isArray(value[1])) {
+    return {
+      name: value[0],
+      generics: value[1],
+      arguments: value[2]
+    };
+  }
+  return false;
+}
+
+/**
+ * Type guard and extractor for arrow functions
+ * @param value - The value to check
+ * @returns Object with args, types (if typed), and returnValue if it's an arrow function, false otherwise
+ */
+export function isArrowFunction(value) {
+  if (Array.isArray(value) && Array.isArray(value[0])) {
+    if (value.length === 2) {
+      // Simple arrow function: [Array, any]
+      return {
+        args: value[0],
+        returnValue: value[1]
+      };
+    }
+    if (value.length === 3 && Array.isArray(value[1]) && value[1].length === 2) {
+      // Typed arrow function: [Array, [inputTypes, outputTypes], any]
+      return {
+        args: value[0],
+        types: [value[1][0], value[1][1]],
+        returnValue: value[2]
+      };
+    }
+  }
+  return false;
+}
+
+/**
+ * Type guard and extractor for object literals
+ * @param value - The value to check
+ * @returns Object with properties if it's an object literal, false otherwise
+ */
+export function isObjectLiteral(value) {
+  if (_typeof(value) === 'object' && value !== null && !Array.isArray(value)) {
+    return {
+      properties: value
+    };
+  }
+  return false;
+}
+
+/**
+ * Type guard and extractor for TypeScript type assertions
+ * @param value - The value to check
+ * @returns Object with type and expression if it's a type assertion, false otherwise
+ */
+export function isTypeAssertion(value) {
+  if (Array.isArray(value) && value.length === 3 && value[0] === 'as' && typeof value[1] === 'string') {
+    return {
+      type: value[1],
+      expression: value[2]
+    };
+  }
+  return false;
+}
+
+/**
+ * Main API: Parse arguments and return structured representation
+ * This is the primary parsing function optimized for recursive data structures
+ */
+export function parseFunctionArguments(str) {
+  return parseArgumentsRecursive(str);
+}
+
+/**
+ * Parse entire file and extract all exports with their function calls
+ * Returns a mapping of export names to their function call information
+ */
+export function parseFileExports(fileContent) {
+  var exports = {};
+
+  // Find all export statements that assign function calls
+  var exportRegex = /export\s+const\s+(\w+)\s*=\s*(\w+)\s*\(/g;
+  var match = exportRegex.exec(fileContent);
+  while (match !== null) {
+    var exportName = match[1];
+    var functionName = match[2];
+    var callStartIndex = match.index;
+    var parenIndex = match.index + match[0].length - 1; // Position of opening parenthesis
+
+    // Find the matching closing parenthesis
+    var parenCount = 0;
+    var callEndIndex = -1;
+    for (var i = parenIndex; i < fileContent.length; i += 1) {
+      if (fileContent[i] === '(') {
+        parenCount += 1;
+      } else if (fileContent[i] === ')') {
+        parenCount -= 1;
+        if (parenCount === 0) {
+          callEndIndex = i;
+          break;
+        }
+      }
+    }
+    if (callEndIndex !== -1) {
+      // Extract the arguments content between parentheses
+      var argumentsContent = fileContent.substring(parenIndex + 1, callEndIndex);
+      exports[exportName] = {
+        functionName: functionName,
+        // Parse the arguments using existing logic
+        arguments: parseFunctionArguments(argumentsContent),
+        sourceRange: [callStartIndex, callEndIndex + 1]
+      };
+    }
+    match = exportRegex.exec(fileContent);
+  }
+  return exports;
+}
+
+/**
+ * Internal recursive parsing function
+ */
+function parseArgumentsRecursive(str) {
+  var result = [];
+  var current = '';
+  var parenCount = 0;
+  var braceCount = 0;
+  var bracketCount = 0;
+  var angleCount = 0;
+  var inSingleLineComment = false;
+  var inMultiLineComment = false;
+  var inString = false;
+  var stringChar = '';
+  for (var i = 0; i < str.length; i += 1) {
+    var _char = str[i];
+    var nextChar = str[i + 1];
+
+    // Handle comments
+    if (!inString && !inSingleLineComment && !inMultiLineComment) {
+      if (_char === '/' && nextChar === '/') {
+        inSingleLineComment = true;
+        current += _char;
+        continue;
+      }
+      if (_char === '/' && nextChar === '*') {
+        inMultiLineComment = true;
+        current += _char;
+        continue;
+      }
+    }
+    if (inSingleLineComment && _char === '\n') {
+      inSingleLineComment = false;
+      current += _char;
+      continue;
+    }
+    if (inMultiLineComment && _char === '*' && nextChar === '/') {
+      inMultiLineComment = false;
+      current += _char + nextChar;
+      i += 1; // Skip next character
+      continue;
+    }
+    if (inSingleLineComment || inMultiLineComment) {
+      current += _char;
+      continue;
+    }
+
+    // Handle strings
+    if (!inString && (_char === '"' || _char === "'" || _char === '`')) {
+      inString = true;
+      stringChar = _char;
+      current += _char;
+      continue;
+    }
+    if (inString && _char === stringChar && str[i - 1] !== '\\') {
+      inString = false;
+      stringChar = '';
+      current += _char;
+      continue;
+    }
+    if (inString) {
+      current += _char;
+      continue;
+    }
+
+    // Handle brackets and parentheses
+    if (_char === '(') {
+      parenCount += 1;
+    } else if (_char === ')') {
+      parenCount -= 1;
+    } else if (_char === '{') {
+      braceCount += 1;
+    } else if (_char === '}') {
+      braceCount -= 1;
+    } else if (_char === '[') {
+      bracketCount += 1;
+    } else if (_char === ']') {
+      bracketCount -= 1;
+    } else if (_char === '<') {
+      angleCount += 1;
+    } else if (_char === '>' && str[i - 1] !== '=') {
+      // Only count > as closing angle bracket if it's not part of =>
+      angleCount -= 1;
+    } else if (_char === ',' && parenCount === 0 && braceCount === 0 && bracketCount === 0 && angleCount === 0) {
+      var trimmedPart = current.trim();
+      if (trimmedPart) {
+        result.push(parseElement(trimmedPart));
+      }
+      current = '';
+      continue;
+    }
+    current += _char;
+  }
+
+  // Handle the last part
+  if (current.trim()) {
+    var _trimmedPart = current.trim();
+    result.push(parseElement(_trimmedPart));
+  }
+  return result;
+}
+
+/**
+ * Parse a single element and determine its type/structure
+ */
+function parseElement(element) {
+  var trimmed = element.trim();
+
+  // Remove comments
+  trimmed = removeComments(trimmed);
+
+  // Handle object literals FIRST before checking for 'as'
+  if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+    return parseObjectLiteral(trimmed);
+  }
+
+  // Handle TypeScript 'as' type assertions with structured representation
+  if (trimmed.includes(' as ')) {
+    return parseTypeAssertion(trimmed);
+  }
+
+  // Handle array literals
+  if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+    return parseArrayLiteral(trimmed);
+  }
+
+  // Handle arrow functions
+  if (trimmed.includes('=>')) {
+    return parseArrowFunction(trimmed);
+  }
+
+  // Handle function calls and generics
+  if (trimmed.includes('(') || trimmed.includes('<')) {
+    return parseFunctionOrGeneric(trimmed);
+  }
+
+  // Everything else is just a string
+  return trimmed;
+}
+
+/**
+ * Remove comments from a string
+ */
+function removeComments(str) {
+  var result = '';
+  var inSingleLineComment = false;
+  var inMultiLineComment = false;
+  var inString = false;
+  var stringChar = '';
+  for (var i = 0; i < str.length; i += 1) {
+    var _char2 = str[i];
+    var nextChar = str[i + 1];
+
+    // Handle strings first
+    if (!inSingleLineComment && !inMultiLineComment && !inString && (_char2 === '"' || _char2 === "'" || _char2 === '`')) {
+      inString = true;
+      stringChar = _char2;
+      result += _char2;
+      continue;
+    }
+    if (inString && _char2 === stringChar && str[i - 1] !== '\\') {
+      inString = false;
+      stringChar = '';
+      result += _char2;
+      continue;
+    }
+    if (inString) {
+      result += _char2;
+      continue;
+    }
+
+    // Handle comments
+    if (!inSingleLineComment && !inMultiLineComment) {
+      if (_char2 === '/' && nextChar === '/') {
+        inSingleLineComment = true;
+        i += 1; // Skip next character
+        continue;
+      }
+      if (_char2 === '/' && nextChar === '*') {
+        inMultiLineComment = true;
+        i += 1; // Skip next character
+        continue;
+      }
+    }
+    if (inSingleLineComment && _char2 === '\n') {
+      inSingleLineComment = false;
+      result += _char2;
+      continue;
+    }
+    if (inMultiLineComment && _char2 === '*' && nextChar === '/') {
+      inMultiLineComment = false;
+      i += 1; // Skip next character
+      continue;
+    }
+    if (inSingleLineComment || inMultiLineComment) {
+      continue;
+    }
+    result += _char2;
+  }
+  return result.trim();
+}
+
+/**
+ * Parse object literal like { key: value, other: data }
+ */
+function parseObjectLiteral(str) {
+  var content = str.slice(1, -1).trim(); // Remove { }
+  if (!content) {
+    return {};
+  }
+  var obj = {};
+
+  // Parse object properties manually to handle complex types
+  var properties = parseObjectProperties(content);
+  for (var _i = 0, _properties = properties; _i < _properties.length; _i++) {
+    var prop = _properties[_i];
+    var colonIndex = prop.indexOf(':');
+    if (colonIndex !== -1) {
+      var key = prop.substring(0, colonIndex).trim();
+      var value = prop.substring(colonIndex + 1).trim();
+      // Parse the value
+      var parsedValue = parseElement(value);
+
+      // For object properties: preserve strings as-is, but only wrap array LITERALS in another array
+      if (typeof parsedValue === 'string' && !Array.isArray(parsedValue)) {
+        obj[key] = parsedValue;
+      } else if (Array.isArray(parsedValue)) {
+        // Only double-wrap array literals (parsed from [1, 2, 3])
+        // Functions and generics should remain as single arrays
+        var originalValue = value.trim();
+        if (originalValue.startsWith('[') && originalValue.endsWith(']')) {
+          // This is an array literal - double wrap it
+          obj[key] = [parsedValue];
+        } else {
+          // This is a function call or generic - keep as single array
+          obj[key] = parsedValue;
+        }
+      } else {
+        obj[key] = parsedValue;
+      }
+    } else {
+      // Shorthand property like { foo } -> { foo: 'foo' }
+      var trimmed = prop.trim();
+      obj[trimmed] = trimmed;
+    }
+  }
+  return obj;
+}
+
+/**
+ * Parse object properties, handling complex nested types
+ */
+function parseObjectProperties(content) {
+  var properties = [];
+  var current = '';
+  var depth = 0;
+  var inString = false;
+  var stringChar = '';
+  for (var i = 0; i < content.length; i += 1) {
+    var _char3 = content[i];
+    var nextChar = content[i + 1];
+    if (!inString && (_char3 === '"' || _char3 === "'" || _char3 === '`')) {
+      inString = true;
+      stringChar = _char3;
+    } else if (inString && _char3 === stringChar && content[i - 1] !== '\\') {
+      inString = false;
+      stringChar = '';
+    }
+    if (!inString) {
+      if (_char3 === '<' || _char3 === '{' || _char3 === '(' || _char3 === '[') {
+        depth += 1;
+      } else if (_char3 === '>' && nextChar !== '=' && content[i - 1] !== '=') {
+        // Only count > as closing bracket if it's not part of => or >=
+        depth -= 1;
+      } else if (_char3 === '}' || _char3 === ')' || _char3 === ']') {
+        depth -= 1;
+      } else if (_char3 === ',' && depth === 0) {
+        if (current.trim()) {
+          properties.push(current.trim());
+        }
+        current = '';
+        continue;
+      }
+    }
+    current += _char3;
+  }
+  if (current.trim()) {
+    properties.push(current.trim());
+  }
+  return properties;
+}
+
+/**
+ * Parse array literal like [1, 2, 3]
+ */
+function parseArrayLiteral(str) {
+  var content = str.slice(1, -1).trim(); // Remove [ ]
+  if (!content) {
+    return [];
+  }
+  return parseArgumentsRecursive(content);
+}
+
+/**
+ * Parse arrow function like (a) => a + 1 or (data: string): Promise<string> => Promise.resolve(data)
+ */
+function parseArrowFunction(str) {
+  var arrowIndex = str.indexOf('=>');
+  var leftPart = str.substring(0, arrowIndex).trim();
+  var rightPart = str.substring(arrowIndex + 2).trim();
+
+  // Parse arguments
+  var args = [];
+  var types;
+  if (leftPart.startsWith('(') && leftPart.includes(')')) {
+    var parenEnd = leftPart.lastIndexOf(')');
+    var argsPart = leftPart.substring(1, parenEnd);
+    var afterParen = leftPart.substring(parenEnd + 1).trim();
+    args = argsPart ? parseArgumentsRecursive(argsPart) : [];
+
+    // Check for return type annotation
+    if (afterParen.startsWith(':')) {
+      var returnType = afterParen.substring(1).trim();
+      // Extract input types from args if they have type annotations
+      var inputTypes = args.map(function (arg) {
+        if (typeof arg === 'string' && arg.includes(':')) {
+          return arg.split(':')[1].trim();
+        }
+        return 'any';
+      });
+
+      // Clean argument names (remove type annotations)
+      args = args.map(function (arg) {
+        if (typeof arg === 'string' && arg.includes(':')) {
+          return arg.split(':')[0].trim();
+        }
+        return arg;
+      });
+      types = [inputTypes.length === 1 ? inputTypes[0] : inputTypes, returnType];
+    }
+  } else {
+    args = [leftPart];
+  }
+  var returnValue = parseElement(rightPart);
+  if (types) {
+    return [args, types, returnValue];
+  }
+  return [args, returnValue];
+}
+
+/**
+ * Parse function calls and generics like func(a, b) or Component<{ foo: string }>
+ */
+function parseFunctionOrGeneric(str) {
+  // Check for generics first
+  var angleStart = str.indexOf('<');
+  var parenStart = str.indexOf('(');
+  if (angleStart !== -1 && (parenStart === -1 || angleStart < parenStart)) {
+    return parseGeneric(str);
+  }
+  if (parenStart !== -1) {
+    var result = parseFunctionCall(str);
+    // If parseFunctionCall detected property access and returned [str], unwrap it
+    if (Array.isArray(result) && result.length === 1 && result[0] === str) {
+      return str;
+    }
+    return result;
+  }
+  return str;
+}
+
+/**
+ * Parse generic content while preserving nested structures
+ */
+function parseGenericContent(content) {
+  var elements = [];
+  var current = '';
+  var parenCount = 0;
+  var braceCount = 0;
+  var bracketCount = 0;
+  var angleCount = 0;
+  var inString = false;
+  var stringChar = '';
+  for (var i = 0; i < content.length; i += 1) {
+    var _char4 = content[i];
+    if (!inString && (_char4 === '"' || _char4 === "'")) {
+      inString = true;
+      stringChar = _char4;
+      current += _char4;
+    } else if (inString && _char4 === stringChar && content[i - 1] !== '\\') {
+      inString = false;
+      stringChar = '';
+      current += _char4;
+    } else if (!inString) {
+      if (_char4 === '(') {
+        parenCount += 1;
+      } else if (_char4 === ')') {
+        parenCount -= 1;
+      } else if (_char4 === '{') {
+        braceCount += 1;
+      } else if (_char4 === '}') {
+        braceCount -= 1;
+      } else if (_char4 === '[') {
+        bracketCount += 1;
+      } else if (_char4 === ']') {
+        bracketCount -= 1;
+      } else if (_char4 === '<') {
+        angleCount += 1;
+      } else if (_char4 === '>') {
+        angleCount -= 1;
+      } else if (_char4 === ',' && parenCount === 0 && braceCount === 0 && bracketCount === 0 && angleCount === 0) {
+        if (current.trim()) {
+          elements.push(parseElement(current.trim()));
+        }
+        current = '';
+        continue;
+      }
+      current += _char4;
+    } else {
+      current += _char4;
+    }
+  }
+  if (current.trim()) {
+    elements.push(parseElement(current.trim()));
+  }
+  return elements;
+}
+
+/**
+ * Parse generic like Component<{ foo: string }> or Theme<"dark" | "light", Component[]>
+ */
+function parseGeneric(str) {
+  var angleStart = str.indexOf('<');
+  var name = str.substring(0, angleStart).trim();
+
+  // Find matching closing angle bracket
+  var angleCount = 0;
+  var angleEnd = -1;
+  for (var i = angleStart; i < str.length; i += 1) {
+    if (str[i] === '<') {
+      angleCount += 1;
+    } else if (str[i] === '>') {
+      angleCount -= 1;
+      if (angleCount === 0) {
+        angleEnd = i;
+        break;
+      }
+    }
+  }
+  if (angleEnd === -1) {
+    return [str];
+  }
+  var genericContent = str.substring(angleStart + 1, angleEnd).trim();
+  var afterGeneric = str.substring(angleEnd + 1).trim();
+
+  // Parse generic content - don't split on commas within generics for unions and arrays
+  var generics = genericContent ? parseGenericContent(genericContent) : [];
+
+  // Check if there are function arguments after the generic
+  if (afterGeneric.startsWith('(') && afterGeneric.endsWith(')')) {
+    var argContent = afterGeneric.slice(1, -1).trim();
+    var args = argContent ? parseArgumentsRecursive(argContent) : [];
+    return [name, generics, args];
+  }
+
+  // For standalone generics like Component<Props>, treat as function call with empty args
+  // This matches the test expectation for Component<{ foo: string }> -> ['Component', [{ foo: 'string' }], []]
+  return [name, generics, []];
+}
+
+/**
+ * Parse function call like func(a, b)
+ */
+function parseFunctionCall(str) {
+  var parenStart = str.indexOf('(');
+  var name = str.substring(0, parenStart).trim();
+
+  // Find matching closing parenthesis
+  var parenCount = 0;
+  var parenEnd = -1;
+  for (var i = parenStart; i < str.length; i += 1) {
+    if (str[i] === '(') {
+      parenCount += 1;
+    } else if (str[i] === ')') {
+      parenCount -= 1;
+      if (parenCount === 0) {
+        parenEnd = i;
+        break;
+      }
+    }
+  }
+  if (parenEnd === -1) {
+    return [str];
+  }
+
+  // Check if there's meaningful continuation after the closing parenthesis
+  var remainingLength = str.length - parenEnd - 1;
+  if (remainingLength > 0) {
+    // Skip whitespace to find the first meaningful character
+    var _i2 = parenEnd + 1;
+    while (_i2 < str.length && (str[_i2] === ' ' || str[_i2] === '\t' || str[_i2] === '\n' || str[_i2] === '\r')) {
+      _i2 += 1;
+    }
+    if (_i2 < str.length) {
+      var firstChar = str[_i2];
+      if (firstChar === '.' || firstChar === '[' || firstChar === '(' || firstChar === '!') {
+        // Property access, bracket notation, chained calls, or non-null assertion
+        return [str];
+      }
+      if (firstChar === '?' && _i2 + 1 < str.length && str[_i2 + 1] === '.') {
+        // Optional chaining
+        return [str];
+      }
+    }
+  }
+  var argContent = str.substring(parenStart + 1, parenEnd).trim();
+  if (!argContent) {
+    return [name, []];
+  }
+  var args = parseArgumentsRecursive(argContent);
+
+  // Special case: if there's a single array literal argument, flatten it
+  if (args.length === 1 && Array.isArray(args[0])) {
+    return [name, args[0]];
+  }
+  return [name, args];
+}
+
+/**
+ * Parse TypeScript type assertion like "Component as React.FC<Props>"
+ */
+function parseTypeAssertion(str) {
+  var asIndex = str.indexOf(' as ');
+  if (asIndex === -1) {
+    return [str]; // fallback to string if no 'as' found
+  }
+  var expression = str.substring(0, asIndex).trim();
+  var type = str.substring(asIndex + 4).trim(); // +4 for ' as '
+
+  // Parse the expression part recursively in case it's complex
+  var parsedExpression = parseElement(expression);
+  return ['as', type, parsedExpression];
+}