@mui/internal-docs-infra 0.2.3-canary.9 → 0.3.1-canary.1

package/esm/cli/runValidate.js

@@ -0,0 +1,297 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import { readdir, readFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMdx from 'remark-mdx';
+import { nameMark, performanceMeasure } from "../pipeline/loadPrecomputedCodeHighlighter/performanceLogger.js";
+import { transformMarkdownMetadata } from "../pipeline/transformMarkdownMetadata/transformMarkdownMetadata.js";
+var completeMessage = function completeMessage(message) {
+  return "\u2713 ".concat(chalk.green(message));
+};
+var functionName = 'Run Validate';
+
+/**
+ * Recursively find all files matching a specific name in a directory
+ */
+function findFiles(_x, _x2) {
+  return _findFiles.apply(this, arguments);
+}
+function _findFiles() {
+  _findFiles = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(dir, fileName) {
+    var results, entries, _t3;
+    return _regenerator().w(function (_context5) {
+      while (1) switch (_context5.p = _context5.n) {
+        case 0:
+          results = [];
+          _context5.p = 1;
+          _context5.n = 2;
+          return readdir(dir, {
+            withFileTypes: true
+          });
+        case 2:
+          entries = _context5.v;
+          _context5.n = 3;
+          return Promise.all(entries.map(/*#__PURE__*/function () {
+            var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(entry) {
+              var fullPath, subResults;
+              return _regenerator().w(function (_context4) {
+                while (1) switch (_context4.n) {
+                  case 0:
+                    fullPath = path.join(dir, entry.name);
+                    if (!entry.isDirectory()) {
+                      _context4.n = 2;
+                      break;
+                    }
+                    _context4.n = 1;
+                    return findFiles(fullPath, fileName);
+                  case 1:
+                    subResults = _context4.v;
+                    results.push.apply(results, _toConsumableArray(subResults));
+                    _context4.n = 3;
+                    break;
+                  case 2:
+                    if (entry.isFile() && entry.name === fileName) {
+                      results.push(fullPath);
+                    }
+                  case 3:
+                    return _context4.a(2);
+                }
+              }, _callee4);
+            }));
+            return function (_x5) {
+              return _ref3.apply(this, arguments);
+            };
+          }()));
+        case 3:
+          _context5.n = 5;
+          break;
+        case 4:
+          _context5.p = 4;
+          _t3 = _context5.v;
+          if (!(_t3.code !== 'ENOENT')) {
+            _context5.n = 5;
+            break;
+          }
+          throw _t3;
+        case 5:
+          return _context5.a(2, results);
+      }
+    }, _callee5, null, [[1, 4]]);
+  }));
+  return _findFiles.apply(this, arguments);
+}
+var runValidate = {
+  command: 'validate [paths...]',
+  describe: 'Ensures that committed files match expected output',
+  builder: function builder(yargs) {
+    return yargs.option('command', {
+      type: 'string',
+      description: 'Command to suggest when indexes are out of date',
+      "default": 'pnpm docs-infra validate'
+    }).option('useVisibleDescription', {
+      type: 'boolean',
+      description: 'Use the first visible paragraph as description in extracted index instead of meta tag',
+      "default": false
+    }).positional('paths', {
+      type: 'string',
+      array: true,
+      description: 'Optional paths to validate (e.g., docs-infra/components docs-infra/functions)',
+      "default": []
+    });
+  },
+  handler: function () {
+    var _handler = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(args) {
+      var cwd, _args$paths, paths, _args$command, command, _args$useVisibleDescr, useVisibleDescription, ci;
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.n) {
+          case 0:
+            cwd = process.cwd();
+            _args$paths = args.paths, paths = _args$paths === void 0 ? [] : _args$paths, _args$command = args.command, command = _args$command === void 0 ? 'pnpm docs-infra validate' : _args$command, _args$useVisibleDescr = args.useVisibleDescription, useVisibleDescription = _args$useVisibleDescr === void 0 ? false : _args$useVisibleDescr;
+            ci = Boolean(process.env.CI);
+            _context3.n = 1;
+            return Promise.all([_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+              var startMark, currentMark, markerDir, markerDirPath, searchDirs, pageMdxFilesPerDir, pageMdxFiles, hasSrcAppFiles, hasAppFiles, includePatterns, processor, hasErrors, updatedIndexes, generatedFiles, pathsArg, updatedPaths, _t2;
+              return _regenerator().w(function (_context2) {
+                while (1) switch (_context2.p = _context2.n) {
+                  case 0:
+                    console.log(chalk.cyan('Validating committed files match expected output...'));
+                    startMark = nameMark(functionName, 'Start Validation', []);
+                    currentMark = startMark;
+                    performance.mark(currentMark);
+                    markerDir = '.next/cache/docs-infra/index-updates';
+                    markerDirPath = path.join(cwd, markerDir); // Remove the marker directory if it exists
+                    _context2.p = 1;
+                    _context2.n = 2;
+                    return rm(markerDirPath, {
+                      recursive: true,
+                      force: true
+                    });
+                  case 2:
+                    _context2.n = 4;
+                    break;
+                  case 3:
+                    _context2.p = 3;
+                    _t2 = _context2.v;
+                  case 4:
+                    if (paths.length > 0) {
+                      // If paths are provided, search in those specific paths
+                      searchDirs = paths.flatMap(function (p) {
+                        return [path.join(cwd, 'src/app', p), path.join(cwd, 'app', p)];
+                      });
+                    } else {
+                      // Otherwise search all app directories
+                      searchDirs = [path.join(cwd, 'src/app'), path.join(cwd, 'app')];
+                    }
+                    _context2.n = 5;
+                    return Promise.all(searchDirs.map(function (dir) {
+                      return findFiles(dir, 'page.mdx');
+                    }));
+                  case 5:
+                    pageMdxFilesPerDir = _context2.v;
+                    pageMdxFiles = pageMdxFilesPerDir.flat();
+                    console.log(chalk.yellow("\nProcessing ".concat(pageMdxFiles.length, " page.mdx files...\n")));
+
+                    // Process each file through the unified pipeline
+                    // Auto-detect include paths based on which directories actually contain files
+                    hasSrcAppFiles = pageMdxFilesPerDir.slice(0, Math.ceil(searchDirs.length / 2)) // First half are src/app paths
+                    .some(function (files) {
+                      return files.length > 0;
+                    });
+                    hasAppFiles = pageMdxFilesPerDir.slice(Math.ceil(searchDirs.length / 2)) // Second half are app paths
+                    .some(function (files) {
+                      return files.length > 0;
+                    });
+                    includePatterns = [];
+                    if (hasSrcAppFiles) {
+                      includePatterns.push('src/app');
+                    }
+                    if (hasAppFiles) {
+                      includePatterns.push('app');
+                    }
+                    // Fallback to 'app' if neither has files (shouldn't happen but be safe)
+                    if (includePatterns.length === 0) {
+                      includePatterns.push('app');
+                    }
+                    processor = unified().use(remarkParse).use(remarkMdx).use(transformMarkdownMetadata, {
+                      extractToIndex: {
+                        include: includePatterns,
+                        exclude: [],
+                        baseDir: cwd,
+                        onlyUpdateIndexes: true,
+                        markerDir: markerDir,
+                        useVisibleDescription: useVisibleDescription
+                      }
+                    });
+                    hasErrors = false;
+                    _context2.n = 6;
+                    return Promise.all(pageMdxFiles.map(/*#__PURE__*/function () {
+                      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(filePath) {
+                        var content, vfile, _t;
+                        return _regenerator().w(function (_context) {
+                          while (1) switch (_context.p = _context.n) {
+                            case 0:
+                              _context.p = 0;
+                              _context.n = 1;
+                              return readFile(filePath, 'utf-8');
+                            case 1:
+                              content = _context.v;
+                              vfile = {
+                                path: filePath,
+                                value: content
+                              }; // Use run() instead of process() since we don't need HTML output
+                              _context.n = 2;
+                              return processor.run(processor.parse(vfile), vfile);
+                            case 2:
+                              _context.n = 4;
+                              break;
+                            case 3:
+                              _context.p = 3;
+                              _t = _context.v;
+                              hasErrors = true;
+                              console.error(chalk.red("Error processing ".concat(filePath, ":")), _t);
+                            case 4:
+                              return _context.a(2);
+                          }
+                        }, _callee, null, [[0, 3]]);
+                      }));
+                      return function (_x4) {
+                        return _ref2.apply(this, arguments);
+                      };
+                    }()));
+                  case 6:
+                    _context2.n = 7;
+                    return findFiles(markerDirPath, 'page.mdx');
+                  case 7:
+                    updatedIndexes = _context2.v;
+                    if (updatedIndexes.length > 0) {
+                      console.log(chalk.yellow('\nUpdated index files:'));
+                      updatedIndexes.forEach(function (markerPath) {
+                        // Convert marker path back to actual index path
+                        var relativePath = path.relative(markerDirPath, markerPath);
+                        console.log(chalk.gray("  ".concat(relativePath)));
+                      });
+                      console.log(chalk.yellow("\nTotal: ".concat(updatedIndexes.length, " indexes updated\n")));
+                    } else {
+                      console.log(chalk.green('\nNo indexes needed updating\n'));
+                    }
+                    generatedFiles = updatedIndexes.length;
+                    currentMark = performanceMeasure(currentMark, {
+                      mark: 'Validated Files',
+                      measure: 'Validating Files'
+                    }, [functionName], true);
+                    console.log(completeMessage("".concat(generatedFiles, " index files updated in ").concat((performance.measure(nameMark(functionName, 'Validation', []), startMark, currentMark).duration / 1000).toPrecision(3), "s")));
+                    if (hasErrors) {
+                      console.error(chalk.red('\n✗ Validation failed with errors\n'));
+                      process.exit(1);
+                    }
+                    if (ci && generatedFiles > 0) {
+                      pathsArg = '';
+                      if (paths.length > 0) {
+                        // Use the paths that were provided
+                        pathsArg = " ".concat(paths.join(' '));
+                      } else {
+                        // Derive paths from the updated indexes
+                        updatedPaths = new Set();
+                        updatedIndexes.forEach(function (markerPath) {
+                          var relativePath = path.relative(markerDirPath, markerPath);
+                          // Extract the directory path (e.g., 'app/docs-infra/components/page.mdx' -> 'docs-infra/components')
+                          var dir = path.dirname(relativePath);
+                          // Remove 'app/' or 'src/app/' prefix if present
+                          var cleanDir = dir.replace(/^(src\/)?app\//, '');
+                          if (cleanDir) {
+                            updatedPaths.add(cleanDir);
+                          }
+                        });
+                        if (updatedPaths.size > 0) {
+                          pathsArg = " ".concat(Array.from(updatedPaths).map(function (p) {
+                            return /^[a-zA-Z0-9/_.-]+$/.test(p) ? p : "\"".concat(p, "\"");
+                          }).join(' '));
+                        }
+                      }
+                      console.error(chalk.red('\n✗ Index files are out of date. Run this command locally:\n'));
+                      console.error(chalk.cyan("  ".concat(command).concat(pathsArg)));
+                      console.error(chalk.red('\nThen commit the results.\n'));
+                      process.exit(1);
+                    }
+                  case 8:
+                    return _context2.a(2);
+                }
+              }, _callee2, null, [[1, 3]]);
+            }))()]);
+          case 1:
+            return _context3.a(2);
+        }
+      }, _callee3);
+    }));
+    function handler(_x3) {
+      return _handler.apply(this, arguments);
+    }
+    return handler;
+  }()
+};
+export default runValidate;

