@mui/internal-docs-infra/esm/CodeHighlighter/calculateMainFilePath.js

MUI Infra - internal documentation creation tools.

import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
import { createSyntheticDirectories, buildPath } from './pathUtils.js';
export function calculateMainFilePath(url, maxBackNav, maxSourceBackNav, metadataPrefix, fileName) {
  // Handle optional parameters with defaults
  var actualMaxSourceBackNav = maxSourceBackNav != null ? maxSourceBackNav : maxBackNav;
  var actualMetadataPrefix = metadataPrefix != null ? metadataPrefix : '';

  // Handle empty URL
  if (!url) {
    return '';
  }

  // Extract URL parts and filename
  var urlSegments;
  var filename;
  var hasTrailingSlash = false;
  try {
    // Try to parse as URL first
    var urlObj = new URL(url);
    hasTrailingSlash = urlObj.pathname.endsWith('/');
    var pathSegments = urlObj.pathname.split('/').filter(Boolean);
    var baseFilename;
    if (hasTrailingSlash) {
      // If URL ends with /, there's no filename - all segments are path segments
      baseFilename = '';
      urlSegments = pathSegments;
    } else {
      // Normal case - last segment is the filename
      baseFilename = pathSegments.pop() || '';
      urlSegments = pathSegments;
    }

    // Use provided fileName or preserve query and hash from URL
    if (fileName !== undefined) {
      filename = fileName;
    } else {
      filename = baseFilename + urlObj.search + urlObj.hash;
      if (hasTrailingSlash && !baseFilename) {
        filename = "".concat(filename, "/");
      }
    }
  } catch (_unused) {
    // Fallback to simple string parsing for relative paths
    hasTrailingSlash = url.endsWith('/');
    var urlParts = url.split('/');
    var _baseFilename;
    if (hasTrailingSlash) {
      // If URL ends with /, there's no filename - all segments are path segments
      _baseFilename = urlParts.pop() || ''; // Remove the empty string after trailing slash
      urlSegments = urlParts.filter(function (part) {
        return part !== '';
      }); // Remove empty segments
    } else {
      // Normal case - last segment is the filename
      _baseFilename = urlParts.pop() || '';
      urlSegments = urlParts.filter(function (part) {
        return part !== '';
      }); // Remove empty segments
    }

    // Use provided fileName or fallback to extracted baseFilename
    if (fileName !== undefined) {
      filename = fileName;
    } else {
      filename = _baseFilename;
      if (hasTrailingSlash && !_baseFilename) {
        filename = "".concat(filename, "/");
      }
    }
  }

  // Work with a copy of URL segments to avoid mutations
  var remainingUrlSegments = _toConsumableArray(urlSegments);

  // Take actualMaxSourceBackNav items from the end for sourcePath
  var sourcePath = remainingUrlSegments.splice(-actualMaxSourceBackNav, actualMaxSourceBackNav);

  // Calculate unhandledBackNav, accounting for missing sourcePath segments
  var unhandledBackNav = maxBackNav - actualMaxSourceBackNav;

  // Add any missing sourcePath segments to unhandledBackNav
  var missingSourcePathSegments = actualMaxSourceBackNav - sourcePath.length;
  unhandledBackNav += missingSourcePathSegments;

  // Split actualMetadataPrefix and subtract that count from unhandledBackNav
  var metadataPrefixSegments = actualMetadataPrefix.split('/').filter(function (part) {
    return part !== '';
  });
  unhandledBackNav -= metadataPrefixSegments.length;

  // Calculate metadataPath from remaining URL segments (what's left after sourcePath)
  var metadataSegmentsNeeded = Math.max(0, unhandledBackNav);
  var metadataSegmentsAvailable = Math.min(metadataSegmentsNeeded, remainingUrlSegments.length);
  var metadataPath = remainingUrlSegments.splice(-metadataSegmentsAvailable, metadataSegmentsAvailable);

  // Update unhandledBackNav with segments we couldn't fulfill from URL
  unhandledBackNav = metadataSegmentsNeeded - metadataSegmentsAvailable;

  // Create synthetic directories for any remaining unhandledBackNav
  var syntheticDirs = createSyntheticDirectories(unhandledBackNav);

  // Combine all parts to create the final path using buildPath utility
  // Order: [synthetic directories] + [metadataPath] + [metadataPrefix] + [sourcePath] + [filename]
  var path = buildPath(syntheticDirs, metadataPath, metadataPrefixSegments, sourcePath, filename);

  // Return as file:// URL unless the result is empty
  return path ? "file:///".concat(path) : path;
}