@mui/internal-docs-infra 0.1.0 → 0.1.1-alpha.0

package/build/transformTsToJs/removeTypes.js

@@ -0,0 +1,141 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeTypes = removeTypes;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var Babel = _interopRequireWildcard(require("@babel/standalone"));
+var _standalone2 = _interopRequireDefault(require("prettier/standalone"));
+var _estree = _interopRequireDefault(require("prettier/plugins/estree"));
+var _parserBabel = _interopRequireDefault(require("prettier/parser-babel"));
+// Based on https://github.com/ember-cli/babel-remove-types/blob/fc3be010e99c4f4926fd70d00242d6777ab1b8d7/src/index.ts
+// Converted to use Babel standalone, with added TSX support
+/**
+ * Strips TypeScript types and decorators from code (including React in TSX),
+ * preserving blank lines and optionally formatting with Prettier.
+ *
+ * @param code - The source code string to transform.
+ * @param filename - The name of the file (e.g. "foo.ts" or "Foo.tsx").
+ *                   Determines whether TSX parsing is enabled.
+ * @param prettierConfig - `true` for default formatting, `false` to skip,
+ *                         or a Prettier options object to customize.
+ * @returns The transformed (and optionally formatted) code.
+ */
+function removeTypes(_x) {
+  return _removeTypes.apply(this, arguments);
+}
+function _removeTypes() {
+  _removeTypes = (0, _asyncToGenerator2["default"])(/*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee(code) {
+    var filename,
+      prettierConfig,
+      removeComments,
+      isTSX,
+      transformed,
+      fixed,
+      standardPrettierOptions,
+      mergedPrettierOptions,
+      _args = arguments;
+    return (0, _regeneratorRuntime2["default"])().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          filename = _args.length > 1 && _args[1] !== undefined ? _args[1] : 'file.ts';
+          prettierConfig = _args.length > 2 && _args[2] !== undefined ? _args[2] : true;
+          // Babel collapses newlines all over the place, which messes with the formatting of almost any
+          // code you pass to it. To preserve the formatting, we go through and mark all the empty lines
+          // in the code string *before* transforming it. This allows us to go back through after the
+          // transformation re-insert the empty lines in the correct place relative to the new code that
+          // has been generated.
+          code = code.replace(/\n\n+/g, '/* ___NEWLINE___ */\n');
+
+          // When removing TS-specific constructs (e.g. interfaces), we want to make sure we also remove
+          // any comments that are associated with those constructs, since otherwise we'll be left with
+          // comments that refer to something that isn't actually there.
+          // Credit to https://github.com/cyco130/detype for figuring out this very useful pattern
+          removeComments = {
+            enter: function enter(nodePath) {
+              if (!nodePath.node.leadingComments) {
+                return;
+              }
+              for (var i = nodePath.node.leadingComments.length - 1; i >= 0; i -= 1) {
+                var comment = nodePath.node.leadingComments[i];
+                if (code.slice(comment.end).match(/^\s*\n\s*\n/) || comment.value.includes('___NEWLINE___')) {
+                  // There is at least one empty line between the comment and the TypeScript specific construct
+                  // We should keep this comment and those before it
+                  break;
+                }
+                comment.value = '___REMOVE_ME___';
+              }
+            }
+          };
+          isTSX = /\.tsx$/i.test(filename);
+          transformed = Babel.transform(code, {
+            filename: filename,
+            plugins: [{
+              name: 'comment-remover',
+              visitor: {
+                TSTypeAliasDeclaration: removeComments,
+                TSInterfaceDeclaration: removeComments,
+                TSDeclareFunction: removeComments,
+                TSDeclareMethod: removeComments,
+                TSImportType: removeComments,
+                TSModuleDeclaration: removeComments
+              }
+            }, ['transform-typescript', {
+              onlyRemoveTypeImports: true,
+              isTSX: isTSX,
+              allExtensions: true
+            }], ['proposal-decorators', {
+              legacy: true
+            }]],
+            generatorOpts: {
+              retainLines: true,
+              shouldPrintComment: function shouldPrintComment(c) {
+                return c !== '___REMOVE_ME___';
+              }
+            }
+          });
+          if (!(!transformed || !transformed.code)) {
+            _context.next = 8;
+            break;
+          }
+          throw new Error('There was an issue with the Babel transform.');
+        case 8:
+          fixed = transformed.code.replace(/\/\* ___NEWLINE___ \*\//g, '\n'); // If the user has *explicitly* passed `false` here, it means they do not want us to run Prettier
+          // at all, so we bail here.
+          if (!(prettierConfig === false)) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("return", fixed);
+        case 11:
+          standardPrettierOptions = {
+            parser: 'babel',
+            singleQuote: true,
+            plugins: [_estree["default"], _parserBabel["default"]]
+          }; // If `prettierConfig` is *explicitly* true (as opposed to truthy), it means the user has opted in
+          // to default behavior either explicitly or implicitly. Either way, we run basic Prettier on it.
+          if (!(prettierConfig === true)) {
+            _context.next = 14;
+            break;
+          }
+          return _context.abrupt("return", _standalone2["default"].format(fixed, standardPrettierOptions));
+        case 14:
+          // If we've made it here, the user has passed their own Prettier options so we merge it with ours
+          // and let theirs overwrite any of the default settings.
+          mergedPrettierOptions = (0, _objectSpread2["default"])((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, standardPrettierOptions), prettierConfig), {}, {
+            plugins: standardPrettierOptions.plugins
+          });
+          return _context.abrupt("return", _standalone2["default"].format(fixed, mergedPrettierOptions));
+        case 16:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _removeTypes.apply(this, arguments);
+}

package/build/transformTsToJs/transformTsToJs.d.ts

@@ -0,0 +1,3 @@
+import type { SourceTransformer, TransformSource } from "../CodeHighlighter/index.js";
+export declare const transformTsToJs: TransformSource;
+export declare const TsToJsTransformer: SourceTransformer;

package/build/transformTsToJs/transformTsToJs.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformTsToJs = exports.TsToJsTransformer = void 0;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _removeTypes = require("./removeTypes");
+var transformTsToJs = exports.transformTsToJs = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee(source, fileName) {
+    var transformed, transformedFileName;
+    return (0, _regeneratorRuntime2["default"])().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return (0, _removeTypes.removeTypes)(source, fileName);
+        case 2:
+          transformed = _context.sent;
+          transformedFileName = fileName.replace(/\.ts$/, '.js').replace(/\.tsx$/, '.jsx');
+          return _context.abrupt("return", {
+            js: {
+              source: transformed,
+              fileName: transformedFileName
+            }
+          });
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function transformTsToJs(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var TsToJsTransformer = exports.TsToJsTransformer = {
+  extensions: ['ts', 'tsx'],
+  transformer: transformTsToJs
+};

package/build/useCode/index.d.ts

@@ -0,0 +1 @@
+export * from "./useCode.js";

package/build/useCode/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _useCode = require("./useCode");
+Object.keys(_useCode).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useCode[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useCode[key];
+    }
+  });
+});

