@mui/internal-docs-infra 0.2.0-alpha.1 → 0.2.0

package/esm/CodeHighlighter/maybeInitialData.js

@@ -68,7 +68,7 @@ import { hasAllVariants } from "./hasAllVariants.js";
  *   initialKey,
  *   code || props.precompute,
  *   undefined,
- *   highlightAt === 'init',
+ *   highlightAfter === 'init',
  *   props.fallbackUsesExtraFiles,
  *   props.fallbackUsesAllVariants,
  * );
@@ -85,7 +85,7 @@ import { hasAllVariants } from "./hasAllVariants.js";
  *     variantName,
  *     code,
  *     fileName,
- *     highlightAt === 'init',
+ *     highlightAfter === 'init',
  *     fallbackUsesExtraFiles,
  *     fallbackUsesAllVariants,
  *   ), [dependencies]);

package/esm/CodeHighlighter/transformSource.js

@@ -3,10 +3,24 @@ import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { create } from 'jsondiffpatch';
 import { toText } from 'hast-util-to-text';
+import { decompress, strFromU8 } from 'fflate';
+import { decode } from 'uint8-to-base64';
 var differ = create({
   omitRemovedValues: true,
   cloneDiffValues: true
 });
+function decompressAsync(input) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return new Promise(function (resolve, reject) {
+    decompress(input, options, function (err, output) {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(output);
+      }
+    });
+  });
+}
 export function transformSource(_x, _x2, _x3) {
   return _transformSource.apply(this, arguments);
 }
@@ -19,7 +33,7 @@ function _transformSource() {
           _context2.n = 1;
           return Promise.all(sourceTransformers.map(/*#__PURE__*/function () {
             var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
-              var extensions, transformer, sourceString, transformed, splitSource, _t;
+              var extensions, transformer, sourceString, decompressed, transformed, splitSource, _t, _t2;
               return _regenerator().w(function (_context) {
                 while (1) switch (_context.p = _context.n) {
                   case 0:
@@ -33,19 +47,45 @@ function _transformSource() {
                     return _context.a(2, undefined);
                   case 1:
                     _context.p = 1;
-                    if (typeof source === 'string') {
-                      sourceString = source;
-                    } else if ('hastJson' in source) {
-                      sourceString = toText(JSON.parse(source.hastJson));
-                    } else {
-                      sourceString = toText(source);
+                    if (!(typeof source === 'string')) {
+                      _context.n = 2;
+                      break;
                     }
-                    _context.n = 2;
-                    return transformer(sourceString, fileName);
+                    sourceString = source;
+                    _context.n = 6;
+                    break;
                   case 2:
+                    if (!('hastJson' in source)) {
+                      _context.n = 3;
+                      break;
+                    }
+                    sourceString = toText(JSON.parse(source.hastJson));
+                    _context.n = 6;
+                    break;
+                  case 3:
+                    if (!('hastGzip' in source)) {
+                      _context.n = 5;
+                      break;
+                    }
+                    _t = strFromU8;
+                    _context.n = 4;
+                    return decompressAsync(decode(source.hastGzip), {
+                      consume: true
+                    });
+                  case 4:
+                    decompressed = _t(_context.v);
+                    sourceString = toText(JSON.parse(decompressed));
+                    _context.n = 6;
+                    break;
+                  case 5:
+                    sourceString = toText(source);
+                  case 6:
+                    _context.n = 7;
+                    return transformer(sourceString, fileName);
+                  case 7:
                     transformed = _context.v;
                     if (!transformed) {
-                      _context.n = 3;
+                      _context.n = 8;
                       break;
                     }
                     splitSource = sourceString.split('\n');
@@ -57,16 +97,16 @@ function _transformSource() {
                       };
                       return acc;
                     }, {}));
-                  case 3:
+                  case 8:
                     return _context.a(2, undefined);
-                  case 4:
-                    _context.p = 4;
-                    _t = _context.v;
-                    throw new Error("Failed to transform source code (file: ".concat(fileName, "): ").concat(_t instanceof Error && _t.message));
-                  case 5:
+                  case 9:
+                    _context.p = 9;
+                    _t2 = _context.v;
+                    throw new Error("Failed to transform source code (file: ".concat(fileName, "): ").concat(_t2 instanceof Error && _t2.message));
+                  case 10:
                     return _context.a(2);
                 }
-              }, _callee, null, [[1, 4]]);
+              }, _callee, null, [[1, 9]]);
             }));
             return function (_x4) {
               return _ref2.apply(this, arguments);

package/esm/CodeHighlighter/types.d.ts

@@ -26,6 +26,8 @@ export interface HastRoot extends Root {
 }
 export type VariantSource = string | HastRoot | {
   hastJson: string;
+} | {
+  hastGzip: string;
 };
 /**
  * Additional files associated with a code variant.
@@ -141,6 +143,10 @@ export interface LoadFileOptions {
   loadedFiles?: Set<string>;
   /** Side effects code to inject into extraFiles */
   globalsCode?: Array<VariantCode | string>;
+  /** Output format for the loaded file
+   * @default 'hast'
+   */
+  output?: 'hast' | 'hastJson' | 'hastGzip';
 }
 /**
  * Options for the loadVariant function, extending LoadFileOptions with required function dependencies
@@ -207,11 +213,21 @@ export interface CodeLoadingProps {
   children?: string;
   /**
    * When to perform syntax highlighting and code processing
-   * @default 'stream'
+   * @default 'idle'
+   */
+  highlightAfter?: 'init' | 'stream' | 'hydration' | 'idle';
+  /**
+   * When to enhance the code display with interactivity
+   * @default 'idle'
    */
