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

package/esm/pipeline/loadPrecomputedCodeHighlighter/replacePrecomputeValue.d.ts

@@ -0,0 +1,14 @@
+import type { ParsedCreateFactory } from "./parseCreateFactoryCall.js";
+/**
+ * Adds or replaces precompute data in createDemo function calls.
+ *
+ * @param source - The source code string containing createDemo calls
+ * @param precomputeData - The data object to inject
+ * @param demoCallInfo - Information about the parsed demo call structure from parseCreateFactoryCall
+ * @param options - Optional configuration
+ * @param options.passPrecomputeAsIs - Whether to pass precompute data as-is without JSON stringifying (default: false)
+ * @returns The modified source code with precompute data injected
+ */
+export declare function replacePrecomputeValue(source: string, precomputeData: Record<string, any>, demoCallInfo?: ParsedCreateFactory, options?: {
+  passPrecomputeAsIs?: boolean;
+}): string;

package/esm/pipeline/loadPrecomputedCodeHighlighter/replacePrecomputeValue.js

@@ -0,0 +1,73 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { serializeFunctionArguments } from "./serializeFunctionArguments.js";
+/**
+ * Adds or replaces precompute data in createDemo function calls.
+ *
+ * @param source - The source code string containing createDemo calls
+ * @param precomputeData - The data object to inject
+ * @param demoCallInfo - Information about the parsed demo call structure from parseCreateFactoryCall
+ * @param options - Optional configuration
+ * @param options.passPrecomputeAsIs - Whether to pass precompute data as-is without JSON stringifying (default: false)
+ * @returns The modified source code with precompute data injected
+ */
+export function replacePrecomputeValue(source, precomputeData, demoCallInfo) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  // If no demoCallInfo provided, return unchanged
+  if (!demoCallInfo) {
+    return source;
+  }
+  var hasOptions = demoCallInfo.hasOptions,
+    argumentsStartIndex = demoCallInfo.argumentsStartIndex,
+    argumentsEndIndex = demoCallInfo.argumentsEndIndex,
+    structuredUrl = demoCallInfo.structuredUrl,
+    structuredVariants = demoCallInfo.structuredVariants,
+    structuredOptions = demoCallInfo.structuredOptions;
+  var _options$passPrecompu = options.passPrecomputeAsIs,
+    passPrecomputeAsIs = _options$passPrecompu === void 0 ? false : _options$passPrecompu;
+
+  // Create new options object with precompute data
+  var newOptions = {};
+
+  // First, copy all existing options to preserve their order
+  if (hasOptions && structuredOptions) {
+    Object.entries(structuredOptions).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      if (key !== 'precompute') {
+        // Skip existing precompute, we'll replace it
+        newOptions[key] = value;
+      }
+    });
+  }
+
+  // Add precompute data - pass as-is if requested, otherwise JSON stringify
+  newOptions.precompute = passPrecomputeAsIs ? precomputeData : JSON.stringify(precomputeData, null, 2);
+
+  // Serialize all arguments using the standard function
+  var args;
+
+  // Build arguments array based on what's available
+  if (hasOptions || Object.keys(newOptions).length > 0) {
+    // We need to include options
+    if (structuredVariants !== undefined) {
+      // Normal case: url, variants, options
+      args = [structuredUrl, structuredVariants, newOptions];
+    } else {
+      // Metadata-only case: url, options (skip undefined variants)
+      args = [structuredUrl, newOptions];
+    }
+  } else if (structuredVariants !== undefined) {
+    // No options needed, but we have variants
+    args = [structuredUrl, structuredVariants];
+  } else {
+    // Only URL argument
+    args = [structuredUrl];
+  }
+  var serializedArgs = serializeFunctionArguments(args);
+
+  // Replace the arguments section
+  var before = source.substring(0, argumentsStartIndex);
+  var after = source.substring(argumentsEndIndex);
+  return "".concat(before).concat(serializedArgs).concat(after);
+}

package/esm/pipeline/loadPrecomputedCodeHighlighter/serializeFunctionArguments.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility function for serializing structured function arguments back to string format
+ * This is the inverse of parseFunctionArguments - it takes structured data and creates
+ * valid JavaScript/TypeScript function call arguments.
+ */
+import type { SplitArguments } from "./parseFunctionArguments.js";
+/**
+ * Serialize structured arguments back to a string representation
+ * Uses JSON.stringify for object values for performance and reliability
+ */
+export declare function serializeFunctionArguments(args: SplitArguments): string;

package/esm/pipeline/loadPrecomputedCodeHighlighter/serializeFunctionArguments.js

