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

MUI Infra - internal documentation creation tools.

import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
var _excluded = ["metadata"];
/**
 * Metadata merging utility for positioning metadata files relative to source files
 */

import { createPathContext } from "./examineVariant.js";

/**
 * Options for merging metadata files
 */

/**
 * Calculate the required back navigation level for metadata files
 */
function calculateMetadataBackNavigation(variant, metadataPrefix) {
  // Get the maxBackNavigation from the variant's file structure
  var pathContext = createPathContext(variant);
  var backLevels = pathContext.maxBackNavigation;
  if (metadataPrefix) {
    // When a prefix is provided, add additional back navigation based on prefix depth
    var prefixSegments = metadataPrefix.split('/').filter(Boolean);
    backLevels += prefixSegments.length;
  }
  return '../'.repeat(backLevels);
}

/**
 * Merge metadata files into a variant with proper positioning
 *
 * @param variant - The variant containing source files and potentially mixed metadata/non-metadata files
 * @param metadataFiles - Additional metadata files to merge in
 * @param options - Options for metadata positioning
 * @returns A variant with all metadata files properly positioned
 */
/**
 * Extract metadata files from a variant, scoping them according to metadataPrefix
 *
 * @param variant - The variant containing mixed source and metadata files
 * @returns An object with the cleaned variant and extracted metadata
 */
export function extractMetadata(variant) {
  var metadataPrefix = variant.metadataPrefix;
  var extractedMetadata = {};
  var nonMetadataFiles = {};
  if (!variant.extraFiles) {
    return {
      variant: _objectSpread(_objectSpread({}, variant), {}, {
        extraFiles: {}
      }),
      metadata: {}
    };
  }

  // Process all extraFiles
  for (var _i = 0, _Object$entries = Object.entries(variant.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;
    if (file.metadata) {
      var scopedPath = relativePath;

      // Calculate how much back navigation to remove
      var pathContext = createPathContext(variant);
      var backLevelsToRemove = pathContext.maxBackNavigation;
      if (metadataPrefix) {
        // Add metadataPrefix levels if present
        backLevelsToRemove += metadataPrefix.split('/').filter(Boolean).length;
      }

      // Remove the back navigation prefix to scope metadata correctly
      if (backLevelsToRemove > 0) {
        var backNavigationToRemove = '../'.repeat(backLevelsToRemove);
        if (scopedPath.startsWith(backNavigationToRemove)) {
          scopedPath = scopedPath.slice(backNavigationToRemove.length);
        }
      }

      // Remove metadata flag when extracting
      var metadataFlag = file.metadata,
        cleanFile = _objectWithoutProperties(file, _excluded);
      extractedMetadata[scopedPath] = cleanFile;
    } else {
      nonMetadataFiles[relativePath] = file;
    }
  }
  return {
    variant: _objectSpread(_objectSpread({}, variant), {}, {
      extraFiles: nonMetadataFiles
    }),
    metadata: extractedMetadata
  };
}
export function mergeMetadata(variant) {
  var _options$metadataPref;
  var metadataFiles = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  // Determine which metadataPrefix to use
  var targetMetadataPrefix = (_options$metadataPref = options.metadataPrefix) != null ? _options$metadataPref : variant.metadataPrefix;

  // Check if we need to re-extract metadata due to metadataPrefix change
  var needsReextraction = options.metadataPrefix !== undefined && options.metadataPrefix !== variant.metadataPrefix;

  // If metadataPrefix is changing, extract existing metadata and reposition everything
  var workingVariant = variant;
  var existingMetadata = {};
  if (needsReextraction && variant.extraFiles) {
    // Extract existing metadata using the old metadataPrefix
    var extracted = extractMetadata(variant);
    workingVariant = extracted.variant;
    existingMetadata = extracted.metadata;
  }

  // Calculate the positioning level for metadata files
  var metadataBackNavigation = calculateMetadataBackNavigation(workingVariant, targetMetadataPrefix);

  // Collect all metadata files that need positioning
  var allMetadataFiles = {};
  var nonMetadataFiles = {};
  var positionedMetadataFiles = {};

  // Process existing extraFiles from working variant
  if (workingVariant.extraFiles) {
    for (var _i2 = 0, _Object$entries2 = Object.entries(workingVariant.extraFiles); _i2 < _Object$entries2.length; _i2++) {
      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
        relativePath = _Object$entries2$_i[0],
        fileContent = _Object$entries2$_i[1];
      var file = typeof fileContent === 'string' ? {
        source: fileContent
      } : fileContent;
      if (file.metadata) {
        // If we're not changing metadataPrefix, keep existing metadata files where they are
        if (!needsReextraction) {
          positionedMetadataFiles[relativePath] = file;
        } else {
          // Only collect for repositioning if metadataPrefix is changing
          allMetadataFiles[relativePath] = file;
        }
      } else {
        nonMetadataFiles[relativePath] = file;
      }
    }
  }

  // Add extracted metadata (if any) for repositioning
  for (var _i3 = 0, _Object$entries3 = Object.entries(existingMetadata); _i3 < _Object$entries3.length; _i3++) {
    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
      filePath = _Object$entries3$_i[0],
      _file = _Object$entries3$_i[1];
    allMetadataFiles[filePath] = _objectSpread(_objectSpread({}, typeof _file === 'string' ? {
      source: _file
    } : _file), {}, {
      metadata: true
    });
  }

  // Add additional metadata files for positioning
  for (var _i4 = 0, _Object$entries4 = Object.entries(metadataFiles); _i4 < _Object$entries4.length; _i4++) {
    var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
      _filePath = _Object$entries4$_i[0],
      _file2 = _Object$entries4$_i[1];
    allMetadataFiles[_filePath] = _objectSpread(_objectSpread({}, typeof _file2 === 'string' ? {
      source: _file2
    } : _file2), {}, {
      metadata: true
    });
  }

  // Position new metadata files at the calculated level
  for (var _i5 = 0, _Object$entries5 = Object.entries(allMetadataFiles); _i5 < _Object$entries5.length; _i5++) {
    var _Object$entries5$_i = _slicedToArray(_Object$entries5[_i5], 2),
      originalPath = _Object$entries5$_i[0],
      _file3 = _Object$entries5$_i[1];
    var metadataPath = "".concat(metadataBackNavigation).concat(originalPath);
    positionedMetadataFiles[metadataPath] = _file3;
  }

  // Combine all files
  var finalExtraFiles = _objectSpread(_objectSpread({}, nonMetadataFiles), positionedMetadataFiles);
  return _objectSpread(_objectSpread({}, workingVariant), {}, {
    extraFiles: finalExtraFiles,
    metadataPrefix: targetMetadataPrefix
  });
}