-  highlightAt?: 'init' | 'stream' | 'hydration' | 'idle';
+  enhanceAfter?: 'init' | 'stream' | 'hydration' | 'idle';
   /** Force client-side rendering even when server rendering is available */
   forceClient?: boolean;
+  /** Defer parsing and populating the AST into memory until the code is enhanced
+   * Applies only in production when RSC loading
+   * @default 'gzip'
+   */
+  deferParsing?: 'none' | 'json' | 'gzip';
 }
 /**
  * Function props for loading and transforming code
@@ -262,7 +278,8 @@ export interface CodeHighlighterClientProps extends CodeIdentityProps, CodeConte
    * When to perform syntax highlighting for performance optimization
    * @default 'hydration'
    */
-  highlightAt?: 'init' | 'hydration' | 'idle';
+  highlightAfter?: 'init' | 'hydration' | 'idle';
+  enhanceAfter?: 'init' | 'hydration' | 'idle';
 }
 /**
  * Main props for the CodeHighlighter component.

package/esm/abstractCreateDemo/abstractCreateDemo.d.ts

@@ -7,7 +7,8 @@ type CreateDemoMeta = {
   displayName?: string;
   variantType?: string;
   skipPrecompute?: boolean;
-  highlightAt?: CodeHighlighterProps<{}>['highlightAt'];
+  highlightAfter?: CodeHighlighterProps<{}>['highlightAfter'];
+  enhanceAfter?: CodeHighlighterProps<{}>['enhanceAfter'];
   precompute?: Code;
   ClientProvider?: React.ComponentType<{
     children: React.ReactNode;
@@ -23,7 +24,8 @@ type AbstractCreateDemoOptions<T extends {}> = {
   controlled?: boolean;
   demoGlobalData?: DemoGlobalData[];
   variantTypes?: Record<string, string>;
-  highlightAt?: CodeHighlighterProps<{}>['highlightAt'];
+  highlightAfter?: CodeHighlighterProps<{}>['highlightAfter'];
+  enhanceAfter?: CodeHighlighterProps<{}>['enhanceAfter'];
   fallbackUsesExtraFiles?: boolean;
   fallbackUsesAllVariants?: boolean;
   loadCodeMeta?: LoadCodeMeta;

package/esm/abstractCreateDemo/abstractCreateDemo.js

@@ -35,7 +35,8 @@ export function abstractCreateDemo(options, url, variants, meta) {
       loadVariantMeta: options.loadVariantMeta,
       loadSource: options.loadSource,
       sourceParser: options.sourceParser,
-      highlightAt: (meta == null ? void 0 : meta.highlightAt) || options.highlightAt,
+      highlightAfter: (meta == null ? void 0 : meta.highlightAfter) || options.highlightAfter,
+      enhanceAfter: (meta == null ? void 0 : meta.enhanceAfter) || options.enhanceAfter,
       controlled: options.controlled,
       fallbackUsesExtraFiles: options.fallbackUsesExtraFiles,
       fallbackUsesAllVariants: options.fallbackUsesAllVariants

package/esm/pipeline/hastUtils/hastUtils.d.ts

@@ -2,10 +2,16 @@ import type { Nodes as HastNodes } from 'hast';
 export declare function hastToJsx(hast: HastNodes): React.ReactNode;
 export declare function hastOrJsonToJsx(hastOrJson: HastNodes | {
   hastJson: string;
+} | {
+  hastGzip: string;
 }): React.ReactNode;
 export declare function stringOrHastToString(source: string | HastNodes | {
   hastJson: string;
+} | {
+  hastGzip: string;
 }): string;
 export declare function stringOrHastToJsx(source: string | HastNodes | {
   hastJson: string;
+} | {
+  hastGzip: string;
 }, highlighted?: boolean): React.ReactNode;

package/esm/pipeline/hastUtils/hastUtils.js

@@ -2,6 +2,8 @@ import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { Fragment, jsx, jsxs } from 'react/jsx-runtime';
 import { toText } from 'hast-util-to-text';
 import { toJsxRuntime } from 'hast-util-to-jsx-runtime';
+import { decompressSync, strFromU8 } from 'fflate';
+import { decode } from 'uint8-to-base64';
 export function hastToJsx(hast) {
   return toJsxRuntime(hast, {
     Fragment: Fragment,
@@ -17,6 +19,12 @@ export function hastOrJsonToJsx(hastOrJson) {
     } catch (error) {
       throw new Error("Failed to parse hastJson: ".concat(JSON.stringify(error)));
     }
+  } else if ('hastGzip' in hastOrJson) {
+    try {
+      hast = JSON.parse(strFromU8(decompressSync(decode(hastOrJson.hastGzip))));
+    } catch (error) {
+      throw new Error("Failed to parse hastGzip: ".concat(JSON.stringify(error)));
+    }
   } else {
     hast = hastOrJson;
   }
@@ -37,6 +45,12 @@ export function stringOrHastToString(source) {
     } catch (error) {
       throw new Error("Failed to parse hastJson: ".concat(JSON.stringify(error)));
     }
+  } else if ('hastGzip' in source) {
+    try {
+      hast = JSON.parse(strFromU8(decompressSync(decode(source.hastGzip))));
+    } catch (error) {
+      throw new Error("Failed to parse hastGzip: ".concat(JSON.stringify(error)));
+    }
   } else {
     hast = source;
   }
@@ -55,6 +69,12 @@ export function stringOrHastToJsx(source, highlighted) {
     } catch (error) {
       throw new Error("Failed to parse hastJson: ".concat(JSON.stringify(error)));
     }
+  } else if ('hastGzip' in source) {
+    try {
+      hast = JSON.parse(strFromU8(decompressSync(decode(source.hastGzip))));
+    } catch (error) {
+      throw new Error("Failed to parse hastGzip: ".concat(JSON.stringify(error)));
+    }
   } else {
     hast = source;
   }

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.d.ts

@@ -1,5 +1,7 @@
 import type { LoaderContext } from 'webpack';
-export type LoaderOptions = {};
+export type LoaderOptions = {
+  output?: 'hast' | 'hastJson' | 'hastGzip';
+};
 /**
  * Webpack loader that processes demo files and precomputes variant data.
  *

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -109,7 +109,8 @@ function _loadPrecomputedCodeHighlighter() {
                       loadVariantMeta: undefined,
                       sourceTransformers: sourceTransformers,
                       // For TypeScript to JavaScript conversion
-                      maxDepth: 5
+                      maxDepth: 5,
+                      output: _this.getOptions().output || 'hastGzip'
                     });
                   case 3:
                     _yield$loadVariant = _context.v;

package/esm/pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.d.ts

@@ -1,4 +1,4 @@
-import { type ParseImportsResult } from "../loaderUtils/index.js";
+import { type ImportsAndComments } from "../loaderUtils/index.js";
 import { type SplitArguments } from "./parseFunctionArguments.js";
 import type { Externals } from "../../CodeHighlighter/types.js";
 /**
@@ -29,16 +29,18 @@ export interface ParsedCreateFactory {
   structuredUrl: string;
   structuredVariants: string | SplitArguments | Record<string, string> | undefined;
   structuredOptions?: Record<string, any>;
+  hasGenerics: boolean;
+  structuredGenerics?: Record<string, any>;
   remaining?: string;
-  parseImportsResult?: ParseImportsResult;
+  importsAndComments?: ImportsAndComments;
 }
 /**
  * Parses a file to extract a single create* factory call and its variants and options
  * Returns the parsed result with remaining content included
  * Returns null if no create* call is found
  */
-export declare function parseCreateFactoryCall(code: string, filePath: string, parseOptions?: ParseOptions, parseImportsResult?: ParseImportsResult): Promise<(ParsedCreateFactory & {
-  parseImportsResult?: ParseImportsResult;
+export declare function parseCreateFactoryCall(code: string, filePath: string, parseOptions?: ParseOptions, importsAndComments?: ImportsAndComments): Promise<(ParsedCreateFactory & {
+  importsAndComments?: ImportsAndComments;
 }) | null>;
 /**
  * Parses all create* factory calls in a file sequentially