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

package/build/esm/CodeHighlighter/CodeHighlighterClient.js

@@ -0,0 +1,399 @@
+'use client';
+
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import * as React from 'react';
+import { useCodeContext } from "../CodeProvider/CodeContext.js";
+import { CodeHighlighterContext } from "./CodeHighlighterContext.js";
+import { maybeInitialData } from "./maybeInitialData.js";
+import { loadFallbackCode } from "./loadFallbackCode.js";
+import { hasAllVariants } from "./hasAllVariants.js";
+import { loadVariant } from "./loadVariant.js";
+import { CodeHighlighterFallbackContext } from "./CodeHighlighterFallbackContext.js";
+import { useControlledCode } from "../CodeControllerContext/index.js";
+import { codeToFallbackProps } from "./codeToFallbackProps.js";
+import { parseCode } from "./parseCode.js";
+import { applyTransforms, getAvailableTransforms } from "./transformCode.js";
+import { parseControlledCode } from "./parseControlledCode.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+var DEBUG = false; // Set to true for debugging purposes
+
+function useInitialData(_ref) {
+  var variants = _ref.variants,
+    variantName = _ref.variantName,
+    code = _ref.code,
+    setCode = _ref.setCode,
+    fileName = _ref.fileName,
+    url = _ref.url,
+    highlightAt = _ref.highlightAt,
+    fallbackUsesExtraFiles = _ref.fallbackUsesExtraFiles,
+    fallbackUsesAllVariants = _ref.fallbackUsesAllVariants,
+    isControlled = _ref.isControlled;
+  var _useCodeContext = useCodeContext(),
+    sourceParser = _useCodeContext.sourceParser,
+    loadCodeMeta = _useCodeContext.loadCodeMeta,
+    loadVariantMeta = _useCodeContext.loadVariantMeta,
+    loadSource = _useCodeContext.loadSource;
+  var _React$useMemo = React.useMemo(function () {
+      return maybeInitialData(variants, variantName, code, fileName, highlightAt === 'init', fallbackUsesExtraFiles, fallbackUsesAllVariants);
+    }, [variants, variantName, code, fileName, highlightAt, fallbackUsesExtraFiles, fallbackUsesAllVariants]),
+    initialData = _React$useMemo.initialData,
+    reason = _React$useMemo.reason;
+
+  // TODO: fallbackInitialRenderOnly option? this would mean we can't fetch fallback data on the client side
+  // Load initial data if not provided
+  React.useEffect(function () {
+    if (initialData || isControlled) {
+      return;
+    }
+
+    // TODO: abort controller
+
+    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var loaded;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (DEBUG) {
+              // eslint-disable-next-line no-console
+              console.log('Loading initial data for CodeHighlighterClient: ', reason);
+            }
+            _context.next = 3;
+            return loadFallbackCode(url, variantName, code, highlightAt === 'init', fallbackUsesExtraFiles, fallbackUsesAllVariants, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, fileName, variants)["catch"](function (error) {
+              return {
+                error: error
+              };
+            });
+          case 3:
+            loaded = _context.sent;
+            if ('error' in loaded) {
+              // TODO: handle error
+            } else {
+              setCode(loaded.code);
+            }
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }, [initialData, reason, isControlled, variantName, code, setCode, highlightAt, url, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, fallbackUsesExtraFiles, fallbackUsesAllVariants, fileName, variants]);
+}
+function useAllVariants(_ref3) {
+  var readyForContent = _ref3.readyForContent,
+    variants = _ref3.variants,
+    isControlled = _ref3.isControlled,
+    url = _ref3.url,
+    code = _ref3.code,
+    setCode = _ref3.setCode;
+  var _useCodeContext2 = useCodeContext(),
+    loadCodeMeta = _useCodeContext2.loadCodeMeta,
+    loadVariantMeta = _useCodeContext2.loadVariantMeta,
+    loadSource = _useCodeContext2.loadSource;
+  React.useEffect(function () {
+    if (readyForContent || isControlled) {
+      return;
+    }
+
+    // TODO: abort controller
+
+    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var loadedCode, result, resultCode, errors, _iterator, _step, item;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            loadedCode = code;
+            if (loadedCode) {
+              _context2.next = 7;
+              break;
+            }
+            if (loadCodeMeta) {
+              _context2.next = 4;
+              break;
+            }
+            throw new Error('"loadCodeMeta" function is required when no code is provided');
+          case 4:
+            _context2.next = 6;
+            return loadCodeMeta(url);
+          case 6:
+            loadedCode = _context2.sent;
+          case 7:
+            _context2.next = 9;
+            return Promise.all(variants.map(function (name) {
+              return loadVariant(url, name, loadedCode[name], undefined,
+              // sourceParser - skip parsing
+              loadSource, loadVariantMeta, undefined,
+              // sourceTransformers - skip transforming
+              {
+                disableParsing: true,
+                disableTransforms: true
+              }).then(function (variant) {
+                return {
+                  name: name,
+                  variant: variant
+                };
+              })["catch"](function (error) {
+                return {
+                  error: error
+                };
+              });
+            }));
+          case 9:
+            result = _context2.sent;
+            resultCode = {};
+            errors = [];
+            _iterator = _createForOfIteratorHelper(result);
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                item = _step.value;
+                if ('error' in item) {
+                  errors.push(item.error);
+                } else {
+                  resultCode[item.name] = item.variant.code;
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+            if (errors.length > 0) {
+              // TODO: handle error
+            } else {
+              setCode(resultCode);
+            }
+          case 15:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  }, [readyForContent, isControlled, variants, url, code, setCode, loadSource, loadVariantMeta, loadCodeMeta]);
+  return {
+    readyForContent: readyForContent
+  };
+}
+function useCodeParsing(_ref5) {
+  var code = _ref5.code,
+    readyForContent = _ref5.readyForContent;
+  var _useCodeContext3 = useCodeContext(),
+    parseSource = _useCodeContext3.parseSource;
+
+  // Parse the internal code state when ready
+  var parsedCode = React.useMemo(function () {
+    if (!code || !readyForContent || !parseSource) {
+      return undefined;
+    }
+    return parseCode(code, parseSource);
+  }, [code, readyForContent, parseSource]);
+  return {
+    parsedCode: parsedCode
+  };
+}
+function useCodeTransforms(_ref6) {
+  var parsedCode = _ref6.parsedCode,
+    variantName = _ref6.variantName;
+  var _useCodeContext4 = useCodeContext(),
+    sourceParser = _useCodeContext4.sourceParser;
+  var _React$useState = React.useState(undefined),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    transformedCode = _React$useState2[0],
+    setTransformedCode = _React$useState2[1];
+
+  // Get available transforms from the current variant (separate memo for efficiency)
+  var availableTransforms = React.useMemo(function () {
+    return getAvailableTransforms(parsedCode, variantName);
+  }, [parsedCode, variantName]);
+
+  // Effect to compute transformations for all variants
+  React.useEffect(function () {
+    if (!parsedCode || !sourceParser) {
+      setTransformedCode(parsedCode);
+      return;
+    }
+
+    // Process transformations for all variants
+    _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      var parseSource, enhanced;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return sourceParser;
+          case 3:
+            parseSource = _context3.sent;
+            _context3.next = 6;
+            return applyTransforms(parsedCode, parseSource);
+          case 6:
+            enhanced = _context3.sent;
+            setTransformedCode(enhanced);
+            _context3.next = 14;
+            break;
+          case 10:
+            _context3.prev = 10;
+            _context3.t0 = _context3["catch"](0);
+            console.error('Failed to process transforms:', _context3.t0);
+            setTransformedCode(parsedCode);
+          case 14:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[0, 10]]);
+    }))();
+  }, [parsedCode, sourceParser]);
+  return {
+    transformedCode: transformedCode,
+    availableTransforms: availableTransforms
+  };
+}
+function useControlledCodeParsing(_ref8) {
+  var controlledCode = _ref8.controlledCode;
+  var _useCodeContext5 = useCodeContext(),
+    parseSource = _useCodeContext5.parseSource;
+
+  // Parse the controlled code separately (no need to check readyForContent)
+  var parsedControlledCode = React.useMemo(function () {
+    if (!controlledCode || !parseSource) {
+      return undefined;
+    }
+    return parseControlledCode(controlledCode, parseSource);
+  }, [controlledCode, parseSource]);
+  return {
+    parsedControlledCode: parsedControlledCode
+  };
+}
+export function CodeHighlighterClient(props) {
+  var _activeCode$variantNa, _activeCode$variantNa2;
+  var _useControlledCode = useControlledCode(),
+    controlledCode = _useControlledCode.controlledCode,
+    controlledSelection = _useControlledCode.controlledSelection,
+    controlledSetCode = _useControlledCode.controlledSetCode,
+    controlledSetSelection = _useControlledCode.controlledSetSelection,
+    controlledComponents = _useControlledCode.controlledComponents;
+  var isControlled = Boolean(props.code || controlledCode);
+
+  // TODO: props.code is for controlled components, props.precompute is for precomputed code
+  // props.code should only be highlighted, but no additional fetching should be done
+  // this is the case with live demos where the code can be edited by the user
+  // then maybe props.code shouldn't allow highlighted code, only strings?
+  // this is a code highlighter afterall, why would they want to control the highlighting aspect?
+
+  // TODO: should we empty this state if controlled?
+  var _React$useState3 = React.useState(_typeof(props.precompute) === 'object' ? props.precompute : undefined),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    code = _React$useState4[0],
+    setCode = _React$useState4[1];
+
+  // TODO: if using props.variant, then the variant is controlled and we can't use our own state
+  // does props.variant make any sense instead of controlledSelection?.variant?
+  var _React$useState5 = React.useState({
+      variant: props.initialVariant || props.defaultVariant || 'Default'
+    }),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    selection = _React$useState6[0],
+    setSelection = _React$useState6[1];
+  var variantName = (controlledSelection == null ? void 0 : controlledSelection.variant) || props.variant || selection.variant;
+  var activeCode = controlledCode || props.code || code;
+  var initialFilename = _typeof(activeCode == null ? void 0 : activeCode[variantName]) === 'object' && (activeCode != null && (_activeCode$variantNa = activeCode[variantName]) != null && _activeCode$variantNa.filesOrder ? activeCode[variantName].filesOrder[0] : activeCode == null || (_activeCode$variantNa2 = activeCode[variantName]) == null ? void 0 : _activeCode$variantNa2.fileName);
+  var fileName = (controlledSelection == null ? void 0 : controlledSelection.fileName) || props.fileName || initialFilename || 'index.js';
+  var variants = props.variants || Object.keys(props.components || activeCode || {});
+  var url = props.url,
+    highlightAt = props.highlightAt,
+    fallbackUsesExtraFiles = props.fallbackUsesExtraFiles,
+    fallbackUsesAllVariants = props.fallbackUsesAllVariants;
+  useInitialData({
+    variants: variants,
+    variantName: variantName,
+    code: code,
+    setCode: setCode,
+    fileName: fileName,
+    url: url,
+    highlightAt: highlightAt,
+    fallbackUsesExtraFiles: fallbackUsesExtraFiles,
+    fallbackUsesAllVariants: fallbackUsesAllVariants,
+    isControlled: isControlled
+  });
+  var readyForContent = React.useMemo(function () {
+    if (!code) {
+      return false;
+    }
+    return hasAllVariants(variants, code);
+  }, [code, variants]);
+
+  // Separate check for activeCode to determine when to show fallback
+  var activeCodeReady = React.useMemo(function () {
+    if (!activeCode) {
+      return false;
+    }
+
+    // Controlled code is always ready since it comes from editing already-ready code
+    if (controlledCode) {
+      return true;
+    }
+
+    // For regular code, use the existing hasAllVariants function
+    var regularCode = props.code || code;
+    return regularCode ? hasAllVariants(variants, regularCode) : false;
+  }, [activeCode, controlledCode, variants, props.code, code]);
+  useAllVariants({
+    readyForContent: readyForContent,
+    variants: variants,
+    isControlled: isControlled,
+    url: url,
+    code: code,
+    setCode: setCode
+  });
+  var _useCodeParsing = useCodeParsing({
+      code: props.code || code,
+      readyForContent: readyForContent || Boolean(props.code)
+    }),
+    parsedCode = _useCodeParsing.parsedCode;
+  var _useCodeTransforms = useCodeTransforms({
+      parsedCode: parsedCode,
+      variantName: variantName
+    }),
+    transformedCode = _useCodeTransforms.transformedCode,
+    availableTransforms = _useCodeTransforms.availableTransforms;
+  var _useControlledCodePar = useControlledCodeParsing({
+      controlledCode: controlledCode
+    }),
+    parsedControlledCode = _useControlledCodePar.parsedControlledCode;
+
+  // Determine the final overlaid code (controlled takes precedence)
+  var overlaidCode = parsedControlledCode || transformedCode;
+
+  // For fallback context, use the processed code or fall back to non-controlled code
+  var codeForFallback = overlaidCode || (controlledCode ? undefined : props.code || code);
+  var fallbackContext = React.useMemo(function () {
+    return codeToFallbackProps(variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants);
+  }, [variantName, codeForFallback, fileName, props.fallbackUsesExtraFiles, props.fallbackUsesAllVariants]);
+  var context = React.useMemo(function () {
+    return {
+      code: overlaidCode || transformedCode,
+      // Use processed/transformed code
+      setCode: controlledSetCode,
+      selection: controlledSelection || selection,
+      setSelection: controlledSetSelection || setSelection,
+      components: controlledComponents || props.components,
+      availableTransforms: availableTransforms
+    };
+  }, [overlaidCode, transformedCode, controlledSetCode, selection, controlledSelection, controlledSetSelection, controlledComponents, props.components, availableTransforms]);
+  if (!props.variants && !props.components && !activeCode) {
+    throw new Error('CodeHighlighterClient requires either `variants`, `components`, or `code` to be provided.');
+  }
+  var fallback = props.fallback;
+  if (fallback && !props.skipFallback && !activeCodeReady) {
+    return /*#__PURE__*/_jsx(CodeHighlighterFallbackContext.Provider, {
+      value: fallbackContext,
+      children: fallback
+    });
+  }
+  return /*#__PURE__*/_jsx(CodeHighlighterContext.Provider, {
+    value: context,
+    children: props.children
+  });
+}