package/build/useCode/useCode.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { UseCopierOpts } from "../useCopier/index.js";
+import { ContentProps } from "../CodeHighlighter/types.js";
+type UseCodeOpts = {
+  defaultOpen?: boolean;
+  copy?: UseCopierOpts;
+  githubUrlPrefix?: string;
+  codeSandboxUrlPrefix?: string;
+  stackBlitzPrefix?: string;
+  initialVariant?: string;
+  initialTransform?: string;
+};
+export interface UseCodeResult {
+  component: React.ReactNode;
+  ref: React.RefObject<HTMLDivElement | null>;
+  variants: string[];
+  selectedVariant: string;
+  selectVariant: React.Dispatch<React.SetStateAction<string>>;
+  files: Array<{
+    name: string;
+    component: React.ReactNode;
+  }>;
+  selectedFile: React.ReactNode;
+  selectedFileName: string;
+  selectFileName: React.Dispatch<React.SetStateAction<string>>;
+  expanded: boolean;
+  expand: () => void;
+  setExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+  resetFocus: () => void;
+  copy: (event: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
+  copyDisabled: boolean;
+  availableTransforms: string[];
+  selectedTransform: string | null | undefined;
+  selectTransform: (transformName: string | null) => void;
+}
+export declare function useCode(contentProps: ContentProps, opts?: UseCodeOpts): UseCodeResult;
+export {};

package/build/useCode/useCode.js

@@ -0,0 +1,401 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCode = useCode;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+var _hastUtilToText = require("hast-util-to-text");
+var _hastUtilToJsxRuntime = require("hast-util-to-jsx-runtime");
+var _useCopier2 = require("../useCopier");
+var _CodeHighlighterContext = require("../CodeHighlighter/CodeHighlighterContext");
+var _applyTransform = require("../CodeHighlighter/applyTransform");
+function toComponent(source) {
+  return (0, _hastUtilToJsxRuntime.toJsxRuntime)(source, {
+    Fragment: _jsxRuntime.Fragment,
+    jsx: _jsxRuntime.jsx,
+    jsxs: _jsxRuntime.jsxs
+  });
+}
+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;
+
+  // Safely try to get context values - will be undefined if not in context
+  var context = (0, _CodeHighlighterContext.useCodeHighlighterContextOptional)();
+  var _React$useState = React.useState(defaultOpen),
+    _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+    expanded = _React$useState2[0],
+    setExpanded = _React$useState2[1];
+  var expand = React.useCallback(function () {
+    return setExpanded(true);
+  }, []);
+  var ref = React.useRef(null);
+  var resetFocus = React.useCallback(function () {
+    var _ref$current;
+    (_ref$current = ref.current) == null || _ref$current.focus();
+  }, []);
+
+  // 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]);
+
+  // Get variant keys from effective code
+  var variantKeys = React.useMemo(function () {
+    return Object.keys(effectiveCode).filter(function (key) {
+      var variant = effectiveCode[key];
+      return variant && (0, _typeof2["default"])(variant) === 'object' && 'source' in variant;
+    });
+  }, [effectiveCode]);
+  var _React$useState3 = React.useState(initialVariant || variantKeys[0] || ''),
+    _React$useState4 = (0, _slicedToArray2["default"])(_React$useState3, 2),
+    selectedVariantKey = _React$useState4[0],
+    setSelectedVariantKey = _React$useState4[1];
+  var selectedVariant = React.useMemo(function () {
+    var variant = effectiveCode[selectedVariantKey];
+    if (variant && (0, _typeof2["default"])(variant) === 'object' && 'source' in variant) {
+      return variant;
+    }
+    return null;
+  }, [effectiveCode, selectedVariantKey]);
+
+  // Safety check: if selectedVariant doesn't exist, fall back to first variant
+  React.useEffect(function () {
+    if (!selectedVariant && variantKeys.length > 0) {
+      setSelectedVariantKey(variantKeys[0]);
+    }
+  }, [selectedVariant, variantKeys]);
+
+  // Transform state - get available transforms from context or from the effective code data
+  var availableTransforms = React.useMemo(function () {
+    // First try to get from context
+    if (context != null && context.availableTransforms && context.availableTransforms.length > 0) {
+      return context.availableTransforms;
+    }
+
+    // Otherwise, get from the effective code data
+    var transforms = new Set();
+    if (effectiveCode && selectedVariantKey) {
+      var variantCode = effectiveCode[selectedVariantKey];
+      if (variantCode && (0, _typeof2["default"])(variantCode) === 'object' && 'transforms' in variantCode && variantCode.transforms) {
+        Object.keys(variantCode.transforms).forEach(function (transformKey) {
+          transforms.add(transformKey);
+        });
+      }
+    }
+    return Array.from(transforms);
+  }, [context == null ? void 0 : context.availableTransforms, effectiveCode, selectedVariantKey]);
+  var _React$useState5 = React.useState(initialTransform || null),
+    _React$useState6 = (0, _slicedToArray2["default"])(_React$useState5, 2),
+    selectedTransform = _React$useState6[0],
+    setSelectedTransform = _React$useState6[1];
+
+  // Memoize all transformed files based on selectedTransform
+  var transformedFiles = React.useMemo(function () {
+    // Only create transformed files when there's actually a transform selected
+    if (!selectedVariant || !selectedTransform) {
+      return undefined;
+    }
+    var files = [];
+    var filenameMap = {};
+
+    // Helper function to apply transform to a source
+    var applyTransformToSource = function applyTransformToSource(source, fileName, transforms) {
+      if (!(transforms != null && transforms[selectedTransform])) {
+        return {
+          transformedSource: source,
+          transformedName: fileName
+        };
+      }
+      try {
+        // Get transform data
+        var transformData = transforms[selectedTransform];
+        if (!transformData || (0, _typeof2["default"])(transformData) !== 'object' || !('delta' in transformData)) {
+          return {
+            transformedSource: source,
+            transformedName: fileName
+          };
+        }
+
+        // Apply transform
+        var result = (0, _applyTransform.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
+        };
+      }
+    };
+
+    // Process main file - get transforms from selectedVariant
+    var variantTransforms = 'transforms' in selectedVariant ? selectedVariant.transforms : undefined;
+    var _applyTransformToSour = applyTransformToSource(selectedVariant.source, selectedVariant.fileName, variantTransforms),
+      mainSource = _applyTransformToSour.transformedSource,
+      mainName = _applyTransformToSour.transformedName;
+    filenameMap[selectedVariant.fileName] = mainName;
+    files.push({
+      name: mainName,
+      originalName: selectedVariant.fileName,
+      source: mainSource,
+      component: toComponent(mainSource)
+    });
+
+    // Process extra files
+    if (selectedVariant.extraFiles) {
+      Object.entries(selectedVariant.extraFiles).forEach(function (_ref2) {
+        var _transforms;
+        var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
+          fileName = _ref3[0],
+          fileData = _ref3[1];
+        var source;
+        var transforms;
+
+        // Handle different extraFile structures
+        if (typeof fileData === 'string') {
+          source = fileData;
+          transforms = variantTransforms;
+        } else if (fileData && (0, _typeof2["default"])(fileData) === 'object' && 'source' in fileData) {
+          source = fileData.source;
+          transforms = fileData.transforms || variantTransforms;
+        } else {
+          return; // Skip invalid entries
+        }
+
+        // Apply transforms if available
+        var transformedSource = source;
+        var transformedName = fileName;
+        if ((_transforms = transforms) != null && _transforms[selectedTransform]) {
+          try {
+            var transformData = transforms[selectedTransform];
+            if (transformData && (0, _typeof2["default"])(transformData) === 'object' && 'delta' in transformData) {
+              transformedSource = (0, _applyTransform.applyTransform)(source, transforms, selectedTransform);
+              transformedName = transformData.fileName || fileName;
+            }
+          } catch (error) {
+            console.error("Transform failed for ".concat(fileName, ":"), error);
+          }
+        }
+        filenameMap[fileName] = transformedName;
+        files.push({
+          name: transformedName,
+          originalName: fileName,
+          source: transformedSource,
+          component: toComponent(transformedSource)
+        });
+      });
+    }
+    return {
+      files: files,
+      filenameMap: filenameMap
+    };
+  }, [selectedVariant, selectedTransform]);
+
+  // Keep selectedFileName as untransformed filename for internal tracking
+  var _React$useState7 = React.useState((selectedVariant == null ? void 0 : selectedVariant.fileName) || ''),
+    _React$useState8 = (0, _slicedToArray2["default"])(_React$useState7, 2),
+    selectedFileNameInternal = _React$useState8[0],
+    setSelectedFileNameInternal = _React$useState8[1];
+
+  // Reset selectedFileName when variant changes
+  React.useEffect(function () {
+    if (selectedVariant && selectedFileNameInternal !== selectedVariant.fileName) {
+      // Only reset if current selectedFileName doesn't exist in the new variant
+      var hasFile = selectedVariant.fileName === selectedFileNameInternal || selectedVariant.extraFiles && selectedVariant.extraFiles[selectedFileNameInternal];
+      if (!hasFile) {
+        setSelectedFileNameInternal(selectedVariant.fileName);
+      }
+    }
+  }, [selectedVariant, selectedFileNameInternal]);
+
+  // Compute the displayed filename (transformed if applicable)
+  var selectedFileName = React.useMemo(function () {
+    if (!selectedVariant) {
+      return '';
+    }
+
+    // If we have transformed files, return the transformed name
+    if (transformedFiles) {
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === selectedFileNameInternal;
+      });
+      return file ? file.name : selectedFileNameInternal;
+    }
+
+    // Otherwise, return the original filename
+    return selectedFileNameInternal;
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles]);
+  var selectedFile = React.useMemo(function () {
+    if (!selectedVariant) {
+      return null;
+    }
+
+    // If we have transformed files, use them
+    if (transformedFiles) {
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === selectedFileNameInternal;
+      });
+      return file ? file.source : null;
+    }
+
+    // Otherwise, use the original untransformed files
+    if (selectedFileNameInternal === selectedVariant.fileName) {
+      return selectedVariant.source;
+    }
+
+    // Look in extraFiles
+    if (selectedVariant.extraFiles && selectedVariant.extraFiles[selectedFileNameInternal]) {
+      var extraFile = selectedVariant.extraFiles[selectedFileNameInternal];
+      if (typeof extraFile === 'string') {
+        return extraFile;
+      }
+      if (extraFile && (0, _typeof2["default"])(extraFile) === 'object' && 'source' in extraFile) {
+        return extraFile.source;
+      }
+    }
+    return null;
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles]);
+  var selectedFileComponent = React.useMemo(function () {
+    if (!selectedVariant) {
+      return null;
+    }
+
+    // If we have transformed files, use them
+    if (transformedFiles) {
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === selectedFileNameInternal;
+      });
+      return file ? file.component : null;
+    }
+
+    // Otherwise, create component from original untransformed files
+    if (selectedFileNameInternal === selectedVariant.fileName) {
+      return toComponent(selectedVariant.source);
+    }
+
+    // Look in extraFiles
+    if (selectedVariant.extraFiles && selectedVariant.extraFiles[selectedFileNameInternal]) {
+      var extraFile = selectedVariant.extraFiles[selectedFileNameInternal];
+      var source;
+      if (typeof extraFile === 'string') {
+        source = extraFile;
+      } else if (extraFile && (0, _typeof2["default"])(extraFile) === 'object' && 'source' in extraFile) {
+        source = extraFile.source;
+      } else {
+        return null;
+      }
+      return toComponent(source);
+    }
+    return null;
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles]);
+
+  // Convert files for the return interface
+  var files = React.useMemo(function () {
+    if (!selectedVariant) {
+      return [];
+    }
+
+    // If we have transformed files, use them
+    if (transformedFiles) {
+      return transformedFiles.files.map(function (f) {
+        return {
+          name: f.name,
+          component: f.component
+        };
+      });
+    }
+
+    // Otherwise, create files from original untransformed data
+    var result = [{
+      name: selectedVariant.fileName,
+      component: toComponent(selectedVariant.source)
+    }];
+    if (selectedVariant.extraFiles) {
+      Object.entries(selectedVariant.extraFiles).forEach(function (_ref4) {
+        var _ref5 = (0, _slicedToArray2["default"])(_ref4, 2),
+          fileName = _ref5[0],
+          fileData = _ref5[1];
+        var source;
+        if (typeof fileData === 'string') {
+          source = fileData;
+        } else if (fileData && (0, _typeof2["default"])(fileData) === 'object' && 'source' in fileData) {
+          source = fileData.source;
+        } else {
+          return; // Skip invalid entries
+        }
+        result.push({
+          name: fileName,
+          component: toComponent(source)
+        });
+      });
+    }
+    return result;
+  }, [selectedVariant, transformedFiles]);
+  var sourceFileToText = React.useCallback(function () {
+    if (!selectedFile) {
+      return undefined;
+    }
+    if (typeof selectedFile === 'string') {
+      return selectedFile;
+    }
+    if (selectedFile && (0, _typeof2["default"])(selectedFile) === 'object' && 'hastJson' in selectedFile) {
+      return selectedFile.hastJson;
+    }
+    return (0, _hastUtilToText.toText)(selectedFile, {
+      whitespace: 'pre'
+    });
+  }, [selectedFile]);
+  var _useCopier = (0, _useCopier2.useCopier)(sourceFileToText, copyOpts),
+    copy = _useCopier.copy,
+    copyDisabled = _useCopier.disabled;
+
+  // Function to switch to a specific transform
+  var selectTransform = React.useCallback(function (transformName) {
+    if (!transformName || availableTransforms.includes(transformName)) {
+      setSelectedTransform(transformName);
+    } else {
+      setSelectedTransform(null);
+    }
+  }, [availableTransforms]);
+
+  // Get the effective components object - context overrides contentProps
+  // Components are kept separate from variant data to maintain clean separation of concerns
+  var effectiveComponents = React.useMemo(function () {
+    return (context == null ? void 0 : context.components) || contentProps.components || {};
+  }, [context == null ? void 0 : context.components, contentProps.components]);
+  return {
+    component: effectiveComponents[selectedVariantKey] || null,
+    ref: ref,
+    variants: variantKeys,
+    selectedVariant: selectedVariantKey,
+    selectVariant: setSelectedVariantKey,
+    files: files,
+    selectedFile: selectedFileComponent,
+    selectedFileName: selectedFileName,
+    selectFileName: setSelectedFileNameInternal,
+    expanded: expanded,
+    expand: expand,
+    setExpanded: setExpanded,
+    resetFocus: resetFocus,
+    copy: copy,
+    copyDisabled: copyDisabled,
+    availableTransforms: availableTransforms,
+    selectedTransform: selectedTransform,
+    selectTransform: selectTransform
+  };
+}