@mui/internal-docs-infra/CodeHighlighter/examineVariant.js

MUI Infra - internal documentation creation tools.

import _typeof from "@babel/runtime/helpers/esm/typeof";
import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
/**
 * Variant examination utility for analyzing variant structure and paths
 */

/**
 * Calculate the maximum back navigation level from extra files
 * Only considers non-metadata files to determine the common back navigation
 */
function calculateMaxBackNavigation(extraFiles) {
  var maxBackNavigation = 0;
  for (var _i = 0, _Object$entries = Object.entries(extraFiles); _i < _Object$entries.length; _i++) {
    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
      relativePath = _Object$entries$_i[0],
      fileContent = _Object$entries$_i[1];
    var file = typeof fileContent === 'string' ? {
      source: fileContent
    } : fileContent;

    // Skip metadata files - only consider non-metadata files for maxBackNavigation
    if (file.metadata) {
      continue;
    }
    if (relativePath.startsWith('.')) {
      var backCount = (relativePath.match(/\.\.\//g) || []).length;
      maxBackNavigation = Math.max(maxBackNavigation, backCount);
    }
  }
  return maxBackNavigation;
}

/**
 * Create path context for processing files with extended information
 */
export function createPathContext(variant) {
  var hasMetadata = variant.extraFiles ? Object.values(variant.extraFiles).some(function (file) {
    return _typeof(file) === 'object' && file.metadata;
  }) : false;

  // Calculate maxBackNavigation based only on extraFiles structure
  var maxBackNavigation = variant.extraFiles ? calculateMaxBackNavigation(variant.extraFiles) : 0;

  // Parse URL to determine path structure
  var urlDirectory = [];
  var rootLevel = '';
  var pathInwardFromRoot = '';
  if (variant.url && variant.url.includes('://')) {
    try {
      var url = new URL(variant.url);
      var pathname = url.pathname;

      // Split path into components, removing empty strings
      var pathComponents = pathname.split('/').filter(Boolean);
      if (pathComponents.length > 0) {
        // Check if the last component looks like a filename (has an extension)
        var lastComponent = pathComponents[pathComponents.length - 1];
        var hasFileExtension = lastComponent.includes('.') && /\.[a-zA-Z0-9]+$/.test(lastComponent);

        // If it has a file extension, exclude it from directory components
        var directoryComponents = hasFileExtension ? pathComponents.slice(0, -1) : pathComponents;
        urlDirectory = directoryComponents;
        rootLevel = directoryComponents[0] || '';

        // Only calculate pathInwardFromRoot if there's actual back navigation
        if (maxBackNavigation > 0 && directoryComponents.length >= maxBackNavigation) {
          // Take the last maxBackNavigation components as the pathInwardFromRoot
          var relevantComponents = directoryComponents.slice(-maxBackNavigation);
          pathInwardFromRoot = relevantComponents.join('/');
        }
      }
    } catch (_unused) {
      // If URL parsing fails, keep defaults
      urlDirectory = [];
      rootLevel = '';
      pathInwardFromRoot = '';
    }
  }

  // We keep the URL info for compatibility, but don't use it for calculations
  var hasUrl = Boolean(variant.url);
  var actualUrl = variant.url;
  if (hasUrl && actualUrl) {
    return {
      hasUrl: true,
      hasMetadata: hasMetadata,
      maxBackNavigation: maxBackNavigation,
      urlDirectory: urlDirectory,
      rootLevel: rootLevel,
      pathInwardFromRoot: pathInwardFromRoot,
      actualUrl: actualUrl
    };
  }
  return {
    hasUrl: false,
    hasMetadata: hasMetadata,
    maxBackNavigation: maxBackNavigation,
    urlDirectory: urlDirectory,
    rootLevel: rootLevel,
    pathInwardFromRoot: pathInwardFromRoot,
    actualUrl: undefined
  };
}