@@ -0,0 +1,203 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/**
+ * Utility function for serializing structured function arguments back to string format
+ * This is the inverse of parseFunctionArguments - it takes structured data and creates
+ * valid JavaScript/TypeScript function call arguments.
+ */
+
+import { isArray, isFunction, isGeneric, isArrowFunction, isObjectLiteral, isTypeAssertion } from "./parseFunctionArguments.js";
+
+/**
+ * Serialize structured arguments back to a string representation
+ * Uses JSON.stringify for object values for performance and reliability
+ */
+export function serializeFunctionArguments(args) {
+  return args.map(function (arg) {
+    return serializeArgument(arg);
+  }).join(', ');
+}
+
+/**
+ * Serialize a single argument based on its type
+ */
+function serializeArgument(arg) {
+  if (typeof arg === 'string') {
+    return arg;
+  }
+  if (typeof arg === 'number' || typeof arg === 'boolean' || arg === null) {
+    return String(arg);
+  }
+
+  // Check structured types using type guards
+  var arrayCheck = isArray(arg);
+  if (arrayCheck) {
+    return "[".concat(arrayCheck.items.map(function (item) {
+      return serializeArgument(item);
+    }).join(', '), "]");
+  }
+  var functionCheck = isFunction(arg);
+  if (functionCheck) {
+    var args = functionCheck.arguments.map(function (p) {
+      return serializeArgument(p);
+    }).join(', ');
+    return "".concat(functionCheck.name, "(").concat(args, ")");
+  }
+  var genericCheck = isGeneric(arg);
+  if (genericCheck) {
+    var generics = genericCheck.generics.map(function (g) {
+      return serializeArgument(g);
+    }).join(', ');
+    if (genericCheck.arguments === null) {
+      // Type generic like Theme<"dark" | "light">
+      return "".concat(genericCheck.name, "<").concat(generics, ">");
+    }
+    // Function generic like Component<Props>(args) - only add () if there are actual arguments
+    if (genericCheck.arguments.length > 0) {
+      var _args = genericCheck.arguments.map(function (p) {
+        return serializeArgument(p);
+      }).join(', ');
+      return "".concat(genericCheck.name, "<").concat(generics, ">(").concat(_args, ")");
+    }
+    // Generic without function call - like Component<Props>
+    return "".concat(genericCheck.name, "<").concat(generics, ">");
+  }
+  var arrowCheck = isArrowFunction(arg);
+  if (arrowCheck) {
+    var _args2 = arrowCheck.args.map(function (p) {
+      return serializeArgument(p);
+    }).join(', ');
+    var argStr = arrowCheck.args.length === 1 ? _args2 : "(".concat(_args2, ")");
+    if (arrowCheck.types) {
+      // Typed arrow function
+      var _arrowCheck$types = _slicedToArray(arrowCheck.types, 2),
+        inputTypes = _arrowCheck$types[0],
+        outputTypes = _arrowCheck$types[1];
+      var inputTypeStr = Array.isArray(inputTypes) ? inputTypes.join(', ') : inputTypes;
+      return "(".concat(_args2, ": ").concat(inputTypeStr, "): ").concat(outputTypes, " => ").concat(serializeArgument(arrowCheck.returnValue));
+    }
+    // Simple arrow function
+    return "".concat(argStr, " => ").concat(serializeArgument(arrowCheck.returnValue));
+  }
+  var typeAssertionCheck = isTypeAssertion(arg);
+  if (typeAssertionCheck) {
+    return "".concat(serializeArgument(typeAssertionCheck.expression), " as ").concat(typeAssertionCheck.type);
+  }
+  var objectCheck = isObjectLiteral(arg);
+  if (objectCheck) {
+    return serializeObject(objectCheck.properties);
+  }
+
+  // Array but not a structured type - serialize as array literal
+  if (Array.isArray(arg)) {
+    // Check if this is a double-wrapped array literal from parseArrayLiteral
+    // parseArrayLiteral calls parseArgumentsRecursive which returns an array,
+    // so we get [[item1, item2]] instead of [item1, item2]
+    var doubleWrappedCheck = isArray(arg);
+    if (doubleWrappedCheck) {
+      // This is a double-wrapped array literal - unwrap it
+      return "[".concat(arg[0].map(function (item) {
+        return serializeArgument(item);
+      }).join(', '), "]");
+    }
+
+    // Regular array
+    return "[".concat(arg.map(function (item) {
+      return serializeArgument(item);
+    }).join(', '), "]");
+  }
+
+  // Object but not a structured type - serialize as object literal
+  if (_typeof(arg) === 'object' && arg !== null) {
+    return serializeObject(arg);
+  }
+
+  // Fallback to string representation
+  return String(arg);
+}
+
+/**
+ * Serialize an object to JavaScript object literal syntax
+ */
+function serializeObject(obj) {
+  if (Object.keys(obj).length === 0) {
+    return '{}';
+  }
+  var entries = Object.entries(obj).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    var serializedValue = serializeObjectValue(value);
+
+    // Handle shorthand properties (key === value)
+    if (typeof value === 'string' && key === value) {
+      return key;
+    }
+    return "".concat(key, ": ").concat(serializedValue);
+  });
+  return "{ ".concat(entries.join(', '), " }");
+} /**
+  * Serialize an object value, using JSON.stringify when appropriate
+  */
+function serializeObjectValue(value) {
+  // Special case: array literals in objects are double-wrapped by the parser
+  // Check if this is a double-wrapped array literal: [[item1, item2, item3]]
+  // This MUST come before the structured type check to prevent it being treated as a structured array
+  if (isArray(value)) {
+    // This is a double-wrapped array literal - unwrap it
+    return "[".concat(value[0].map(function (item) {
+      return serializeObjectValue(item);
+    }).join(', '), "]");
+  }
+
+  // For structured types, recursively serialize first
+  if (_typeof(value) === 'object' && value !== null && isStructuredType(value)) {
+    return serializeArgument(value);
+  }
+
+  // For primitive values, just convert to string
+  if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+    return String(value);
+  }
+
+  // For strings, preserve original quotes from the parser
+  if (typeof value === 'string') {
+    // The parser preserves quotes for string literals and returns identifiers without quotes
+    // So we should return exactly what the parser gave us
+    return value;
+  }
+
+  // For plain objects and arrays, serialize keys/values individually
+  if (_typeof(value) === 'object' && value !== null && !isStructuredType(value)) {
+    if (Array.isArray(value)) {
+      // Check if this is a double-wrapped array literal
+      if (isArray(value)) {
+        // This is a double-wrapped array literal - unwrap it
+        return "[".concat(value[0].map(function (item) {
+          return serializeObjectValue(item);
+        }).join(', '), "]");
+      }
+      // Regular array
+      return "[".concat(value.map(function (item) {
+        return serializeObjectValue(item);
+      }).join(', '), "]");
+    }
+    var pairs = Object.entries(value).map(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+        key = _ref4[0],
+        val = _ref4[1];
+      return "".concat(key, ": ").concat(serializeObjectValue(val));
+    });
+    return "{ ".concat(pairs.join(', '), " }");
+  }
+
+  // Fallback
+  return serializeArgument(value);
+}
+
+/**
+ * Check if a value is one of our structured types that needs special handling
+ */
+function isStructuredType(value) {
+  return !!(isArray(value) || isFunction(value) || isGeneric(value) || isArrowFunction(value) || isTypeAssertion(value));
+}

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/filterRuntimeExternals.d.ts

