@mui/internal-docs-infra 0.1.1-alpha.1 → 0.1.1-alpha.10

package/useCode/useCodeUtils.js

@@ -0,0 +1,240 @@
+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
+  if (selectedVariant.fileName) {
+    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
+      }
+
+      // 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
+  };
+}

package/useCode/useCopyFunctionality.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { UseCopierOpts } from "../useCopier/index.js";
+interface UseCopyFunctionalityProps {
+  selectedFile: any;
+  copyOpts?: UseCopierOpts;
+}
+export interface UseCopyFunctionalityResult {
+  copy: (event: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
+}
+/**
+ * Hook for managing copy-to-clipboard functionality
+ */
+export declare function useCopyFunctionality({
+  selectedFile,
+  copyOpts
+}: UseCopyFunctionalityProps): UseCopyFunctionalityResult;
+export {};

package/useCode/useCopyFunctionality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCopyFunctionality.d.ts","sourceRoot":"","sources":["../../src/useCode/useCopyFunctionality.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAa,aAAa,EAAE,MAAM,cAAc,CAAC;AAExD,UAAU,yBAAyB;IACjC,YAAY,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,YAAY,EACZ,QAAQ,GACT,EAAE,yBAAyB,GAAG,0BAA0B,CAsBxD"}

package/useCode/useCopyFunctionality.js

@@ -0,0 +1,28 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import * as React from 'react';
+import { stringOrHastToString } from "../pipeline/hastUtils/index.js";
+import { useCopier } from "../useCopier/index.js";
+/**
+ * Hook for managing copy-to-clipboard functionality
+ */
+export function useCopyFunctionality(_ref) {
+  var selectedFile = _ref.selectedFile,
+    copyOpts = _ref.copyOpts;
+  var sourceFileToText = React.useCallback(function () {
+    if (!selectedFile) {
+      return undefined;
+    }
+    if (typeof selectedFile === 'string') {
+      return selectedFile;
+    }
+    if (selectedFile && _typeof(selectedFile) === 'object' && 'hastJson' in selectedFile) {
+      return selectedFile.hastJson;
+    }
+    return stringOrHastToString(selectedFile);
+  }, [selectedFile]);
+  var _useCopier = useCopier(sourceFileToText, copyOpts),
+    copy = _useCopier.copy;
+  return {
+    copy: copy
+  };
+}

package/useCode/useFileNavigation.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import type { VariantSource } from "../CodeHighlighter/types.js";
+type Source = VariantSource;
+interface TransformedFile {
+  name: string;
+  originalName: string;
+  source: Source;
+  component: React.ReactNode;
+}
+interface TransformedFiles {
+  files: TransformedFile[];
+  filenameMap: {
+    [originalName: string]: string;
+  };
+}
+interface UseFileNavigationProps {
+  selectedVariant: any;
+  transformedFiles: TransformedFiles | undefined;
+  mainSlug?: string;
+  selectedVariantKey?: string;
+  variantKeys?: string[];
+  shouldHighlight: boolean;
+  initialVariant?: string;
+}
+export interface UseFileNavigationResult {
+  selectedFileName: string | undefined;
+  selectedFile: any;
+  selectedFileComponent: React.ReactNode;
+  files: Array<{
+    name: string;
+    slug?: string;
+    component: React.ReactNode;
+  }>;
+  selectFileName: (fileName: string) => void;
+}
+/**
+ * Hook for managing file selection and navigation within a code variant
+ */
+export declare function useFileNavigation({
+  selectedVariant,
+  transformedFiles,
+  mainSlug,
+  selectedVariantKey,
+  variantKeys,
+  initialVariant,
+  shouldHighlight
+}: UseFileNavigationProps): UseFileNavigationResult;
+export {};

package/useCode/useFileNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFileNavigation.d.ts","sourceRoot":"","sources":["../../src/useCode/useFileNavigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D,KAAK,MAAM,GAAG,aAAa,CAAC;AA0D5B,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,UAAU,gBAAgB;IACxB,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,WAAW,EAAE;QAAE,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACjD;AAED,UAAU,sBAAsB;IAC9B,eAAe,EAAE,GAAG,CAAC;IACrB,gBAAgB,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,YAAY,EAAE,GAAG,CAAC;IAClB,qBAAqB,EAAE,KAAK,CAAC,SAAS,CAAC;IACvC,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAC;IAC1E,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,eAAe,EACf,gBAAgB,EAChB,QAAa,EACb,kBAAuB,EACvB,WAAgB,EAChB,cAAc,EACd,eAAe,GAChB,EAAE,sBAAsB,GAAG,uBAAuB,CAkYlD"}