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

package/esm/CodeHighlighter/parseControlledCode.js

@@ -1,24 +1,19 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 /**
  * Pure function to parse controlled code and convert it to regular Code format.
  * Handles the conversion from ControlledCode (string|null sources) to Code (HAST nodes).
  */
 export function parseControlledCode(controlledCode, parseSource) {
-  var parsed = {};
-  for (var _i = 0, _Object$entries = Object.entries(controlledCode); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      variant = _Object$entries$_i[0],
-      variantCode = _Object$entries$_i[1];
+  const parsed = {};
+  for (const [variant, variantCode] of Object.entries(controlledCode)) {
     if (variantCode === null) {
       // Explicitly deleted - skip this variant
       continue;
     }
-    if (variantCode && _typeof(variantCode) === 'object') {
-      var mainSource = void 0;
+    if (variantCode && typeof variantCode === 'object') {
+      let mainSource;
 
       // Convert null to empty string, then parse
-      var sourceToProcess = variantCode.source === null ? '' : variantCode.source;
+      const sourceToProcess = variantCode.source === null ? '' : variantCode.source;
       if (typeof sourceToProcess === 'string' && variantCode.fileName) {
         try {
           mainSource = parseSource(sourceToProcess, variantCode.fileName);
@@ -29,7 +24,7 @@ export function parseControlledCode(controlledCode, parseSource) {
       } else if (typeof sourceToProcess === 'string' && !variantCode.fileName) {
         // Return a basic HAST root node with the source text for unsupported file types
         // This indicates that the source has at least passed through the parsing pipeline
-        var source = {
+        const source = {
           type: 'root',
           children: [{
             type: 'text',
@@ -43,19 +38,16 @@ export function parseControlledCode(controlledCode, parseSource) {
       }
 
       // Parse extraFiles if present
-      var extraFiles = void 0;
+      let extraFiles;
       if (variantCode.extraFiles) {
-        var parsedExtraFiles = {};
-        for (var _i2 = 0, _Object$entries2 = Object.entries(variantCode.extraFiles); _i2 < _Object$entries2.length; _i2++) {
-          var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-            fileName = _Object$entries2$_i[0],
-            fileData = _Object$entries2$_i[1];
+        const parsedExtraFiles = {};
+        for (const [fileName, fileData] of Object.entries(variantCode.extraFiles)) {
           // Convert null to empty string, then parse
-          var fileSourceToProcess = fileData.source === null ? '' : fileData.source;
+          const fileSourceToProcess = fileData.source === null ? '' : fileData.source;
           if (typeof fileSourceToProcess === 'string') {
             // Parse string sources
             try {
-              var parsedSource = parseSource(fileSourceToProcess, fileName);
+              const parsedSource = parseSource(fileSourceToProcess, fileName);
               parsedExtraFiles[fileName] = {
                 source: parsedSource
               };
@@ -78,7 +70,7 @@ export function parseControlledCode(controlledCode, parseSource) {
         fileName: variantCode.fileName,
         url: variantCode.url,
         source: mainSource,
-        extraFiles: extraFiles,
+        extraFiles,
         filesOrder: variantCode.filesOrder
       };
     }

package/esm/CodeProvider/CodeContext.js

@@ -4,9 +4,9 @@ import * as React from 'react';
 
 // Type definitions for the heavy functions we're moving to context
 
-export var CodeContext = /*#__PURE__*/React.createContext({});
+export const CodeContext = /*#__PURE__*/React.createContext({});
 if (process.env.NODE_ENV !== "production") CodeContext.displayName = "CodeContext";
-export var useCodeContext = function useCodeContext() {
-  var context = React.useContext(CodeContext);
+export const useCodeContext = () => {
+  const context = React.useContext(CodeContext);
   return context;
 };

package/esm/CodeProvider/CodeProvider.js

@@ -1,6 +1,5 @@
 'use client';
 
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import * as React from 'react';
 import { createStarryNight } from '@wooorm/starry-night';
 import { CodeContext } from "./CodeContext.js";
@@ -13,25 +12,23 @@ import { parseCode } from "../pipeline/loadCodeVariant/parseCode.js";
 import { parseControlledCode } from "../CodeHighlighter/parseControlledCode.js";
 import { computeHastDeltas, getAvailableTransforms } from "../pipeline/loadCodeVariant/computeHastDeltas.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-export function CodeProvider(_ref) {
-  var children = _ref.children,
-    loadCodeMeta = _ref.loadCodeMeta,
-    loadVariantMeta = _ref.loadVariantMeta,
-    loadSource = _ref.loadSource;
-  var _React$useState = React.useState(undefined),
-    _React$useState2 = _slicedToArray(_React$useState, 2),
-    parseSource = _React$useState2[0],
-    setParseSource = _React$useState2[1];
-  var sourceParser = React.useMemo(function () {
+export function CodeProvider({
+  children,
+  loadCodeMeta,
+  loadVariantMeta,
+  loadSource
+}) {
+  const [parseSource, setParseSource] = React.useState(undefined);
+  const sourceParser = React.useMemo(() => {
     // Only initialize Starry Night in the browser, not during SSR
     if (typeof window === 'undefined') {
-      return Promise.resolve(function () {
+      return Promise.resolve(() => {
         throw new Error('parseSource not available during SSR');
       });
     }
-    return createStarryNight(grammars).then(function (starryNight) {
-      var parseSourceFn = function parseSourceFn(source, fileName) {
-        var fileType = fileName.slice(fileName.lastIndexOf('.'));
+    return createStarryNight(grammars).then(starryNight => {
+      const parseSourceFn = (source, fileName) => {
+        const fileType = fileName.slice(fileName.lastIndexOf('.'));
         if (!extensionMap[fileType]) {
           // Return a basic HAST root node with the source text for unsupported file types
           return {
@@ -42,8 +39,8 @@ export function CodeProvider(_ref) {
             }]
           };
         }
-        var highlighted = starryNight.highlight(source, extensionMap[fileType]);
-        var sourceLines = source.split(/\r?\n|\r/);
+        const highlighted = starryNight.highlight(source, extensionMap[fileType]);
+        const sourceLines = source.split(/\r?\n|\r/);
         starryNightGutter(highlighted, sourceLines); // mutates the tree to add line gutters
 
         return highlighted;
@@ -51,31 +48,25 @@ export function CodeProvider(_ref) {
       return parseSourceFn;
     });
   }, []);
-  React.useEffect(function () {
+  React.useEffect(() => {
     // Update the sync version when available
-    sourceParser.then(function (parseSourceFn) {
-      return setParseSource(function () {
-        return parseSourceFn;
-      });
-    });
+    sourceParser.then(parseSourceFn => setParseSource(() => parseSourceFn));
   }, [sourceParser]);
-  var context = React.useMemo(function () {
-    return {
-      sourceParser: sourceParser,
-      parseSource: parseSource,
-      // Sync version when available
-      loadSource: loadSource,
-      loadVariantMeta: loadVariantMeta,
-      loadCodeMeta: loadCodeMeta,
-      // Provide the heavy functions
-      loadCodeFallback: loadCodeFallback,
-      loadCodeVariant: loadCodeVariant,
-      parseCode: parseCode,
-      parseControlledCode: parseControlledCode,
-      computeHastDeltas: computeHastDeltas,
-      getAvailableTransforms: getAvailableTransforms
-    };
-  }, [sourceParser, parseSource, loadSource, loadVariantMeta, loadCodeMeta]);
+  const context = React.useMemo(() => ({
+    sourceParser,
+    parseSource,
+    // Sync version when available
+    loadSource,
+    loadVariantMeta,
+    loadCodeMeta,
+    // Provide the heavy functions
+    loadCodeFallback,
+    loadCodeVariant,
+    parseCode,
+    parseControlledCode,
+    computeHastDeltas,
+    getAvailableTransforms
+  }), [sourceParser, parseSource, loadSource, loadVariantMeta, loadCodeMeta]);
   return /*#__PURE__*/_jsx(CodeContext.Provider, {
     value: context,
     children: children

package/esm/abstractCreateDemo/abstractCreateDemo.js

@@ -1,30 +1,26 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import * as React from 'react';
 import { CodeHighlighter } from "../CodeHighlighter/index.js";
 import { createDemoDataWithVariants } from "../createDemoData/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 export function abstractCreateDemo(options, url, variants, meta) {
-  var demoData = createDemoDataWithVariants(url, variants, meta);
-  var variantType = options.variantTypes && options.variantTypes[Object.keys(variants).sort().join(':')];
-  var globalCode = [];
+  const demoData = createDemoDataWithVariants(url, variants, meta);
+  const variantType = options.variantTypes && options.variantTypes[Object.keys(variants).sort().join(':')];
+  const globalCode = [];
   if (options.demoGlobalData) {
-    options.demoGlobalData.forEach(function (data) {
+    options.demoGlobalData.forEach(data => {
       globalCode.push(data.precompute || data.url);
     });
   }
   function DemoComponent(props) {
-    var renderedComponents = Object.entries(demoData.components).reduce(function (acc, _ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        key = _ref2[0],
-        Component = _ref2[1];
+    const renderedComponents = Object.entries(demoData.components).reduce((acc, [key, Component]) => {
       acc[key] = /*#__PURE__*/React.createElement(Component);
       return acc;
     }, {});
-    var highlighter = /*#__PURE__*/_jsx(CodeHighlighter, {
+    const highlighter = /*#__PURE__*/_jsx(CodeHighlighter, {
       url: demoData.url,
       name: demoData.name,
       slug: demoData.slug,
-      variantType: (meta == null ? void 0 : meta.variantType) || variantType,
+      variantType: meta?.variantType || variantType,
       precompute: demoData.precompute,
       globalsCode: globalCode,
       components: renderedComponents,
@@ -35,15 +31,15 @@ export function abstractCreateDemo(options, url, variants, meta) {
       loadVariantMeta: options.loadVariantMeta,
       loadSource: options.loadSource,
       sourceParser: options.sourceParser,
-      highlightAfter: (meta == null ? void 0 : meta.highlightAfter) || options.highlightAfter,
-      enhanceAfter: (meta == null ? void 0 : meta.enhanceAfter) || options.enhanceAfter,
+      highlightAfter: meta?.highlightAfter || options.highlightAfter,
+      enhanceAfter: meta?.enhanceAfter || options.enhanceAfter,
       controlled: options.controlled,
       fallbackUsesExtraFiles: options.fallbackUsesExtraFiles,
       fallbackUsesAllVariants: options.fallbackUsesAllVariants
     });
 
     // Use client provider if available
-    var ClientProvider = meta == null ? void 0 : meta.ClientProvider;
+    const ClientProvider = meta?.ClientProvider;
     if (ClientProvider) {
       return /*#__PURE__*/_jsx(ClientProvider, {
         children: highlighter
@@ -66,7 +62,7 @@ export function abstractCreateDemo(options, url, variants, meta) {
   DemoComponent.Title = Title;
   if (process.env.NODE_ENV !== 'production') {
     DemoComponent.displayName = demoData.displayName;
-    DemoComponent.Title.displayName = "".concat(demoData.displayName, "Title");
+    DemoComponent.Title.displayName = `${demoData.displayName}Title`;
   }
   return DemoComponent;
 }
@@ -77,7 +73,7 @@ export function createDemoFactory(options) {
    * @param component The component to be rendered in the demo.
    * @param meta Additional meta for the demo.
    */
-  var createDemo = function createDemo(url, component, meta) {
+  const createDemo = (url, component, meta) => {
     return abstractCreateDemo(options, url, {
       Default: component
     },
@@ -94,7 +90,7 @@ export function createDemoWithVariantsFactory(options) {
    * @param variants The variants of the component to be rendered in the demo.
    * @param meta Additional meta for the demo.
    */
-  var createDemoWithVariants = function createDemoWithVariants(url, variants, meta) {
+  const createDemoWithVariants = (url, variants, meta) => {
     return abstractCreateDemo(options, url, variants, meta);
   };
   return createDemoWithVariants;

package/esm/abstractCreateDemoClient/abstractCreateDemoClient.js

@@ -9,16 +9,16 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * @returns A function that creates demo client providers
  */
 export function abstractCreateDemoClient(options, url, meta) {
-  var _meta$precompute;
   // Extract externals from precomputed data
-  var externals = (meta == null || (_meta$precompute = meta.precompute) == null ? void 0 : _meta$precompute.externals) || {};
-  var context = {
-    externals: externals
+  const externals = meta?.precompute?.externals || {};
+  const context = {
+    externals
   };
 
   // Create a provider component that makes externals available to children
-  function ClientProvider(_ref) {
-    var children = _ref.children;
+  function ClientProvider({
+    children
+  }) {
     // In a real implementation, this would provide the externals via context
     // For now, just render children - the externals are already injected as imports
     return /*#__PURE__*/_jsx(CodeExternalsContext.Provider, {
@@ -27,15 +27,15 @@ export function abstractCreateDemoClient(options, url, meta) {
     });
   }
   if (process.env.NODE_ENV !== 'production') {
-    ClientProvider.displayName = "ClientProvider(".concat((meta == null ? void 0 : meta.name) || 'Demo', ")");
+    ClientProvider.displayName = `ClientProvider(${meta?.name || 'Demo'})`;
   }
 
   // Attach metadata to the provider for debugging/inspection
   ClientProvider.clientMeta = {
-    url: url,
-    options: options,
-    meta: meta,
-    externals: externals
+    url,
+    options,
+    meta,
+    externals
   };
   return ClientProvider;
 }
@@ -45,7 +45,7 @@ export function createDemoClientFactory(options) {
    * @param url Depends on `import.meta.url` to determine the source file location.
    * @param meta Additional meta and configuration for the demo client.
    */
-  var createDemoClient = function createDemoClient(url, meta) {
+  const createDemoClient = (url, meta) => {
     return abstractCreateDemoClient(options, url, meta);
   };
   return createDemoClient;

package/esm/cli/index.js

@@ -2,5 +2,5 @@ import { createRequire } from 'node:module';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import runValidate from "./runValidate.js";
-var pkgJson = createRequire(import.meta.url)('../../package.json');
+const pkgJson = createRequire(import.meta.url)('../../package.json');
 yargs().scriptName('docs-infra').usage('$0 <command> [args]').command(runValidate).demandCommand(1, 'You need at least one command before moving on').strict().help().version(pkgJson.version).parse(hideBin(process.argv));