package/build/esm/CodeHighlighter/CodeHighlighterContext.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { Code, ControlledCode } from "./types.js";
+import { Selection } from "../CodeControllerContext/index.js";
+export interface CodeHighlighterContextType {
+  code?: Code;
+  setCode?: React.Dispatch<React.SetStateAction<ControlledCode | undefined>>;
+  selection?: Selection;
+  setSelection?: React.Dispatch<React.SetStateAction<Selection>>;
+  components?: Record<string, React.ReactNode>;
+  availableTransforms?: string[];
+}
+export declare const CodeHighlighterContext: React.Context<CodeHighlighterContextType | undefined>;
+export declare function useCodeHighlighterContext(): CodeHighlighterContextType;
+export declare function useCodeHighlighterContextOptional(): CodeHighlighterContextType | undefined;

package/build/esm/CodeHighlighter/CodeHighlighterContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeHighlighterContext.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/CodeHighlighterContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC;IAC3E,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,YAAY,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7C,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,eAAO,MAAM,sBAAsB,uDAElC,CAAC;AAEF,wBAAgB,yBAAyB,+BAQxC;AAED,wBAAgB,iCAAiC,2CAEhD"}

package/build/esm/CodeHighlighter/CodeHighlighterContext.js

@@ -0,0 +1,14 @@
+'use client';
+
+import * as React from 'react';
+export var CodeHighlighterContext = /*#__PURE__*/React.createContext(undefined);
+export function useCodeHighlighterContext() {
+  var context = React.useContext(CodeHighlighterContext);
+  if (context === undefined) {
+    throw new Error('CodeHighlighterContext is missing. `useCodeHighlighterContext` must be used within a `CodeHighlighter` component.');
+  }
+  return context;
+}
+export function useCodeHighlighterContextOptional() {
+  return React.useContext(CodeHighlighterContext);
+}