@@ -0,0 +1,6 @@
+import type { Externals } from "../../CodeHighlighter/types.js";
+/**
+ * Filters out type-only imports from externals since they don't exist at runtime.
+ * This is essential for client-side code where type imports are stripped during compilation.
+ */
+export declare function filterRuntimeExternals(externals: Externals): Externals;

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/filterRuntimeExternals.js

@@ -0,0 +1,23 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/**
+ * Filters out type-only imports from externals since they don't exist at runtime.
+ * This is essential for client-side code where type imports are stripped during compilation.
+ */
+export function filterRuntimeExternals(externals) {
+  var runtimeExternals = {};
+  for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      modulePath = _Object$entries$_i[0],
+      imports = _Object$entries$_i[1];
+    // Filter out imports where isType is true
+    var runtimeImports = imports.filter(function (importItem) {
+      return !importItem.isType;
+    });
+
+    // Only include the module if it has runtime imports
+    if (runtimeImports.length > 0) {
+      runtimeExternals[modulePath] = runtimeImports;
+    }
+  }
+  return runtimeExternals;
+}

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/generateImportStatements.d.ts

@@ -0,0 +1,6 @@
+import type { Externals } from "../../CodeHighlighter/types.js";
+/**
+ * Generates import statements from externals without creating a provider
+ * Returns just the import lines needed to bring in the dependencies
+ */
+export declare function generateImportStatements(externals: Externals): string[];

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/generateImportStatements.js

