@mui/internal-docs-infra/useCode/useCodeUtils.js

MUI Infra - internal documentation creation tools.

import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import _typeof from "@babel/runtime/helpers/esm/typeof";
import { stringOrHastToJsx } from "../pipeline/hastUtils/index.js";
import { applyTransform } from "../CodeHighlighter/applyTransform.js";
/**
 * Pure function to get available transforms from effective code data.
 * Only includes transforms that have actual deltas (file changes), not just filename changes.
 *
 * @param effectiveCode - The effective code object containing all variants
 * @param selectedVariantKey - The currently selected variant key
 * @returns Array of available transform keys that have deltas
 */
export function getAvailableTransforms(effectiveCode, selectedVariantKey) {
  var transforms = new Set();
  if (effectiveCode && selectedVariantKey) {
    var variantCode = effectiveCode[selectedVariantKey];
    if (variantCode && _typeof(variantCode) === 'object') {
      // Check main variant transforms
      if ('transforms' in variantCode && variantCode.transforms) {
        Object.keys(variantCode.transforms).forEach(function (transformKey) {
          var transformData = variantCode.transforms[transformKey];
          // Only include transforms that have actual deltas (file changes)
          // Check if delta exists and is not empty
          if (transformData && _typeof(transformData) === 'object' && 'delta' in transformData) {
            var delta = transformData.delta;
            // Check if delta has meaningful content (not just an empty object)
            var hasContent = delta && _typeof(delta) === 'object' && Object.keys(delta).length > 0;
            if (hasContent) {
              transforms.add(transformKey);
            }
          }
        });
      }

      // Check extraFiles for transforms with deltas
      if ('extraFiles' in variantCode && variantCode.extraFiles) {
        Object.values(variantCode.extraFiles).forEach(function (fileData) {
          if (fileData && _typeof(fileData) === 'object' && 'transforms' in fileData && fileData.transforms) {
            Object.keys(fileData.transforms).forEach(function (transformKey) {
              var transformData = fileData.transforms[transformKey];
              // Only include transforms that have actual deltas (file changes)
              // Check if delta exists and is not empty
              if (transformData && _typeof(transformData) === 'object' && 'delta' in transformData) {
                var delta = transformData.delta;
                // Check if delta has meaningful content (not just an empty object)
                var hasContent = delta && _typeof(delta) === 'object' && Object.keys(delta).length > 0;
                if (hasContent) {
                  transforms.add(transformKey);
                }
              }
            });
          }
        });
      }
    }
  }
  return Array.from(transforms);
}

/**
 * Pure helper function to apply transform to a source file.
 *
 * @param source - The source code to transform
 * @param fileName - The filename for the source
 * @param transforms - Available transforms for this source
 * @param selectedTransform - The transform to apply
 * @returns Object with transformed source and name
 */
export function applyTransformToSource(source, fileName, transforms, selectedTransform) {
  if (!(transforms != null && transforms[selectedTransform])) {
    return {
      transformedSource: source,
      transformedName: fileName
    };
  }
  try {
    // Get transform data
    var transformData = transforms[selectedTransform];
    if (!transformData || _typeof(transformData) !== 'object' || !('delta' in transformData)) {
      return {
        transformedSource: source,
        transformedName: fileName
      };
    }

    // Check if delta has meaningful content
    var delta = transformData.delta;
    var hasContent = delta && _typeof(delta) === 'object' && Object.keys(delta).length > 0;
    if (!hasContent) {
      return {
        transformedSource: source,
        transformedName: fileName
      };
    }

    // Apply transform
    var result = applyTransform(source, transforms, selectedTransform);
    var transformedName = transformData.fileName || fileName;
    return {
      transformedSource: result,
      transformedName: transformedName
    };
  } catch (error) {
    console.error("Transform failed for ".concat(fileName, ":"), error);
    return {
      transformedSource: source,
      transformedName: fileName
    };
  }
}

/**
 * Pure function to create transformed files from a variant and selected transform.
 *
 * @param selectedVariant - The currently selected variant
 * @param selectedTransform - The transform to apply
 * @returns Object with transformed files and filename mapping, or undefined if no transform
 */
