@mui/internal-docs-infra 0.12.1-canary.1 → 0.12.1-canary.3

package/CodeHighlighter/CodeHighlighter.mjs

@@ -107,7 +107,7 @@ export function CodeHighlighter(props) {
 
   // No ContentLoading: render the content/full-load directly, with no loading
   // fallback (the client shows nothing until content is ready). For
-  // `highlightAt: 'init'`, `createClientProps` folds each variant's highlighted-visible
+  // `highlightAfter: 'init'`, `createClientProps` folds each variant's highlighted-visible
   // `fallbackCritical` over its plain `fallback`, so `<Pre>` paints the visible frames
   // highlighted on the first render (no decompression) and decodes the full tree after
   // paint (the `decodeAllowed` latch).

package/CodeHighlighter/CodeHighlighterClient.mjs

@@ -120,7 +120,7 @@ function useInitialData({
       }
 
       // Fold each variant's highlighted-visible `fallbackCritical` over its plain
-      // `fallback` (under `highlightAt: 'init'`) and strip the staging field, so the
+      // `fallback` (under `highlightAfter: 'init'`) and strip the staging field, so the
       // hoisted loading fallback is already highlighted and nothing leaks to the
       // content. `collapseToEmpty` isn't threaded into the client here, so the `false`
       // form is assumed: under collapse-to-empty this may promote a few frames that are
@@ -343,7 +343,7 @@ function useCodeParsing({
   }, [highlightAfter]);
 
   // Highlight instantly once hydrated, as a non-blocking client transition,
-  // rather than deferring to a scheduled task. (`highlightAt: 'idle'` above is
+  // rather than deferring to a scheduled task. (`highlightAfter: 'idle'` above is
   // the mode that deliberately keeps the unhighlighted first paint and swaps in
   // the highlighted tree on a later idle render.)
   React.useEffect(() => {
@@ -421,9 +421,9 @@ function useCodeParsing({
   const waitingForParsedCode = shouldHighlight && !!code && !allVariantsAlreadyHighlighted && !parsedCode;
 
   // Only signal `deferHighlight` while a highlight pass is actively in
-  // flight. When `shouldHighlight` is `false` (e.g. `highlightAt: 'idle'`
-  // before the idle window fires, or `'view'` before the block scrolls
-  // into view) we render the un-highlighted source as-is — downstream
+  // flight. When `shouldHighlight` is `false` (e.g. `highlightAfter: 'idle'`
+  // before the idle window fires) we render the un-highlighted source
+  // as-is — downstream
   // consumers like `useTransformManagement`'s `awaitHighlight` gate must
   // commit eagerly against that source instead of blocking the barrier
   // indefinitely. Once the trigger fires, `shouldHighlight` flips true,
@@ -436,7 +436,7 @@ function useCodeParsing({
   // needs to know whether the published `code` should be rendered as
   // highlighted HAST *now*. That answer is false in two distinct
   // windows that `deferHighlight` deliberately collapses out:
-  //   1. The trigger for `highlightAt: 'hydration' | 'idle' | 'visible'`
+  //   1. The trigger for `highlightAfter: 'hydration' | 'idle'`
   //      hasn't fired yet — `shouldHighlight` is still false. The
   //      precomputed `codeWithGlobals` already contains HAST, so
   //      without a render-side gate `<Pre>` would render highlighted

package/CodeHighlighter/createClientProps.mjs

@@ -13,7 +13,7 @@ export function createClientProps(props) {
   const enhanceAfter = props.enhanceAfter === 'stream' ? 'init' : props.enhanceAfter;
 
   // Resolve the staging `fallbackCritical` on every variant of both carriers before
-  // they cross to the client: under `highlightAt: 'init'` (not `collapseToEmpty`)
+  // they cross to the client: under `highlightAfter: 'init'` (not `collapseToEmpty`)
   // promote it over the plain `fallback` so the first paint is highlighted with no
   // decompression, and always strip it so it never reaches `Content`/`ContentLoading`
   // or bloats the payload. `code` and `precompute` are forwarded separately (the

package/CodeHighlighter/fallbackFormat.d.mts

@@ -79,7 +79,7 @@ export declare function fallbackIsHighlighted(fallback: FallbackNode[]): boolean
  * render (`visibleFrames`). Off-screen frames are omitted — they flatten to exactly
  * {@link buildRootFallback}'s plain output, so storing them would just duplicate
  * `fallback` in the precompute. {@link promoteCriticalFallback} splices these back
- * over the plain fallback for `highlightAt: 'init'` (paint highlighted on the first
+ * over the plain fallback for `highlightAfter: 'init'` (paint highlighted on the first
  * render, zero decompression). Frame indices count `span.frame` children only,
  * matching `getInitialVisibleFrames`.
  *

package/CodeHighlighter/fallbackFormat.mjs

@@ -259,7 +259,7 @@ export function fallbackIsHighlighted(fallback) {
  * render (`visibleFrames`). Off-screen frames are omitted — they flatten to exactly
  * {@link buildRootFallback}'s plain output, so storing them would just duplicate
  * `fallback` in the precompute. {@link promoteCriticalFallback} splices these back
- * over the plain fallback for `highlightAt: 'init'` (paint highlighted on the first
+ * over the plain fallback for `highlightAfter: 'init'` (paint highlighted on the first
  * render, zero decompression). Frame indices count `span.frame` children only,
  * matching `getInitialVisibleFrames`.
  *

package/CodeHighlighter/prepareInitialSource.mjs

@@ -33,7 +33,7 @@ export function prepareInitialSource(props) {
   const initialExpandedEnabled = initialExpanded === true;
 
   // Fold each variant's staging `fallbackCritical` into its plain `fallback` up front
-  // (under `highlightAt: 'init'`, not `collapseToEmpty`), then strip it. The hoisted
+  // (under `highlightAfter: 'init'`, not `collapseToEmpty`), then strip it. The hoisted
   // loading fallback is therefore already highlighted-visible — so the first paint is
   // highlighted with no decompression — while the rest of this function (strip, hoist,
   // window, compress) operates on a single `fallback` field with no awareness of the

package/CodeHighlighter/resolveFallbackCritical.d.mts

@@ -4,7 +4,7 @@ type HighlightAfter = CodeHighlighterBaseProps<{}>['highlightAfter'];
  * Resolve the staging `fallbackCritical` field at a server→client (or client-load)
  * boundary, returning a clone of `code` ready to cross to the client:
  *
- * - **Promote** — under `highlightAt: 'init'` (and not `collapseToEmpty`), each
+ * - **Promote** — under `highlightAfter: 'init'` (and not `collapseToEmpty`), each
  *   variant whose `fallbackCritical` *and* plain `fallback` are both present has the
  *   sparse `fallbackCritical` diff spliced over its `fallback` (`promoteCriticalFallback`)
  *   — the visible frames become highlighted, the rest stay plain — so the first paint is

package/CodeHighlighter/resolveFallbackCritical.mjs

@@ -3,7 +3,7 @@ import { promoteCriticalFallback } from "./fallbackFormat.mjs";
  * Resolve the staging `fallbackCritical` field at a server→client (or client-load)
  * boundary, returning a clone of `code` ready to cross to the client:
  *
- * - **Promote** — under `highlightAt: 'init'` (and not `collapseToEmpty`), each
+ * - **Promote** — under `highlightAfter: 'init'` (and not `collapseToEmpty`), each
  *   variant whose `fallbackCritical` *and* plain `fallback` are both present has the
  *   sparse `fallbackCritical` diff spliced over its `fallback` (`promoteCriticalFallback`)
  *   — the visible frames become highlighted, the rest stay plain — so the first paint is

package/CodeHighlighter/types.d.mts

@@ -170,7 +170,7 @@ export type VariantCode = CodeMeta & {
    * are byte-identical to `fallback`'s plain output, so storing them would just
    * duplicate `fallback` in the precompute. Computed at load time (where the source is
    * still a live `HastRoot`, so no decompression) and carried in precomputed payloads
-   * alongside `fallback`. Under `highlightAt: 'init'` the server/client boundary
+   * alongside `fallback`. Under `highlightAfter: 'init'` the server/client boundary
    * `promoteCriticalFallback`s it over `fallback` so the first paint is highlighted with
    * no client-side decompression, then deletes it: `fallbackCritical` must NEVER reach
    * the `Content`/`ContentLoading` components. The promoted `fallback` has byte-identical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-docs-infra",
-  "version": "0.12.1-canary.1",
+  "version": "0.12.1-canary.3",
   "author": "MUI Team",
   "description": "MUI Infra - internal documentation creation tools.",
   "license": "MIT",
@@ -8,9 +8,16 @@
   "keywords": [
     "react",
     "react-component",
-    "material-ui",
-    "material design",
-    "docs"
+    "docs",
+    "code highlighting",
+    "syntax highlighting",
+    "typescript docs",
+    "live demos",
+    "code editor",
+    "local search",
+    "client-side search",
+    "markdown",
+    "next.js docs"
   ],
   "repository": {
     "type": "git",
@@ -768,5 +775,5 @@
   "bin": {
     "docs-infra": "./cli/index.mjs"
   },
-  "gitSha": "33bc43be2eaf49ec4b4445d8f40efd6fcf27a1e3"
+  "gitSha": "b652e3d89b09d3c556f2b1df043b0dc9cbaf7a88"
 }

package/useCode/Pre.mjs

@@ -244,7 +244,7 @@ export function Pre({
 }) {
   // Defer the decompressing `decodeHastSource` to a post-paint render ONLY when the
   // first-paint `.fallback` is ALREADY highlighted — i.e. the promoted highlighted-visible
-  // fallback the server ships for `highlightAt: 'init'`. Then paint that highlighted
+  // fallback the server ships for `highlightAfter: 'init'`. Then paint that highlighted
   // fallback first (no decompression on the critical path) and swap in the full decoded
   // tree after. When the fallback is plain — every other mode, including a late-mounted
   // `'hydration'` block where `shouldHighlight` is also true on the first render — decode

package/withDocsInfra/withDeploymentConfig.mjs

@@ -228,6 +228,7 @@ export function withDeploymentConfig(nextConfig) {
     typescript: {
       // Motivated by https://github.com/vercel/next.js/issues/7687
       ignoreBuildErrors: true,
+      tsconfigPath: './tsconfig.json',
       ...nextConfig.typescript
     }
   };