package/esm/createSitemap/createSitemap.d.ts

@@ -0,0 +1,23 @@
+import type * as React from 'react';
+import type { Sitemap } from "./types.js";
+type CreateSitemapMeta = {
+  name?: string;
+  slug?: string;
+  displayName?: string;
+  precompute?: Sitemap;
+  skipPrecompute?: boolean;
+  [key: string]: any;
+};
+/**
+ * Creates sitemap data from page components with optional precomputed data.
+ * Returns a sitemap data object containing schema and page data.
+ *
+ * In Next.js builds, the webpack loader precomputes the sitemap data.
+ * Outside Next.js (e.g., tests or scripts), use `loadServerSitemap()` for runtime loading.
+ *
+ * @param sourceUrl Depends on `import.meta.url` to determine the source file location.
+ * @param pages Record of page components indexed by path.
+ * @param meta Additional meta and precomputed sitemap configuration.
+ */
+export declare function createSitemap(sourceUrl: string, pages: Record<string, React.ComponentType<any> | null>, meta?: CreateSitemapMeta): Sitemap | undefined;
+export {};

package/esm/createSitemap/createSitemap.js

@@ -0,0 +1,45 @@
+/**
+ * Detects if code is running within a Next.js build or runtime context.
+ * Returns true if Next.js environment variables are present.
+ */
+function isNextJsContext() {
+  return typeof process !== 'undefined' && (typeof process.env.NEXT_RUNTIME === 'string' ||
+  // Next.js runtime (edge/nodejs)
+  // eslint-disable-next-line no-underscore-dangle
+  typeof process.env.__NEXT_PROCESSED_ENV === 'string' ||
+  // Next.js build
+  typeof process.env.NEXT_PHASE === 'string') // Next.js build phase
+  ;
+}
+
+/**
+ * Creates sitemap data from page components with optional precomputed data.
+ * Returns a sitemap data object containing schema and page data.
+ *
+ * In Next.js builds, the webpack loader precomputes the sitemap data.
+ * Outside Next.js (e.g., tests or scripts), use `loadServerSitemap()` for runtime loading.
+ *
+ * @param sourceUrl Depends on `import.meta.url` to determine the source file location.
+ * @param pages Record of page components indexed by path.
+ * @param meta Additional meta and precomputed sitemap configuration.
+ */
+export function createSitemap(sourceUrl, pages, meta) {
+  if (!sourceUrl.startsWith('file:')) {
+    throw new Error('createSitemap() requires the `sourceUrl` argument to be a file URL. Use `import.meta.url` to get the current file URL.');
+  }
+
+  // If precompute data exists or skipPrecompute is set, use the precomputed data
+  if (meta != null && meta.precompute || meta != null && meta.skipPrecompute) {
+    return meta.precompute;
+  }
+
+  // In Next.js context, precomputation should have happened via webpack loader
+  // If it didn't, throw an error to help developers fix their configuration
+  if (isNextJsContext()) {
+    throw new Error("createSitemap() was unable to precompute the sitemap data in ".concat(sourceUrl, ". Ensure the createSitemap() function is called within a path used for sitemap indexes. This is typically app/sitemap/index.ts but may be overridden in next.config.js"));
+  }
+
+  // Outside Next.js, return undefined (sync function can't do async loading)
+  // Use loadServerSitemap() for runtime loading
+  return undefined;
+}