@@ -0,0 +1,148 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+/**
+ * Generates a unique import name based on module path and original name
+ */
+function generateUniqueImportName(originalName, modulePath, type, usedNames) {
+  // If no conflict, use original name
+  if (!usedNames.has(originalName)) {
+    return originalName;
+  }
+
+  // For conflicts, strategy depends on type and context:
+  // - Namespace imports: always use numbered suffixes
+  // - Named imports from simple test cases (lib1, lib2, etc.): use numbered suffixes
+  // - Other cases: try module-based names first
+
+  var wantsNumberedSuffix = type === 'namespace' || modulePath.startsWith('lib') && /^lib\d+$/.test(modulePath);
+  if (wantsNumberedSuffix) {
+    // Use numbered suffixes
+    var attempt = 1;
+    var _uniqueName = "".concat(originalName).concat(attempt);
+    while (usedNames.has(_uniqueName)) {
+      attempt += 1;
+      _uniqueName = "".concat(originalName).concat(attempt);
+    }
+    return _uniqueName;
+  }
+
+  // For real modules, try module-based names first
+  var moduleKey = modulePath.replace(/[@/.-]/g, '') // Remove special characters
+  .toLowerCase().slice(0, 20); // Limit length
+
+  var uniqueName = "".concat(originalName).concat(moduleKey);
+
+  // If that's still taken, try numbered suffixes
+  if (usedNames.has(uniqueName)) {
+    var _attempt = 1;
+    do {
+      uniqueName = "".concat(originalName).concat(_attempt);
+      _attempt += 1;
+    } while (usedNames.has(uniqueName));
+  }
+  return uniqueName;
+}
+
+/**
+ * Generates import statements from externals without creating a provider
+ * Returns just the import lines needed to bring in the dependencies
+ */
+export function generateImportStatements(externals) {
+  var moduleImports = {};
+  var usedNames = new Set();
+  var seenImports = new Set();
+
+  // First pass: collect all imports and resolve naming conflicts
+  for (var _i = 0, _Object$entries = Object.entries(externals); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      modulePath = _Object$entries$_i[0],
+      importItems = _Object$entries$_i[1];
+    if (!moduleImports[modulePath]) {
+      moduleImports[modulePath] = {
+        named: [],
+        namespace: []
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(importItems),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _step.value,
+          originalName = _step$value.name,
+          type = _step$value.type,
+          isType = _step$value.isType;
+        // Skip type-only imports and empty names
+        if (isType || !originalName.trim()) {
+          continue;
+        }
+        var importKey = "".concat(modulePath, ":").concat(originalName, ":").concat(type);
+
+        // Skip duplicates
+        if (seenImports.has(importKey)) {
+          continue;
+        }
+        seenImports.add(importKey);
+        var uniqueName = generateUniqueImportName(originalName, modulePath, type, usedNames);
+        usedNames.add(uniqueName);
+        if (type === 'default') {
+          moduleImports[modulePath]["default"] = uniqueName;
+        } else if (type === 'named') {
+          moduleImports[modulePath].named.push({
+            original: originalName,
+            unique: uniqueName
+          });
+        } else if (type === 'namespace') {
+          moduleImports[modulePath].namespace.push(uniqueName);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  // Second pass: generate consolidated import statements
+  var imports = [];
+  for (var _i2 = 0, _Object$entries2 = Object.entries(moduleImports); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+      _modulePath = _Object$entries2$_i[0],
+      moduleImport = _Object$entries2$_i[1];
+    var importParts = [];
+
+    // Add default import
+    if (moduleImport["default"]) {
+      importParts.push(moduleImport["default"]);
+    }
+
+    // Add named imports (consolidated into one statement)
+    if (moduleImport.named.length > 0) {
+      var namedImports = moduleImport.named.map(function (_ref) {
+        var original = _ref.original,
+          unique = _ref.unique;
+        return original === unique ? original : "".concat(original, " as ").concat(unique);
+      }).join(', ');
+      importParts.push("{ ".concat(namedImports, " }"));
+    }
+
+    // Generate import statement
+    if (importParts.length > 0) {
+      imports.push("import ".concat(importParts.join(', '), " from '").concat(_modulePath, "';"));
+    }
+
+    // Add namespace imports (separate statements as they can't be combined)
+    var _iterator2 = _createForOfIteratorHelper(moduleImport.namespace),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var namespaceName = _step2.value;
+        imports.push("import * as ".concat(namespaceName, " from '").concat(_modulePath, "';"));
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  return imports;
+}

package/esm/pipeline/loadPrecomputedCodeHighlighterClient/generateResolvedExternals.d.ts

@@ -0,0 +1,9 @@
+import type { Externals } from "../../CodeHighlighter/types.js";
+/**
+ * Generates both import statements and resolved externals object
+ * Returns the import statements and the externals as a JavaScript object
+ */
+export declare function generateResolvedExternals(externals: Externals): {
+  imports: string[];
+  resolvedExternals: Record<string, string>;
+};