export function createTransformedFiles(selectedVariant, selectedTransform, shouldHighlight) {
  var _variantTransforms$se;
  // Only create transformed files when there's actually a transform selected
  if (!selectedVariant || !selectedTransform) {
    return undefined;
  }
  var files = [];
  var filenameMap = {};

  // First, check if any file has a meaningful transform delta for the selected transform
  var variantTransforms = 'transforms' in selectedVariant ? selectedVariant.transforms : undefined;
  var hasAnyMeaningfulTransform = false;

  // Check main file for meaningful transform
  if (selectedVariant.fileName && variantTransforms != null && (_variantTransforms$se = variantTransforms[selectedTransform]) != null && _variantTransforms$se.delta) {
    var delta = variantTransforms[selectedTransform].delta;
    if (delta && Object.keys(delta).length > 0) {
      hasAnyMeaningfulTransform = true;
    }
  }

  // Check extraFiles for meaningful transforms
  if (!hasAnyMeaningfulTransform && selectedVariant.extraFiles) {
    Object.values(selectedVariant.extraFiles).forEach(function (fileData) {
      if (fileData && _typeof(fileData) === 'object' && 'transforms' in fileData) {
        var _fileData$transforms;
        var transformData = (_fileData$transforms = fileData.transforms) == null ? void 0 : _fileData$transforms[selectedTransform];
        if (transformData != null && transformData.delta && Object.keys(transformData.delta).length > 0) {
          hasAnyMeaningfulTransform = true;
        }
      }
    });
  }

  // If no file has a meaningful transform, return empty result
  if (!hasAnyMeaningfulTransform) {
    return {
      files: [],
      filenameMap: {}
    };
  }

  // Process main file if we have a fileName and source
  if (selectedVariant.fileName && selectedVariant.source) {
    var _applyTransformToSour = applyTransformToSource(selectedVariant.source, selectedVariant.fileName, variantTransforms, selectedTransform),
      mainSource = _applyTransformToSour.transformedSource,
      mainName = _applyTransformToSour.transformedName;
    var fileName = selectedVariant.fileName;
    filenameMap[fileName] = mainName;
    files.push({
      name: mainName,
      originalName: fileName,
      source: mainSource,
      component: stringOrHastToJsx(mainSource, shouldHighlight)
    });
  }

  // Process extra files
  if (selectedVariant.extraFiles) {
    Object.entries(selectedVariant.extraFiles).forEach(function (_ref) {
      var _transforms;
      var _ref2 = _slicedToArray(_ref, 2),
        extraFileName = _ref2[0],
        fileData = _ref2[1];
      var source;
      var transforms;

      // Handle different extraFile structures
      if (typeof fileData === 'string') {
        source = fileData;
        transforms = undefined; // Don't inherit variant transforms for simple string files
      } else if (fileData && _typeof(fileData) === 'object' && 'source' in fileData) {
        source = fileData.source;
        transforms = fileData.transforms; // Only use explicit transforms for this file
      } else {
        return; // Skip invalid entries
      }

      // Skip if source is undefined
      if (!source) {
        return;
      }

      // Apply transforms if available, otherwise use original source
      var transformedSource = source;
      var transformedName = extraFileName;
      if ((_transforms = transforms) != null && _transforms[selectedTransform]) {
        try {
          var transformData = transforms[selectedTransform];
          if (transformData && _typeof(transformData) === 'object' && 'delta' in transformData) {
            // Only apply transform if there's a meaningful delta
            var hasTransformDelta = transformData.delta && Object.keys(transformData.delta).length > 0;
            if (hasTransformDelta) {
              transformedSource = applyTransform(source, transforms, selectedTransform);
              transformedName = transformData.fileName || extraFileName;
            }
          }
        } catch (error) {
          console.error("Transform failed for ".concat(extraFileName, ":"), error);
          // Continue with original source if transform fails
        }
      }

      // Only update filenameMap and add to files if this doesn't conflict with existing files
      // If a file already exists with the target name, skip this transformation to preserve original files
      var existingFile = files.find(function (f) {
        return f.name === transformedName;
      });
      if (!existingFile) {
        filenameMap[extraFileName] = transformedName;
        files.push({
          name: transformedName,
          originalName: extraFileName,
          source: transformedSource,
          component: stringOrHastToJsx(transformedSource, shouldHighlight)
        });
      } else {
        // If there's a conflict, skip this file with a warning
        console.warn("Transform conflict: ".concat(extraFileName, " would transform to ").concat(transformedName, " but that name is already taken. Skipping this file."));
      }
    });
  }
  return {
    files: files,
    filenameMap: filenameMap
  };
}