package/esm/createSitemap/index.d.ts

@@ -0,0 +1 @@
+export * from "./createSitemap.js";

package/esm/createSitemap/index.js

@@ -0,0 +1 @@
+export * from "./createSitemap.js";

package/esm/createSitemap/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Section data structure from sitemap
+ */
+export interface SitemapSection {
+  title: string;
+  children?: Record<string, SitemapSection>;
+}
+/**
+ * Part data structure from sitemap (for component parts)
+ */
+export interface SitemapPart {
+  props?: string[];
+  dataAttributes?: string[];
+  cssVariables?: string[];
+}
+/**
+ * Export data structure from sitemap (for exported functions/components)
+ */
+export interface SitemapExport {
+  props?: string[];
+  dataAttributes?: string[];
+  cssVariables?: string[];
+}
+/**
+ * Page data structure from sitemap
+ */
+export interface SitemapPage {
+  title?: string;
+  slug: string;
+  path: string;
+  description?: string;
+  keywords?: string[];
+  sections?: Record<string, SitemapSection>;
+  parts?: Record<string, SitemapPart>;
+  exports?: Record<string, SitemapExport>;
+  tags?: string[];
+  skipDetailSection?: boolean;
+  openGraph?: {
+    title?: string;
+    description?: string;
+    images?: Array<{
+      url: string;
+      width: number;
+      height: number;
+      alt: string;
+    }>;
+  };
+}
+/**
+ * Section data from sitemap
+ */
+export interface SitemapSectionData {
+  title: string;
+  prefix: string;
+  pages: SitemapPage[];
+}
+/**
+ * Orama schema property types
+ * See: https://docs.orama.com/docs/orama-js/usage/create#schema-properties-and-types
+ */
+export type OramaSchemaType = 'string' | 'number' | 'boolean' | 'string[]' | 'number[]' | 'boolean[]' | `vector[${number}]`;
+/**
+ * Sitemap structure
+ */
+export interface Sitemap {
+  schema: Record<string, OramaSchemaType>;
+  data: Record<string, SitemapSectionData>;
+}