package/build/esm/CodeHighlighter/CodeHighlighterFallbackContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { ContentLoadingVariant } from "./types.js";
+export interface CodeHighlighterFallbackContext extends ContentLoadingVariant {
+  extraVariants?: Record<string, ContentLoadingVariant>;
+}
+export declare const CodeHighlighterFallbackContext: React.Context<CodeHighlighterFallbackContext | undefined>;
+export declare function useCodeHighlighterFallbackContext(): CodeHighlighterFallbackContext;

package/build/esm/CodeHighlighter/CodeHighlighterFallbackContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeHighlighterFallbackContext.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/CodeHighlighterFallbackContext.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,8BAA+B,SAAQ,qBAAqB;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CACvD;AAED,eAAO,MAAM,8BAA8B,2DAE/B,CAAC;AAEb,wBAAgB,iCAAiC,mCAQhD"}

package/build/esm/CodeHighlighter/CodeHighlighterFallbackContext.js

@@ -0,0 +1,11 @@
+'use client';
+
+import * as React from 'react';
+export var CodeHighlighterFallbackContext = /*#__PURE__*/React.createContext(undefined);
+export function useCodeHighlighterFallbackContext() {
+  var context = React.useContext(CodeHighlighterFallbackContext);
+  if (context === undefined) {
+    throw new Error('CodeHighlighterFallbackContext is missing. `useCodeHighlighterFallbackContext` must be used within a `CodeHighlighter` component.');
+  }
+  return context;
+}

