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

package/esm/useDemo/useDemo.js

@@ -1,5 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import * as React from 'react';
 import kebabCase from 'kebab-case';
 import { useCode } from "../useCode/index.js";
@@ -29,7 +27,7 @@ import { flattenCodeVariant } from "../pipeline/loadCodeVariant/flattenCodeVaria
  * Helper to create HTML form element with hidden inputs
  */
 export function addHiddenInput(form, name, value) {
-  var input = document.createElement('input');
+  const input = document.createElement('input');
   input.type = 'hidden';
   input.name = name;
   input.value = value;
@@ -40,21 +38,17 @@ export function addHiddenInput(form, name, value) {
  * Generic function to create and submit a form for opening online demo platforms
  * This function creates HTML elements and should be used in browser contexts
  */
-export function openWithForm(_ref) {
-  var url = _ref.url,
-    formData = _ref.formData,
-    _ref$method = _ref.method,
-    method = _ref$method === void 0 ? 'POST' : _ref$method,
-    _ref$target = _ref.target,
-    target = _ref$target === void 0 ? '_blank' : _ref$target;
-  var form = document.createElement('form');
+export function openWithForm({
+  url,
+  formData,
+  method = 'POST',
+  target = '_blank'
+}) {
+  const form = document.createElement('form');
   form.method = method;
   form.target = target;
   form.action = url;
-  Object.entries(formData).forEach(function (_ref2) {
-    var _ref3 = _slicedToArray(_ref2, 2),
-      name = _ref3[0],
-      value = _ref3[1];
+  Object.entries(formData).forEach(([name, value]) => {
     addHiddenInput(form, name, value);
   });
   document.body.appendChild(form);
@@ -64,130 +58,132 @@ export function openWithForm(_ref) {
 
 // TODO: take initialVariant and initialTransforms as parameters
 export function useDemo(contentProps, opts) {
-  var code = useCode(contentProps, opts);
+  const code = useCode(contentProps, opts);
 
   // Extract export configuration options
-  var _ref4 = opts || {},
-    _ref4$export = _ref4["export"],
-    commonExportConfig = _ref4$export === void 0 ? {} : _ref4$export,
-    _ref4$exportStackBlit = _ref4.exportStackBlitz,
-    stackBlitzExportConfig = _ref4$exportStackBlit === void 0 ? {} : _ref4$exportStackBlit,
-    _ref4$exportCodeSandb = _ref4.exportCodeSandbox,
-    codeSandboxExportConfig = _ref4$exportCodeSandb === void 0 ? {} : _ref4$exportCodeSandb;
+  const {
+    export: commonExportConfig = {},
+    exportStackBlitz: stackBlitzExportConfig = {},
+    exportCodeSandbox: codeSandboxExportConfig = {}
+  } = opts || {};
 
   // Get context to access components if available (using React.useContext to avoid import conflicts)
-  var context = React.useContext(CodeHighlighterContext);
-  var slug = React.useMemo(function () {
-    return contentProps.slug || (contentProps.name ? kebabCase(contentProps.name, false) : undefined);
-  }, [contentProps.slug, contentProps.name]);
+  const context = React.useContext(CodeHighlighterContext);
+  const slug = React.useMemo(() => contentProps.slug || (contentProps.name ? kebabCase(contentProps.name, false) : undefined), [contentProps.slug, contentProps.name]);
 
   // Get the effective components object - context overrides contentProps
-  var effectiveComponents = React.useMemo(function () {
-    return (context == null ? void 0 : context.components) || contentProps.components || {};
-  }, [context == null ? void 0 : context.components, contentProps.components]);
+  const effectiveComponents = React.useMemo(() => {
+    return context?.components || contentProps.components || {};
+  }, [context?.components, contentProps.components]);
 
   // Get the component for the current variant
-  var component = React.useMemo(function () {
+  const component = React.useMemo(() => {
     return effectiveComponents[code.selectedVariant] || null;
   }, [effectiveComponents, code.selectedVariant]);
 
   // Demo-specific ref and focus management
-  var ref = React.useRef(null);
-  var resetFocus = React.useCallback(function () {
-    var _ref$current;
-    (_ref$current = ref.current) == null || _ref$current.focus();
+  const ref = React.useRef(null);
+  const resetFocus = React.useCallback(() => {
+    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]);
+  const effectiveCode = React.useMemo(() => {
+    return context?.code || contentProps.code || {};
+  }, [context?.code, contentProps.code]);
 
   // Create StackBlitz demo callback
-  var openStackBlitz = React.useCallback(function () {
+  const openStackBlitz = React.useCallback(() => {
     // Get the current variant code
-    var variantCode = effectiveCode[code.selectedVariant];
+    const variantCode = effectiveCode[code.selectedVariant];
     if (!variantCode || typeof variantCode === 'string') {
       console.warn('No valid variant code available for StackBlitz demo');
       return;
     }
-    var title = contentProps.name || 'Demo';
-    var description = "".concat(title, " demo");
+    const title = contentProps.name || 'Demo';
+    const description = `${title} demo`;
 
     // Determine if we should use TypeScript based on whether 'js' transform is NOT applied
     // If 'js' transform is applied, it means we're showing the JS version of TS code
-    var useTypescript = code.selectedTransform !== 'js';
+    const useTypescript = code.selectedTransform !== 'js';
 
     // Merge common export config with StackBlitz-specific config
-    var mergedConfig = _extends(_extends(_extends({}, commonExportConfig), stackBlitzExportConfig), {}, {
+    const mergedConfig = {
+      ...commonExportConfig,
+      ...stackBlitzExportConfig,
       variantName: code.selectedVariant,
-      title: title,
-      description: description,
-      useTypescript: useTypescript
-    });
+      title,
+      description,
+      useTypescript
+    };
 
     // Use custom export function if provided, otherwise use default exportVariant
-    var exportFunction = mergedConfig.exportFunction || exportVariant;
-    var _exportFunction = exportFunction(variantCode, mergedConfig),
-      exported = _exportFunction.exported,
-      rootFile = _exportFunction.rootFile;
+    const exportFunction = mergedConfig.exportFunction || exportVariant;
+    const {
+      exported,
+      rootFile
+    } = exportFunction(variantCode, mergedConfig);
 
     // Flatten the variant to get a flat file structure
-    var flattenedFiles = flattenCodeVariant(exported);
-    var stackBlitzDemo = createStackBlitz({
-      title: title,
-      description: description,
-      flattenedFiles: flattenedFiles,
-      rootFile: rootFile
+    const flattenedFiles = flattenCodeVariant(exported);
+    const stackBlitzDemo = createStackBlitz({
+      title,
+      description,
+      flattenedFiles,
+      rootFile
     });
     openWithForm(stackBlitzDemo);
   }, [effectiveCode, code.selectedVariant, code.selectedTransform, contentProps.name, commonExportConfig, stackBlitzExportConfig]);
 
   // Create CodeSandbox demo callback
-  var openCodeSandbox = React.useCallback(function () {
+  const openCodeSandbox = React.useCallback(() => {
     // Get the current variant code
-    var variantCode = effectiveCode[code.selectedVariant];
+    const variantCode = effectiveCode[code.selectedVariant];
     if (!variantCode || typeof variantCode === 'string') {
       console.warn('No valid variant code available for CodeSandbox demo');
       return;
     }
-    var title = contentProps.name || 'Demo';
-    var description = "".concat(title, " demo");
+    const title = contentProps.name || 'Demo';
+    const description = `${title} demo`;
 
     // Determine if we should use TypeScript based on whether 'js' transform is NOT applied
     // If 'js' transform is applied, it means we're showing the JS version of TS code
-    var useTypescript = code.selectedTransform !== 'js';
+    const useTypescript = code.selectedTransform !== 'js';
 
     // Merge common export config with CodeSandbox-specific config
-    var mergedConfig = _extends(_extends(_extends({}, commonExportConfig), codeSandboxExportConfig), {}, {
+    const mergedConfig = {
+      ...commonExportConfig,
+      ...codeSandboxExportConfig,
       variantName: code.selectedVariant,
-      title: title,
-      description: description,
-      useTypescript: useTypescript
-    });
+      title,
+      description,
+      useTypescript
+    };
 
     // Use custom export function if provided, otherwise use default exportVariantAsCra
-    var exportFunction = mergedConfig.exportFunction || exportVariantAsCra;
-    var _exportFunction2 = exportFunction(variantCode, mergedConfig),
-      craExport = _exportFunction2.exported,
-      rootFile = _exportFunction2.rootFile;
+    const exportFunction = mergedConfig.exportFunction || exportVariantAsCra;
+    const {
+      exported: craExport,
+      rootFile
+    } = exportFunction(variantCode, mergedConfig);
 
     // Flatten the variant to get a flat file structure
-    var flattenedFiles = flattenCodeVariant(craExport);
-    var codeSandboxDemo = createCodeSandbox({
-      flattenedFiles: flattenedFiles,
-      rootFile: rootFile
+    const flattenedFiles = flattenCodeVariant(craExport);
+    const codeSandboxDemo = createCodeSandbox({
+      flattenedFiles,
+      rootFile
     });
     openWithForm(codeSandboxDemo);
   }, [effectiveCode, code.selectedVariant, code.selectedTransform, contentProps.name, commonExportConfig, codeSandboxExportConfig]);
-  return _extends(_extends({}, code), {}, {
+  return {
+    ...code,
     // Demo-specific additions
-    component: component,
-    ref: ref,
-    resetFocus: resetFocus,
-    openStackBlitz: openStackBlitz,
-    openCodeSandbox: openCodeSandbox,
+    component,
+    ref,
+    resetFocus,
+    openStackBlitz,
+    openCodeSandbox,
     name: contentProps.name,
-    slug: slug
-  });
+    slug
+  };
 }

package/esm/useErrors/ErrorsContext.js

@@ -1,7 +1,7 @@
 'use client';
 
 import * as React from 'react';
-export var CodeErrorsContext = /*#__PURE__*/React.createContext(undefined);
+export const CodeErrorsContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") CodeErrorsContext.displayName = "CodeErrorsContext";
 export function useErrorsContext() {
   return React.useContext(CodeErrorsContext);

package/esm/useErrors/useErrors.js

@@ -1,11 +1,11 @@
 import { useErrorsContext } from "./ErrorsContext.js";
 export function useErrors(props) {
-  var context = useErrorsContext();
+  const context = useErrorsContext();
 
   // Context errors take precedence over prop errors
   // This ensures client-side errors override server-side errors
-  var errors = (context == null ? void 0 : context.errors) || (props == null ? void 0 : props.errors);
+  const errors = context?.errors || props?.errors;
   return {
-    errors: errors
+    errors
   };
 }

package/esm/useLocalStorageState/useLocalStorageState.js

@@ -1,6 +1,5 @@
 'use client';
 
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import * as React from 'react';
 
 /**
@@ -8,9 +7,9 @@ import * as React from 'react';
  */
 
 // storage events only work across tabs, we'll use an event emitter to announce within the current tab
-var currentTabChangeListeners = new Map();
+const currentTabChangeListeners = new Map();
 function onCurrentTabStorageChange(key, handler) {
-  var listeners = currentTabChangeListeners.get(key);
+  let listeners = currentTabChangeListeners.get(key);
   if (!listeners) {
     listeners = new Set();
     currentTabChangeListeners.set(key, listeners);
@@ -18,35 +17,33 @@ function onCurrentTabStorageChange(key, handler) {
   listeners.add(handler);
 }
 function offCurrentTabStorageChange(key, handler) {
-  var listeners = currentTabChangeListeners.get(key);
+  const listeners = currentTabChangeListeners.get(key);
   if (!listeners) {
     return;
   }
-  listeners["delete"](handler);
+  listeners.delete(handler);
   if (listeners.size === 0) {
-    currentTabChangeListeners["delete"](key);
+    currentTabChangeListeners.delete(key);
   }
 }
 function emitCurrentTabStorageChange(key) {
-  var listeners = currentTabChangeListeners.get(key);
+  const listeners = currentTabChangeListeners.get(key);
   if (listeners) {
-    listeners.forEach(function (listener) {
-      return listener();
-    });
+    listeners.forEach(listener => listener());
   }
 }
 function subscribe(area, key, callback) {
   if (!key) {
-    return function () {};
+    return () => {};
   }
-  var storageHandler = function storageHandler(event) {
+  const storageHandler = event => {
     if (event.storageArea === area && event.key === key) {
       callback();
     }
   };
   window.addEventListener('storage', storageHandler);
   onCurrentTabStorageChange(key, callback);
-  return function () {
+  return () => {
     window.removeEventListener('storage', storageHandler);
     offCurrentTabStorageChange(key, callback);
   };
@@ -57,7 +54,7 @@ function getSnapshot(area, key) {
   }
   try {
     return area.getItem(key);
-  } catch (_unused) {
+  } catch {
     // ignore
     // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API#feature-detecting_localstorage
     return null;
@@ -73,14 +70,14 @@ function setValue(area, key, value) {
     } else {
       area.setItem(key, String(value));
     }
-  } catch (_unused2) {
+  } catch {
     // ignore
     // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API#feature-detecting_localstorage
     return;
   }
   emitCurrentTabStorageChange(key);
 }
-var serverValue = [null, function () {}];
+const serverValue = [null, () => {}];
 function useLocalStorageStateServer() {
   return serverValue;
 }
@@ -93,33 +90,20 @@ function useLocalStorageStateServer() {
  * Since the storage API isn't available in server-rendering environments, we
  * return null during SSR and hydration.
  */
-function useLocalStorageStateBrowser(key) {
-  var initializer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  var _React$useState = React.useState(initializer),
-    _React$useState2 = _slicedToArray(_React$useState, 1),
-    initialValue = _React$useState2[0];
-  var area = window.localStorage;
-  var subscribeKey = React.useCallback(function (callback) {
-    return subscribe(area, key, callback);
-  }, [area, key]);
-  var getKeySnapshot = React.useCallback(function () {
-    var _getSnapshot;
-    return (_getSnapshot = getSnapshot(area, key)) != null ? _getSnapshot : initialValue;
-  }, [area, initialValue, key]);
+function useLocalStorageStateBrowser(key, initializer = null) {
+  const [initialValue] = React.useState(initializer);
+  const area = window.localStorage;
+  const subscribeKey = React.useCallback(callback => subscribe(area, key, callback), [area, key]);
+  const getKeySnapshot = React.useCallback(() => getSnapshot(area, key) ?? initialValue, [area, initialValue, key]);
 
   // Start with null for the hydration, and then switch to the actual value.
-  var getKeyServerSnapshot = function getKeyServerSnapshot() {
-    return null;
-  };
-  var storedValue = React.useSyncExternalStore(subscribeKey, getKeySnapshot, getKeyServerSnapshot);
-  var setStoredValue = React.useCallback(function (value) {
-    var valueToStore = value instanceof Function ? value(storedValue) : value;
+  const getKeyServerSnapshot = () => null;
+  const storedValue = React.useSyncExternalStore(subscribeKey, getKeySnapshot, getKeyServerSnapshot);
+  const setStoredValue = React.useCallback(value => {
+    const valueToStore = value instanceof Function ? value(storedValue) : value;
     setValue(area, key, valueToStore);
   }, [area, key, storedValue]);
-  var _React$useState3 = React.useState(initialValue),
-    _React$useState4 = _slicedToArray(_React$useState3, 2),
-    nonStoredValue = _React$useState4[0],
-    setNonStoredValue = _React$useState4[1];
+  const [nonStoredValue, setNonStoredValue] = React.useState(initialValue);
   if (!key) {
     return [nonStoredValue, setNonStoredValue];
   }

package/esm/usePreference/PreferencesProvider.js

@@ -1,7 +1,7 @@
 'use client';
 
 import * as React from 'react';
-export var PreferencesContext = /*#__PURE__*/React.createContext(undefined);
+export const PreferencesContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") PreferencesContext.displayName = "PreferencesContext";
 export function usePreferences() {
   return React.useContext(PreferencesContext);

package/esm/usePreference/usePreference.js

@@ -1,25 +1,23 @@
 'use client';
 
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import * as React from 'react';
 import useLocalStorageState from "../useLocalStorageState/index.js";
 import { usePreferences } from "./PreferencesProvider.js";
-var variantPrefPrefix = '_docs_variant_pref';
-var transformPref = '_docs_transform_pref';
-export function usePreference(type, name) {
-  var initializer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-  var key = React.useMemo(function () {
+const variantPrefPrefix = '_docs_variant_pref';
+const transformPref = '_docs_transform_pref';
+export function usePreference(type, name, initializer = null) {
+  const key = React.useMemo(() => {
     if (!Array.isArray(name)) {
       return name;
     }
     if (name.length <= 1) {
       return null; // Don't use localStorage for single variants - no choice to remember
     }
-    return _toConsumableArray(name).sort().join(':');
+    return [...name].sort().join(':');
   }, [name]);
-  var preferences = usePreferences();
-  var defaultPrefix = type === 'variant' ? variantPrefPrefix : transformPref;
-  var prefix = preferences != null && preferences.prefix ? "".concat(preferences == null ? void 0 : preferences.prefix, "_").concat(type) : defaultPrefix;
-  var storageKey = key ? "".concat(prefix, ":").concat(key) : null;
+  const preferences = usePreferences();
+  const defaultPrefix = type === 'variant' ? variantPrefPrefix : transformPref;
+  const prefix = preferences?.prefix ? `${preferences?.prefix}_${type}` : defaultPrefix;
+  const storageKey = key ? `${prefix}:${key}` : null;
   return useLocalStorageState(storageKey, initializer);
 }