package/esm/createSitemap/types.js

@@ -0,0 +1 @@
+export {};

package/esm/pipeline/getFileConventions/fileConventions.d.ts

@@ -0,0 +1,4 @@
+export declare const fileConventions: {
+  rule: string;
+  loader: string;
+}[];

package/esm/pipeline/getFileConventions/fileConventions.js

@@ -0,0 +1,4 @@
+export var fileConventions = [{
+  rule: './app/**/demos/*/index.ts',
+  loader: 'loadPrecomputedCodeHighlighter'
+}];

package/esm/pipeline/getFileConventions/getFileConventions.d.ts

@@ -0,0 +1,4 @@
+export declare function getFileConventions(): Promise<{
+  rule: string;
+  loader: string;
+}[]>;

package/esm/pipeline/getFileConventions/getFileConventions.js

@@ -0,0 +1,17 @@
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { fileConventions } from "./fileConventions.js";
+export function getFileConventions() {
+  return _getFileConventions.apply(this, arguments);
+}
+function _getFileConventions() {
+  _getFileConventions = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          return _context.a(2, fileConventions);
+      }
+    }, _callee);
+  }));
+  return _getFileConventions.apply(this, arguments);
+}

package/esm/pipeline/getFileConventions/index.d.ts

@@ -0,0 +1 @@
+export * from "./getFileConventions.js";

