@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.4

package/esm/useCode/useCode.js

@@ -1,6 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["name", "slug", "code", "components", "url"];
 import * as React from 'react';
 import { useCodeHighlighterContextOptional } from "../CodeHighlighter/CodeHighlighterContext.js";
 import { extractNameAndSlugFromUrl } from "../pipeline/loaderUtils/index.js";
@@ -11,111 +8,112 @@ import { useUIState } from "./useUIState.js";
 import { useCopyFunctionality } from "./useCopyFunctionality.js";
 import { useSourceEditing } from "./useSourceEditing.js";
 export function useCode(contentProps, opts) {
-  var _ref = opts || {},
-    copyOpts = _ref.copy,
-    _ref$defaultOpen = _ref.defaultOpen,
-    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen,
-    initialVariant = _ref.initialVariant,
-    initialTransform = _ref.initialTransform,
-    preClassName = _ref.preClassName,
-    preRef = _ref.preRef,
-    _ref$fileHashMode = _ref.fileHashMode,
-    fileHashMode = _ref$fileHashMode === void 0 ? 'remove-hash' : _ref$fileHashMode,
-    _ref$saveHashVariantT = _ref.saveHashVariantToLocalStorage,
-    saveHashVariantToLocalStorage = _ref$saveHashVariantT === void 0 ? 'on-interaction' : _ref$saveHashVariantT;
+  const {
+    copy: copyOpts,
+    defaultOpen = false,
+    initialVariant,
+    initialTransform,
+    preClassName,
+    preRef,
+    fileHashMode = 'remove-hash',
+    saveHashVariantToLocalStorage = 'on-interaction'
+  } = opts || {};
 
   // Safely try to get context values - will be undefined if not in context
-  var context = useCodeHighlighterContextOptional();
+  const context = useCodeHighlighterContextOptional();
 
   // Get the effective code - context overrides contentProps if available
-  var effectiveCode = React.useMemo(function () {
-    return (context == null ? void 0 : context.code) || contentProps.code || {};
-  }, [context == null ? void 0 : context.code, contentProps.code]);
-  var shouldHighlight = !(context != null && context.deferHighlight);
+  const effectiveCode = React.useMemo(() => {
+    return context?.code || contentProps.code || {};
+  }, [context?.code, contentProps.code]);
+  const shouldHighlight = !context?.deferHighlight;
 
   // Memoize userProps with auto-generated name and slug if missing
-  var userProps = React.useMemo(function () {
+  const userProps = React.useMemo(() => {
     // Extract only the user-defined properties (T) from contentProps
-    var contentName = contentProps.name,
-      contentSlug = contentProps.slug,
-      code = contentProps.code,
-      components = contentProps.components,
-      contentUrl = contentProps.url,
-      userDefinedProps = _objectWithoutPropertiesLoose(contentProps, _excluded);
+    const {
+      name: contentName,
+      slug: contentSlug,
+      code,
+      components,
+      url: contentUrl,
+      ...userDefinedProps
+    } = contentProps;
     // Get URL from context first, then fall back to contentProps
-    var effectiveUrl = (context == null ? void 0 : context.url) || contentUrl;
-    var name = contentName;
-    var slug = contentSlug;
+    const effectiveUrl = context?.url || contentUrl;
+    let name = contentName;
+    let slug = contentSlug;
     // Generate name and slug from URL if they're missing and we have a URL
     if ((!name || !slug) && effectiveUrl) {
       try {
-        var generated = extractNameAndSlugFromUrl(effectiveUrl);
+        const generated = extractNameAndSlugFromUrl(effectiveUrl);
         name = name || generated.name;
         slug = slug || generated.slug;
-      } catch (_unused) {
+      } catch {
         // If URL parsing fails, keep the original values (which might be undefined)
       }
     }
-    return _extends(_extends({}, userDefinedProps), {}, {
-      name: name,
-      slug: slug
-    });
-  }, [contentProps, context == null ? void 0 : context.url]);
+    return {
+      ...userDefinedProps,
+      name,
+      slug
+    };
+  }, [contentProps, context?.url]);
 
   // Sub-hook: UI State Management (needs slug to check for relevant hash)
-  var uiState = useUIState({
-    defaultOpen: defaultOpen,
+  const uiState = useUIState({
+    defaultOpen,
     mainSlug: userProps.slug
   });
 
   // Sub-hook: Variant Selection
-  var variantSelection = useVariantSelection({
-    effectiveCode: effectiveCode,
-    initialVariant: initialVariant,
+  const variantSelection = useVariantSelection({
+    effectiveCode,
+    initialVariant,
     variantType: contentProps.variantType,
     mainSlug: userProps.slug,
-    saveHashVariantToLocalStorage: saveHashVariantToLocalStorage
+    saveHashVariantToLocalStorage
   });
 
   // Sub-hook: Transform Management
-  var transformManagement = useTransformManagement({
-    context: context,
-    effectiveCode: effectiveCode,
+  const transformManagement = useTransformManagement({
+    context,
+    effectiveCode,
     selectedVariantKey: variantSelection.selectedVariantKey,
     selectedVariant: variantSelection.selectedVariant,
-    initialTransform: initialTransform,
-    shouldHighlight: shouldHighlight
+    initialTransform,
+    shouldHighlight
   });
 
   // Sub-hook: File Navigation
-  var fileNavigation = useFileNavigation({
+  const fileNavigation = useFileNavigation({
     selectedVariant: variantSelection.selectedVariant,
     transformedFiles: transformManagement.transformedFiles,
     mainSlug: userProps.slug,
     selectedVariantKey: variantSelection.selectedVariantKey,
     selectVariant: variantSelection.selectVariantProgrammatic,
     variantKeys: variantSelection.variantKeys,
-    shouldHighlight: shouldHighlight,
-    preClassName: preClassName,
-    preRef: preRef,
-    effectiveCode: effectiveCode,
-    fileHashMode: fileHashMode,
-    saveHashVariantToLocalStorage: saveHashVariantToLocalStorage,
+    shouldHighlight,
+    preClassName,
+    preRef,
+    effectiveCode,
+    fileHashMode,
+    saveHashVariantToLocalStorage,
     saveVariantToLocalStorage: variantSelection.saveVariantToLocalStorage,
     hashVariant: variantSelection.hashVariant
   });
 
   // Sub-hook: Copy Functionality
-  var copyFunctionality = useCopyFunctionality({
+  const copyFunctionality = useCopyFunctionality({
     selectedFile: fileNavigation.selectedFile,
-    copyOpts: copyOpts
+    copyOpts
   });
 
   // Sub-hook: Source Editing
-  var sourceEditing = useSourceEditing({
-    context: context,
+  const sourceEditing = useSourceEditing({
+    context,
     selectedVariantKey: variantSelection.selectedVariantKey,
-    effectiveCode: effectiveCode,
+    effectiveCode,
     selectedVariant: variantSelection.selectedVariant
   });
   return {
@@ -136,6 +134,6 @@ export function useCode(contentProps, opts) {
     selectedTransform: transformManagement.selectedTransform,
     selectTransform: transformManagement.selectTransform,
     setSource: sourceEditing.setSource,
-    userProps: userProps
+    userProps
   };
 }

package/esm/useCode/useCodeUtils.js

@@ -1,5 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { stringOrHastToJsx } from "../pipeline/hastUtils/index.js";
 import { applyCodeTransform } from "../pipeline/loadCodeVariant/applyCodeTransform.js";
 /**
@@ -11,20 +9,20 @@ import { applyCodeTransform } from "../pipeline/loadCodeVariant/applyCodeTransfo
  * @returns Array of available transform keys that have deltas
  */
 export function getAvailableTransforms(effectiveCode, selectedVariantKey) {
-  var transforms = new Set();
+  const transforms = new Set();
   if (effectiveCode && selectedVariantKey) {
-    var variantCode = effectiveCode[selectedVariantKey];
-    if (variantCode && _typeof(variantCode) === 'object') {
+    const 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];
+        Object.keys(variantCode.transforms).forEach(transformKey => {
+          const 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;
+          if (transformData && typeof transformData === 'object' && 'delta' in transformData) {
+            const 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;
+            const hasContent = delta && typeof delta === 'object' && Object.keys(delta).length > 0;
             if (hasContent) {
               transforms.add(transformKey);
             }
@@ -34,16 +32,16 @@ export function getAvailableTransforms(effectiveCode, selectedVariantKey) {
 
       // 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];
+        Object.values(variantCode.extraFiles).forEach(fileData => {
+          if (fileData && typeof fileData === 'object' && 'transforms' in fileData && fileData.transforms) {
+            Object.keys(fileData.transforms).forEach(transformKey => {
+              const 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;
+              if (transformData && typeof transformData === 'object' && 'delta' in transformData) {
+                const 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;
+                const hasContent = delta && typeof delta === 'object' && Object.keys(delta).length > 0;
                 if (hasContent) {
                   transforms.add(transformKey);
                 }
@@ -67,7 +65,7 @@ export function getAvailableTransforms(effectiveCode, selectedVariantKey) {
  * @returns Object with transformed source and name
  */
 export function applyTransformToSource(source, fileName, transforms, selectedTransform) {
-  if (!(transforms != null && transforms[selectedTransform])) {
+  if (!transforms?.[selectedTransform]) {
     return {
       transformedSource: source,
       transformedName: fileName
@@ -75,8 +73,8 @@ export function applyTransformToSource(source, fileName, transforms, selectedTra
   }
   try {
     // Get transform data
-    var transformData = transforms[selectedTransform];
-    if (!transformData || _typeof(transformData) !== 'object' || !('delta' in transformData)) {
+    const transformData = transforms[selectedTransform];
+    if (!transformData || typeof transformData !== 'object' || !('delta' in transformData)) {
       return {
         transformedSource: source,
         transformedName: fileName
@@ -84,8 +82,8 @@ export function applyTransformToSource(source, fileName, transforms, selectedTra
     }
 
     // Check if delta has meaningful content
-    var delta = transformData.delta;
-    var hasContent = delta && _typeof(delta) === 'object' && Object.keys(delta).length > 0;
+    const delta = transformData.delta;
+    const hasContent = delta && typeof delta === 'object' && Object.keys(delta).length > 0;
     if (!hasContent) {
       return {
         transformedSource: source,
@@ -94,14 +92,14 @@ export function applyTransformToSource(source, fileName, transforms, selectedTra
     }
 
     // Apply transform
-    var result = applyCodeTransform(source, transforms, selectedTransform);
-    var transformedName = transformData.fileName || fileName;
+    const result = applyCodeTransform(source, transforms, selectedTransform);
+    const transformedName = transformData.fileName || fileName;
     return {
       transformedSource: result,
-      transformedName: transformedName
+      transformedName
     };
   } catch (error) {
-    console.error("Transform failed for ".concat(fileName, ":"), error);
+    console.error(`Transform failed for ${fileName}:`, error);
     return {
       transformedSource: source,
       transformedName: fileName
@@ -117,21 +115,20 @@ export function applyTransformToSource(source, fileName, transforms, selectedTra
  * @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 = {};
+  const files = [];
+  const 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;
+  const variantTransforms = 'transforms' in selectedVariant ? selectedVariant.transforms : undefined;
+  let 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 (selectedVariant.fileName && variantTransforms?.[selectedTransform]?.delta) {
+    const delta = variantTransforms[selectedTransform].delta;
     if (delta && Object.keys(delta).length > 0) {
       hasAnyMeaningfulTransform = true;
     }
@@ -139,11 +136,10 @@ export function createTransformedFiles(selectedVariant, selectedTransform, shoul
 
   // 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) {
+    Object.values(selectedVariant.extraFiles).forEach(fileData => {
+      if (fileData && typeof fileData === 'object' && 'transforms' in fileData) {
+        const transformData = fileData.transforms?.[selectedTransform];
+        if (transformData?.delta && Object.keys(transformData.delta).length > 0) {
           hasAnyMeaningfulTransform = true;
         }
       }
@@ -160,10 +156,11 @@ export function createTransformedFiles(selectedVariant, selectedTransform, shoul
 
   // 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;
+    const {
+      transformedSource: mainSource,
+      transformedName: mainName
+    } = applyTransformToSource(selectedVariant.source, selectedVariant.fileName, variantTransforms, selectedTransform);
+    const fileName = selectedVariant.fileName;
     filenameMap[fileName] = mainName;
     files.push({
       name: mainName,
@@ -175,19 +172,15 @@ export function createTransformedFiles(selectedVariant, selectedTransform, shoul
 
   // 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;
+    Object.entries(selectedVariant.extraFiles).forEach(([extraFileName, fileData]) => {
+      let source;
+      let 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) {
+      } else if (fileData && typeof fileData === 'object' && 'source' in fileData) {
         source = fileData.source;
         transforms = fileData.transforms; // Only use explicit transforms for this file
       } else {
@@ -200,30 +193,28 @@ export function createTransformedFiles(selectedVariant, selectedTransform, shoul
       }
 
       // Apply transforms if available, otherwise use original source
-      var transformedSource = source;
-      var transformedName = extraFileName;
-      if ((_transforms = transforms) != null && _transforms[selectedTransform]) {
+      let transformedSource = source;
+      let transformedName = extraFileName;
+      if (transforms?.[selectedTransform]) {
         try {
-          var transformData = transforms[selectedTransform];
-          if (transformData && _typeof(transformData) === 'object' && 'delta' in transformData) {
+          const 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;
+            const hasTransformDelta = transformData.delta && Object.keys(transformData.delta).length > 0;
             if (hasTransformDelta) {
               transformedSource = applyCodeTransform(source, transforms, selectedTransform);
               transformedName = transformData.fileName || extraFileName;
             }
           }
         } catch (error) {
-          console.error("Transform failed for ".concat(extraFileName, ":"), error);
+          console.error(`Transform failed for ${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;
-      });
+      const existingFile = files.find(f => f.name === transformedName);
       if (!existingFile) {
         filenameMap[extraFileName] = transformedName;
         files.push({
@@ -234,12 +225,12 @@ export function createTransformedFiles(selectedVariant, selectedTransform, shoul
         });
       } 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."));
+        console.warn(`Transform conflict: ${extraFileName} would transform to ${transformedName} but that name is already taken. Skipping this file.`);
       }
     });
   }
   return {
-    files: files,
-    filenameMap: filenameMap
+    files,
+    filenameMap
   };
 }

package/esm/useCode/useCopyFunctionality.js

@@ -1,28 +1,29 @@
-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 () {
+export function useCopyFunctionality({
+  selectedFile,
+  copyOpts
+}) {
+  const sourceFileToText = React.useCallback(() => {
     if (!selectedFile) {
       return undefined;
     }
     if (typeof selectedFile === 'string') {
       return selectedFile;
     }
-    if (selectedFile && _typeof(selectedFile) === 'object' && 'hastJson' in selectedFile) {
+    if (selectedFile && typeof selectedFile === 'object' && 'hastJson' in selectedFile) {
       return selectedFile.hastJson;
     }
     return stringOrHastToString(selectedFile);
   }, [selectedFile]);
-  var _useCopier = useCopier(sourceFileToText, copyOpts),
-    copy = _useCopier.copy;
+  const {
+    copy
+  } = useCopier(sourceFileToText, copyOpts);
   return {
-    copy: copy
+    copy
   };
 }