package/build/esm/CodeHighlighter/applyTransform.d.ts

@@ -0,0 +1,19 @@
+import type { VariantSource, Transforms } from "./types.js";
+/**
+ * Applies a specific transform to a variant source and returns the transformed source
+ * @param source - The original variant source (string, HastNodes, or hastJson object)
+ * @param transforms - Object containing all available transforms
+ * @param transformKey - The key of the specific transform to apply
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if the transform key doesn't exist or patching fails
+ */
+export declare function applyTransform(source: VariantSource, transforms: Transforms, transformKey: string): VariantSource;
+/**
+ * Applies multiple transforms to a variant source in sequence
+ * @param source - The original variant source
+ * @param transforms - Object containing all available transforms
+ * @param transformKeys - Array of transform keys to apply in order
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if any transform key doesn't exist or patching fails
+ */
+export declare function applyTransforms(source: VariantSource, transforms: Transforms, transformKeys: string[]): VariantSource;

package/build/esm/CodeHighlighter/applyTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyTransform.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/applyTransform.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,GACnB,aAAa,CA0Cf;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EAAE,GACtB,aAAa,CAQf"}

package/build/esm/CodeHighlighter/applyTransform.js

@@ -0,0 +1,75 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { patch, clone } from 'jsondiffpatch';
+/**
+ * Applies a specific transform to a variant source and returns the transformed source
+ * @param source - The original variant source (string, HastNodes, or hastJson object)
+ * @param transforms - Object containing all available transforms
+ * @param transformKey - The key of the specific transform to apply
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if the transform key doesn't exist or patching fails
+ */
+export function applyTransform(source, transforms, transformKey) {
+  var transform = transforms[transformKey];
+  if (!transform) {
+    throw new Error("Transform \"".concat(transformKey, "\" not found in transforms"));
+  }
+
+  // Determine the format of the source and apply the appropriate transform strategy
+  if (typeof source === 'string') {
+    // For string sources, deltas are typically line-array based (from transformSource)
+    var sourceLines = source.split('\n');
+    var patched = patch(sourceLines, transform.delta);
+    if (!Array.isArray(patched)) {
+      throw new Error("Patch for transform \"".concat(transformKey, "\" did not return an array"));
+    }
+    return patched.join('\n');
+  }
+
+  // For Hast node sources, deltas are typically node-based (from transformParsedSource)
+  var sourceNodes;
+  var isHastJson = 'hastJson' in source;
+  if (isHastJson) {
+    sourceNodes = JSON.parse(source.hastJson);
+  } else {
+    sourceNodes = source;
+  }
+
+  // Apply the node-based delta
+  var patchedNodes = patch(clone(sourceNodes), transform.delta);
+  if (!patchedNodes) {
+    throw new Error("Patch for transform \"".concat(transformKey, "\" returned null/undefined"));
+  }
+
+  // Return in the same format as the input
+  if (isHastJson) {
+    return {
+      hastJson: JSON.stringify(patchedNodes)
+    };
+  }
+  return patchedNodes;
+}
+
+/**
+ * Applies multiple transforms to a variant source in sequence
+ * @param source - The original variant source
+ * @param transforms - Object containing all available transforms
+ * @param transformKeys - Array of transform keys to apply in order
+ * @returns The transformed variant source in the same format as the input
+ * @throws Error if any transform key doesn't exist or patching fails
+ */
+export function applyTransforms(source, transforms, transformKeys) {
+  var currentSource = source;
+  var _iterator = _createForOfIteratorHelper(transformKeys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var transformKey = _step.value;
+      currentSource = applyTransform(currentSource, transforms, transformKey);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return currentSource;
+}

package/build/esm/CodeHighlighter/codeToFallbackProps.d.ts

@@ -0,0 +1,2 @@
+import { Code, ContentLoadingProps } from "./types.js";
+export declare function codeToFallbackProps(variant: string, code?: Code, fileName?: string, needsAllFiles?: boolean, needsAllVariants?: boolean): ContentLoadingProps;

package/build/esm/CodeHighlighter/codeToFallbackProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeToFallbackProps.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/codeToFallbackProps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAsC,MAAM,SAAS,CAAC;AAexF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,IAAI,EACX,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,UAAQ,EACrB,gBAAgB,UAAQ,GACvB,mBAAmB,CAyDrB"}

package/build/esm/CodeHighlighter/codeToFallbackProps.js

@@ -0,0 +1,70 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { stringOrHastToJsx } from "../hast/hast.js";
+function toExtraSource(variantCode, fileName) {
+  return Object.entries(variantCode.extraFiles || {}).reduce(function (acc, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      name = _ref2[0],
+      file = _ref2[1];
+    if (name !== fileName && _typeof(file) === 'object' && file != null && file.source) {
+      acc[name] = stringOrHastToJsx(file.source);
+    }
+    return acc;
+  }, _defineProperty({}, variantCode.fileName, variantCode.source && stringOrHastToJsx(variantCode.source)));
+}
+export function codeToFallbackProps(variant, code, fileName) {
+  var needsAllFiles = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var needsAllVariants = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var variantCode = code == null ? void 0 : code[variant];
+  if (!variantCode || typeof variantCode === 'string') {
+    return {};
+  }
+  var fileNames = [variantCode.fileName].concat(_toConsumableArray(Object.keys(variantCode.extraFiles || {})));
+  var source;
+  if (fileName) {
+    var _variantCode$extraFil;
+    var fileData = (_variantCode$extraFil = variantCode.extraFiles) == null ? void 0 : _variantCode$extraFil[fileName];
+    if (fileData && _typeof(fileData) === 'object' && 'source' in fileData && fileData.source) {
+      source = stringOrHastToJsx(fileData.source);
+    }
+  } else if (variantCode.source) {
+    source = stringOrHastToJsx(variantCode.source);
+  }
+  if (needsAllVariants || needsAllFiles) {
+    var extraSource = toExtraSource(variantCode, fileName);
+    if (needsAllVariants) {
+      var extraVariants = Object.entries(code || {}).reduce(function (acc, _ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          name = _ref4[0],
+          vCode = _ref4[1];
+        if (name !== variant && vCode && typeof vCode !== 'string') {
+          var extraVariantExtraSource = toExtraSource(vCode, vCode.fileName);
+          acc[name] = {
+            fileNames: [vCode.fileName].concat(_toConsumableArray(Object.keys(vCode.extraFiles || {}))),
+            // TODO: use filesOrder if provided
+            source: vCode.source && stringOrHastToJsx(vCode.source),
+            extraSource: extraVariantExtraSource
+          };
+        }
+        return acc;
+      }, {});
+      return {
+        fileNames: fileNames,
+        source: source,
+        extraSource: extraSource,
+        extraVariants: extraVariants
+      };
+    }
+    return {
+      fileNames: fileNames,
+      source: source,
+      extraSource: extraSource
+    };
+  }
+  return {
+    fileNames: fileNames,
+    source: source
+  };
+}

package/build/esm/CodeHighlighter/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/errors.ts"],"names":[],"mappings":""}

package/build/esm/CodeHighlighter/errors.js

@@ -0,0 +1 @@
+// TODO: all known errors should be defined here

package/build/esm/CodeHighlighter/hasAllVariants.d.ts

@@ -0,0 +1,2 @@
+import { Code } from "./types.js";
+export declare function hasAllVariants(variants: string[], code: Code, needsHighlight?: boolean): boolean;

package/build/esm/CodeHighlighter/hasAllVariants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasAllVariants.d.ts","sourceRoot":"","sources":["../../../src/CodeHighlighter/hasAllVariants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiB,MAAM,SAAS,CAAC;AAgB9C,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,EAAE,OAAO,WA6BtF"}