package/esm/pipeline/getFileConventions/index.js

@@ -0,0 +1 @@
+export * from "./getFileConventions.js";

package/esm/{CodeHighlighter/addPathsToVariant.d.ts → pipeline/loadCodeVariant/addCodeVariantPaths.d.ts}

@@ -2,7 +2,7 @@
  * Add path utility to add path property to each file in a variant
  * Uses calculateMainFilePath utility and URL resolution for simplified path calculation
  */
-import type { VariantCode, VariantSource } from "./types.js";
+import type { VariantCode, VariantSource } from "../../CodeHighlighter/types.js";
 export interface FileWithPath {
   source?: VariantSource;
   metadata?: boolean;

package/esm/{CodeHighlighter/applyTransform.d.ts → pipeline/loadCodeVariant/applyCodeTransform.d.ts}

@@ -1,4 +1,4 @@
-import type { VariantSource, Transforms } from "./types.js";
+import type { VariantSource, Transforms } from "../../CodeHighlighter/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)
@@ -7,7 +7,7 @@ import type { VariantSource, Transforms } from "./types.js";
  * @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;
+export declare function applyCodeTransform(source: VariantSource, transforms: Transforms, transformKey: string): VariantSource;
 /**
  * Applies multiple transforms to a variant source in sequence
  * @param source - The original variant source
@@ -16,4 +16,4 @@ export declare function applyTransform(source: VariantSource, transforms: Transf
  * @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;
+export declare function applyCodeTransforms(source: VariantSource, transforms: Transforms, transformKeys: string[]): VariantSource;

package/esm/{CodeHighlighter/applyTransform.js → pipeline/loadCodeVariant/applyCodeTransform.js}

@@ -8,7 +8,7 @@ import { patch, clone } from 'jsondiffpatch';
  * @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) {
+export function applyCodeTransform(source, transforms, transformKey) {
   var transform = transforms[transformKey];
   if (!transform) {
     throw new Error("Transform \"".concat(transformKey, "\" not found in transforms"));
@@ -25,7 +25,7 @@ export function applyTransform(source, transforms, transformKey) {
     return patched.join('\n');
   }
 
-  // For Hast node sources, deltas are typically node-based (from transformParsedSource)
+  // For Hast node sources, deltas are typically node-based (from diffHast)
   var sourceRoot;
   var isHastJson = 'hastJson' in source;
   if (isHastJson) {
@@ -57,14 +57,14 @@ export function applyTransform(source, transforms, transformKey) {
  * @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) {
+export function applyCodeTransforms(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);
+      currentSource = applyCodeTransform(currentSource, transforms, transformKey);
     }
   } catch (err) {
     _iterator.e(err);

package/esm/{CodeHighlighter → pipeline/loadCodeVariant}/calculateMainFilePath.js

@@ -1,5 +1,5 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import { createSyntheticDirectories, buildPath } from './pathUtils.js';
+import { createSyntheticDirectories, buildPath } from "./pathUtils.js";
 export function calculateMainFilePath(url, maxBackNav, maxSourceBackNav, metadataPrefix, fileName) {
   // Handle optional parameters with defaults
   var actualMaxSourceBackNav = maxSourceBackNav != null ? maxSourceBackNav : maxBackNav;

package/esm/{CodeHighlighter/transformCode.d.ts → pipeline/loadCodeVariant/computeHastDeltas.d.ts}

@@ -1,4 +1,4 @@
-import type { Code, ParseSource } from "./types.js";
+import type { Code, ParseSource } from "../../CodeHighlighter/types.js";
 /**
  * Pure function to identify which variants need transformation.
  * Returns entries of variants that have transforms requiring processing.
@@ -13,9 +13,13 @@ export declare function getAvailableTransforms(parsedCode: Code | undefined, var
  * Pure async function to transform a single variant's code and extraFiles.
  * Returns the transformed variant or the original if transformation fails.
  */
-export declare function transformVariant(variant: string, variantCode: any, parseSource: ParseSource): Promise<any>;
+export declare function computeVariantDeltas(variant: string, variantCode: any, parseSource: ParseSource): Promise<any>;
 /**
- * Pure async function to apply transformations to all variants that need them.
- * Returns the enhanced code with computed transforms.
+ * Computes transform deltas for all variants in the parsed code.
+ * This function generates the transformation data that can be applied later.
+ *
+ * @param parsedCode - The parsed code object containing variants
+ * @param parseSource - The parser function to parse source strings
+ * @returns A promise that resolves to the code with computed transforms
  */
-export declare function applyTransforms(parsedCode: Code, parseSource: ParseSource): Promise<Code>;
+export declare function computeHastDeltas(parsedCode: Code, parseSource: ParseSource): Promise<Code>;