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

package/loaderUtils/resolveModulePathWithFs.d.ts

@@ -0,0 +1,44 @@
+import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions } from "./resolveModulePath.js";
+/**
+ * Resolves a module path using Node.js filesystem APIs.
+ * This is a convenience wrapper around the generic resolveModulePath function.
+ *
+ * @param modulePath - The module path to resolve (without file extension)
+ * @param options - Configuration options
+ * @returns Promise<string> - The resolved file path, or throws if not found
+ */
+export declare function resolveModulePathWithFs(modulePath: string, options?: ResolveModulePathOptions): Promise<string>;
+/**
+ * Resolves multiple module paths using Node.js filesystem APIs.
+ * This is a convenience wrapper around the generic resolveModulePaths function.
+ *
+ * @param modulePaths - Array of module paths to resolve (without file extensions)
+ * @param options - Configuration options
+ * @returns Promise<Map<string, string>> - Map from input path to resolved file path
+ */
+export declare function resolveModulePathsWithFs(modulePaths: string[], options?: ResolveModulePathOptions): Promise<Map<string, string>>;
+/**
+ * Resolves import result by separating JavaScript modules from static assets,
+ * only resolving JavaScript modules and returning a combined map.
+ * This is a convenience wrapper around the generic resolveImportResult function
+ * that uses Node.js filesystem APIs.
+ *
+ * @param importResult - The result from resolveImports containing all imports
+ * @param options - Configuration options for module resolution
+ * @returns Promise<Map<string, string>> - Map from import path to resolved file path
+ */
+export declare function resolveImportResultWithFs(importResult: Record<string, {
+  path: string;
+  names: string[];
+}>, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
+/**
+ * Resolves variant paths from a variants object mapping variant names to their file paths.
+ * This is a convenience wrapper around the generic resolveVariantPaths function
+ * that uses Node.js filesystem APIs.
+ *
+ * @param variants - Object mapping variant names to their file paths
+ * @param options - Configuration options for module resolution
+ * @returns Promise<Map<string, string>> - Map from variant name to resolved file URL
+ */
+export declare function resolveVariantPathsWithFs(variants: Record<string, string>, options?: ResolveModulePathOptions): Promise<Map<string, string>>;
+export type { DirectoryEntry, DirectoryReader, ResolveModulePathOptions };

package/loaderUtils/resolveModulePathWithFs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveModulePathWithFs.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/resolveModulePathWithFs.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC9B,MAAM,qBAAqB,CAAC;AAe7B;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE9B;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EAC/D,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE9B;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAE9B;AAGD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,wBAAwB,EAAE,CAAC"}

package/loaderUtils/resolveModulePathWithFs.js

@@ -0,0 +1,159 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { readdir } from 'node:fs/promises';
+import { resolveModulePath, resolveModulePaths, resolveImportResult, resolveVariantPaths } from "./resolveModulePath.js";
+
+/**
+ * Node.js filesystem-based directory reader that converts Dirent objects
+ * to the DirectoryEntry interface expected by the resolver functions.
+ */
+var nodeDirectoryReader = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(path) {
+    var entries;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return readdir(path, {
+            withFileTypes: true
+          });
+        case 2:
+          entries = _context.sent;
+          return _context.abrupt("return", entries.map(function (entry) {
+            return {
+              name: entry.name,
+              isFile: entry.isFile(),
+              isDirectory: entry.isDirectory()
+            };
+          }));
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function nodeDirectoryReader(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+/**
+ * Resolves a module path using Node.js filesystem APIs.
+ * This is a convenience wrapper around the generic resolveModulePath function.
+ *
+ * @param modulePath - The module path to resolve (without file extension)
+ * @param options - Configuration options
+ * @returns Promise<string> - The resolved file path, or throws if not found
+ */
+export function resolveModulePathWithFs(_x2) {
+  return _resolveModulePathWithFs.apply(this, arguments);
+}
+
+/**
+ * Resolves multiple module paths using Node.js filesystem APIs.
+ * This is a convenience wrapper around the generic resolveModulePaths function.
+ *
+ * @param modulePaths - Array of module paths to resolve (without file extensions)
+ * @param options - Configuration options
+ * @returns Promise<Map<string, string>> - Map from input path to resolved file path
+ */
+function _resolveModulePathWithFs() {
+  _resolveModulePathWithFs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(modulePath) {
+    var options,
+      _args2 = arguments;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+          return _context2.abrupt("return", resolveModulePath(modulePath, nodeDirectoryReader, options));
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _resolveModulePathWithFs.apply(this, arguments);
+}
+export function resolveModulePathsWithFs(_x3) {
+  return _resolveModulePathsWithFs.apply(this, arguments);
+}
+
+/**
+ * Resolves import result by separating JavaScript modules from static assets,
+ * only resolving JavaScript modules and returning a combined map.
+ * This is a convenience wrapper around the generic resolveImportResult function
+ * that uses Node.js filesystem APIs.
+ *
+ * @param importResult - The result from resolveImports containing all imports
+ * @param options - Configuration options for module resolution
+ * @returns Promise<Map<string, string>> - Map from import path to resolved file path
+ */
+function _resolveModulePathsWithFs() {
+  _resolveModulePathsWithFs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(modulePaths) {
+    var options,
+      _args3 = arguments;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          options = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
+          return _context3.abrupt("return", resolveModulePaths(modulePaths, nodeDirectoryReader, options));
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _resolveModulePathsWithFs.apply(this, arguments);
+}
+export function resolveImportResultWithFs(_x4) {
+  return _resolveImportResultWithFs.apply(this, arguments);
+}
+
+/**
+ * Resolves variant paths from a variants object mapping variant names to their file paths.
+ * This is a convenience wrapper around the generic resolveVariantPaths function
+ * that uses Node.js filesystem APIs.
+ *
+ * @param variants - Object mapping variant names to their file paths
+ * @param options - Configuration options for module resolution
+ * @returns Promise<Map<string, string>> - Map from variant name to resolved file URL
+ */
+function _resolveImportResultWithFs() {
+  _resolveImportResultWithFs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(importResult) {
+    var options,
+      _args4 = arguments;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          options = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {};
+          return _context4.abrupt("return", resolveImportResult(importResult, nodeDirectoryReader, options));
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _resolveImportResultWithFs.apply(this, arguments);
+}
+export function resolveVariantPathsWithFs(_x5) {
+  return _resolveVariantPathsWithFs.apply(this, arguments);
+}
+
+// Re-export types for convenience
+function _resolveVariantPathsWithFs() {
+  _resolveVariantPathsWithFs = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee5(variants) {
+    var options,
+      _args5 = arguments;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          options = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : {};
+          return _context5.abrupt("return", resolveVariantPaths(variants, nodeDirectoryReader, options));
+        case 2:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _resolveVariantPathsWithFs.apply(this, arguments);
+}

package/loaderUtils/rewriteImports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rewrites relative imports in source code to assume all files are in the same directory.
+ * Converts imports like '../utils/helper' or './components/Button' to './helper' and './Button'
+ *
+ * @param source - The source code to process
+ * @param filePaths - Set of file paths that are available as dependencies
+ * @returns The source code with rewritten imports
+ */
+export declare function rewriteImportsToSameDirectory(source: string, filePaths: Set<string>): string;

package/loaderUtils/rewriteImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewriteImports.d.ts","sourceRoot":"","sources":["../../../src/loaderUtils/rewriteImports.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,CAmD5F"}

package/loaderUtils/rewriteImports.js

@@ -0,0 +1,57 @@
+import { JAVASCRIPT_MODULE_EXTENSIONS, isJavaScriptModule } from "./resolveModulePath.js";
+import { getFileNameFromUrl } from "./getFileNameFromUrl.js";
+
+/**
+ * Rewrites relative imports in source code to assume all files are in the same directory.
+ * Converts imports like '../utils/helper' or './components/Button' to './helper' and './Button'
+ *
+ * @param source - The source code to process
+ * @param filePaths - Set of file paths that are available as dependencies
+ * @returns The source code with rewritten imports
+ */
+export function rewriteImportsToSameDirectory(source, filePaths) {
+  // Create a map of original file paths to just their basenames
+  var fileBasenames = new Map();
+  Array.from(filePaths).forEach(function (path) {
+    fileBasenames.set(path, getFileNameFromUrl(path).fileName);
+  });
+
+  // Regex to match import statements with relative paths
+  var importRegex = /import\s+((?:\w+|\*\s+as\s+\w+|{[^}]+})\s+from\s+)['"]([^'"]+)['"]/g;
+  return source.replace(importRegex, function (match, importPart, modulePath) {
+    // Only process relative imports
+    if (modulePath.startsWith('.')) {
+      // Extract the filename from the path
+      var filename = getFileNameFromUrl(modulePath).fileName;
+
+      // For static assets (CSS, JSON, etc.), use the filename as-is
+      if (!isJavaScriptModule(modulePath)) {
+        var matchingPath = Array.from(filePaths).find(function (path) {
+          return getFileNameFromUrl(path).fileName === filename;
+        });
+        if (matchingPath) {
+          return "import ".concat(importPart, "'./").concat(filename, "'");
+        }
+      } else {
+        // For JS/TS modules, check against all possible extensions
+        var _matchingPath = Array.from(filePaths).find(function (path) {
+          var pathBasename = getFileNameFromUrl(path).fileName;
+          return pathBasename === filename || JAVASCRIPT_MODULE_EXTENSIONS.some(function (ext) {
+            var _getFileNameFromUrl = getFileNameFromUrl(path),
+              fileName = _getFileNameFromUrl.fileName;
+            return fileName.endsWith(ext) ? fileName.slice(0, -ext.length) === filename : false;
+          });
+        });
+        if (_matchingPath) {
+          // For JS/TS modules, rewrite to same directory without extension
+          var pathBasename = getFileNameFromUrl(_matchingPath).fileName;
+          var nameWithoutExt = JAVASCRIPT_MODULE_EXTENSIONS.reduce(function (name, ext) {
+            return name.replace(new RegExp("\\".concat(ext, "$")), '');
+          }, pathBasename);
+          return "import ".concat(importPart, "'./").concat(nameWithoutExt, "'");
+        }
+      }
+    }
+    return match;
+  });
+}

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@mui/internal-docs-infra",
-  "version": "0.1.0",
+  "version": "0.1.1-alpha.1",
   "author": "MUI Team",
   "description": "MUI Infra - internal documentation creation tools.",
+  "type": "module",
   "main": "./index.js",
   "exports": {
     "./package.json": "./package.json",
     ".": "./index.js",
-    "./*": "./*/index.js"
+    "./*": "./*/index.js",
+    "./*/types": "./*/types.js",
+    "./*/errors": "./*/errors.js"
   },
   "keywords": [
     "react",
@@ -28,12 +31,23 @@
   "homepage": "https://github.com/mui/mui-public/tree/master/packages/docs-infra",
   "dependencies": {
     "@babel/runtime": "^7.27.6",
-    "@types/hast": "^3.0.4",
+    "@babel/standalone": "^7.28.1",
+    "@wooorm/starry-night": "^3.8.0",
     "clipboard-copy": "^4.0.1",
-    "hast": "^1.0.0",
     "hast-util-to-jsx-runtime": "^2.3.6",
+    "hast-util-to-mdast": "^10.1.2",
     "hast-util-to-text": "^4.0.2",
-    "kebab-case": "^2.0.2"
+    "js-sha256": "^0.11.1",
+    "jsondiffpatch": "^0.7.3",
+    "kebab-case": "^2.0.2",
+    "prettier": "^3.5.3",
+    "rehype-parse": "^9.0.1",
+    "rehype-remark": "^10.0.1",
+    "rehype-sanitize": "^6.0.0",
+    "remark-stringify": "^11.0.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.0.0",
+    "vscode-oniguruma": "^2.0.1"
   },
   "peerDependencies": {
     "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
@@ -52,6 +66,5 @@
   "engines": {
     "node": ">=14.0.0"
   },
-  "private": false,
-  "module": "./esm/index.js"
+  "private": false
 }

package/parseSource/grammars.d.ts

@@ -0,0 +1,2 @@
+export declare const grammars: import("@wooorm/starry-night").Grammar[];
+export declare const extensionMap: Record<string, string>;

package/parseSource/grammars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammars.d.ts","sourceRoot":"","sources":["../../../src/parseSource/grammars.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,QAAQ,0CAWpB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAY/C,CAAC"}

package/parseSource/grammars.js

@@ -0,0 +1,27 @@
+import sourceJs from '@wooorm/starry-night/source.js';
+import sourceTs from '@wooorm/starry-night/source.ts';
+import sourceTsx from '@wooorm/starry-night/source.tsx';
+import sourceJson from '@wooorm/starry-night/source.json';
+import textMd from '@wooorm/starry-night/text.md';
+import sourceMdx from '@wooorm/starry-night/source.mdx';
+import textHtmlBasic from '@wooorm/starry-night/text.html.basic';
+import sourceCss from '@wooorm/starry-night/source.css';
+import sourceShell from '@wooorm/starry-night/source.shell';
+import sourceYaml from '@wooorm/starry-night/source.yaml';
+export var grammars = [sourceJs, sourceTs, sourceTsx, sourceJson, textMd, sourceMdx,
+// needs sourceTsx
+textHtmlBasic, sourceCss, sourceShell, sourceYaml];
+export var extensionMap = {
+  '.js': 'source.js',
+  '.ts': 'source.ts',
+  '.jsx': 'source.tsx',
+  // TODO: is there a JSX grammar?
+  '.tsx': 'source.tsx',
+  '.json': 'source.json',
+  '.md': 'text.md',
+  '.mdx': 'source.mdx',
+  '.html': 'text.html.basic',
+  '.css': 'source.css',
+  '.sh': 'source.shell',
+  '.yaml': 'source.yaml'
+};

package/parseSource/index.d.ts

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

package/parseSource/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/parseSource/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/parseSource/index.js

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

package/parseSource/parseSource.d.ts

@@ -0,0 +1,3 @@
+import { ParseSource } from "../CodeHighlighter/index.js";
+export declare const parseSource: ParseSource;
+export declare const parseSourceFactory: () => Promise<ParseSource>;

package/parseSource/parseSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSource.d.ts","sourceRoot":"","sources":["../../../src/parseSource/parseSource.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAOjD,eAAO,MAAM,WAAW,EAAE,WASzB,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,WAAW,CAM9D,CAAC"}

package/parseSource/parseSource.js

@@ -0,0 +1,37 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { createStarryNight } from '@wooorm/starry-night';
+import { grammars, extensionMap } from "./grammars.js";
+var starryNight = null;
+export var parseSource = function parseSource(source, fileName) {
+  if (!starryNight) {
+    throw new Error('Starry Night not initialized. Use parseSourceFactory to create an initialized parseSource function.');
+  }
+  var fileType = fileName.slice(fileName.lastIndexOf('.')) || 'plaintext';
+  return starryNight.highlight(source, extensionMap[fileType] || 'plaintext');
+};
+export var parseSourceFactory = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (starryNight) {
+            _context.next = 4;
+            break;
+          }
+          _context.next = 3;
+          return createStarryNight(grammars);
+        case 3:
+          starryNight = _context.sent;
+        case 4:
+          return _context.abrupt("return", parseSource);
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function parseSourceFactory() {
+    return _ref.apply(this, arguments);
+  };
+}();

package/transformRelativeMarkdownPaths/index.d.ts

@@ -0,0 +1,2 @@
+import { transformRelativeMarkdownPaths } from "./transformRelativeMarkdownPaths.js";
+export default transformRelativeMarkdownPaths;

package/transformRelativeMarkdownPaths/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformRelativeMarkdownPaths/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAElF,eAAe,8BAA8B,CAAC"}

package/transformRelativeMarkdownPaths/index.js

@@ -0,0 +1,4 @@
+// This is the export format expected by a remark plugin.
+
+import { transformRelativeMarkdownPaths } from "./transformRelativeMarkdownPaths.js";
+export default transformRelativeMarkdownPaths;

package/transformRelativeMarkdownPaths/transformRelativeMarkdownPaths.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'unified';
+/**
+ * Remark plugin that strips page file extensions from URLs.
+ * Removes /page.tsx, /page.jsx, /page.js, /page.mdx, /page.md from both absolute and relative URLs.
+ * For relative URLs, converts them to absolute paths based on the current file's location.
+ *
+ * Examples:
+ * - /components/page.tsx -> /components
+ * - ./code-highlighter/page.mdx -> /components/code-highlighter (when processed from /components/page.mdx)
+ * This allows URLs to resolve when reading in VSCode and Github
+ */
+export declare const transformRelativeMarkdownPaths: Plugin;

package/transformRelativeMarkdownPaths/transformRelativeMarkdownPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformRelativeMarkdownPaths.d.ts","sourceRoot":"","sources":["../../../src/transformRelativeMarkdownPaths/transformRelativeMarkdownPaths.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAItC;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B,EAAE,MAmB5C,CAAC"}

package/transformRelativeMarkdownPaths/transformRelativeMarkdownPaths.js

@@ -0,0 +1,30 @@
+import { visit } from 'unist-util-visit';
+import path from 'path';
+
+/**
+ * Remark plugin that strips page file extensions from URLs.
+ * Removes /page.tsx, /page.jsx, /page.js, /page.mdx, /page.md from both absolute and relative URLs.
+ * For relative URLs, converts them to absolute paths based on the current file's location.
+ *
+ * Examples:
+ * - /components/page.tsx -> /components
+ * - ./code-highlighter/page.mdx -> /components/code-highlighter (when processed from /components/page.mdx)
+ * This allows URLs to resolve when reading in VSCode and Github
+ */
+export var transformRelativeMarkdownPaths = function transformRelativeMarkdownPaths() {
+  return function (tree, file) {
+    visit(tree, 'link', function (node) {
+      if (node.url) {
+        node.url = node.url.replace(/\/page\.(tsx|jsx|js|mdx|md)$/g, '');
+        node.url = node.url.replace(/\/page\.(tsx|jsx|js|mdx|md)(\?[^#]*)?(#.*)?$/g, '$2$3');
+        if (node.url.startsWith('./') && file.path) {
+          var currentDir = path.dirname(file.path);
+          var appIndex = currentDir.indexOf('/app/');
+          var baseDir = appIndex !== -1 ? currentDir.substring(appIndex + 4) : '/';
+          node.url = path.join('/', baseDir, node.url.replace(/^\.\//, ''));
+        }
+        node.url = node.url.replace(/\/$/, '');
+      }
+    });
+  };
+};

package/transformTsToJs/index.d.ts

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

package/transformTsToJs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transformTsToJs/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/transformTsToJs/index.js

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

package/transformTsToJs/removeTypes.d.ts

@@ -0,0 +1,13 @@
+import type { Options as PrettierOptions } from 'prettier';
+/**
+ * Strips TypeScript types and decorators from code (including React in TSX),
+ * preserving blank lines and optionally formatting with Prettier.
+ *
+ * @param code - The source code string to transform.
+ * @param filename - The name of the file (e.g. "foo.ts" or "Foo.tsx").
+ *                   Determines whether TSX parsing is enabled.
+ * @param prettierConfig - `true` for default formatting, `false` to skip,
+ *                         or a Prettier options object to customize.
+ * @returns The transformed (and optionally formatted) code.
+ */
+export declare function removeTypes(code: string, filename?: string, prettierConfig?: PrettierOptions | boolean): Promise<string>;

package/transformTsToJs/removeTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeTypes.d.ts","sourceRoot":"","sources":["../../../src/transformTsToJs/removeTypes.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3D;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,SAAY,EACpB,cAAc,GAAE,eAAe,GAAG,OAAc,GAC/C,OAAO,CAAC,MAAM,CAAC,CAkGjB"}

package/transformTsToJs/removeTypes.js

@@ -0,0 +1,134 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// Based on https://github.com/ember-cli/babel-remove-types/blob/fc3be010e99c4f4926fd70d00242d6777ab1b8d7/src/index.ts
+// Converted to use Babel standalone, with added TSX support
+
+import * as Babel from '@babel/standalone';
+import prettier from 'prettier/standalone';
+import prettierPluginEstree from 'prettier/plugins/estree';
+import parserBabel from 'prettier/parser-babel';
+/**
+ * Strips TypeScript types and decorators from code (including React in TSX),
+ * preserving blank lines and optionally formatting with Prettier.
+ *
+ * @param code - The source code string to transform.
+ * @param filename - The name of the file (e.g. "foo.ts" or "Foo.tsx").
+ *                   Determines whether TSX parsing is enabled.
+ * @param prettierConfig - `true` for default formatting, `false` to skip,
+ *                         or a Prettier options object to customize.
+ * @returns The transformed (and optionally formatted) code.
+ */
+export function removeTypes(_x) {
+  return _removeTypes.apply(this, arguments);
+}
+function _removeTypes() {
+  _removeTypes = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(code) {
+    var filename,
+      prettierConfig,
+      removeComments,
+      isTSX,
+      transformed,
+      fixed,
+      standardPrettierOptions,
+      mergedPrettierOptions,
+      _args = arguments;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          filename = _args.length > 1 && _args[1] !== undefined ? _args[1] : 'file.ts';
+          prettierConfig = _args.length > 2 && _args[2] !== undefined ? _args[2] : true;
+          // Babel collapses newlines all over the place, which messes with the formatting of almost any
+          // code you pass to it. To preserve the formatting, we go through and mark all the empty lines
+          // in the code string *before* transforming it. This allows us to go back through after the
+          // transformation re-insert the empty lines in the correct place relative to the new code that
+          // has been generated.
+          code = code.replace(/\n\n+/g, '/* ___NEWLINE___ */\n');
+
+          // When removing TS-specific constructs (e.g. interfaces), we want to make sure we also remove
+          // any comments that are associated with those constructs, since otherwise we'll be left with
+          // comments that refer to something that isn't actually there.
+          // Credit to https://github.com/cyco130/detype for figuring out this very useful pattern
+          removeComments = {
+            enter: function enter(nodePath) {
+              if (!nodePath.node.leadingComments) {
+                return;
+              }
+              for (var i = nodePath.node.leadingComments.length - 1; i >= 0; i -= 1) {
+                var comment = nodePath.node.leadingComments[i];
+                if (code.slice(comment.end).match(/^\s*\n\s*\n/) || comment.value.includes('___NEWLINE___')) {
+                  // There is at least one empty line between the comment and the TypeScript specific construct
+                  // We should keep this comment and those before it
+                  break;
+                }
+                comment.value = '___REMOVE_ME___';
+              }
+            }
+          };
+          isTSX = /\.tsx$/i.test(filename);
+          transformed = Babel.transform(code, {
+            filename: filename,
+            plugins: [{
+              name: 'comment-remover',
+              visitor: {
+                TSTypeAliasDeclaration: removeComments,
+                TSInterfaceDeclaration: removeComments,
+                TSDeclareFunction: removeComments,
+                TSDeclareMethod: removeComments,
+                TSImportType: removeComments,
+                TSModuleDeclaration: removeComments
+              }
+            }, ['transform-typescript', {
+              onlyRemoveTypeImports: true,
+              isTSX: isTSX,
+              allExtensions: true
+            }], ['proposal-decorators', {
+              legacy: true
+            }]],
+            generatorOpts: {
+              retainLines: true,
+              shouldPrintComment: function shouldPrintComment(c) {
+                return c !== '___REMOVE_ME___';
+              }
+            }
+          });
+          if (!(!transformed || !transformed.code)) {
+            _context.next = 8;
+            break;
+          }
+          throw new Error('There was an issue with the Babel transform.');
+        case 8:
+          fixed = transformed.code.replace(/\/\* ___NEWLINE___ \*\//g, '\n'); // If the user has *explicitly* passed `false` here, it means they do not want us to run Prettier
+          // at all, so we bail here.
+          if (!(prettierConfig === false)) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("return", fixed);
+        case 11:
+          standardPrettierOptions = {
+            parser: 'babel',
+            singleQuote: true,
+            plugins: [prettierPluginEstree, parserBabel]
+          }; // If `prettierConfig` is *explicitly* true (as opposed to truthy), it means the user has opted in
+          // to default behavior either explicitly or implicitly. Either way, we run basic Prettier on it.
+          if (!(prettierConfig === true)) {
+            _context.next = 14;
+            break;
+          }
+          return _context.abrupt("return", prettier.format(fixed, standardPrettierOptions));
+        case 14:
+          // If we've made it here, the user has passed their own Prettier options so we merge it with ours
+          // and let theirs overwrite any of the default settings.
+          mergedPrettierOptions = _objectSpread(_objectSpread(_objectSpread({}, standardPrettierOptions), prettierConfig), {}, {
+            plugins: standardPrettierOptions.plugins
+          });
+          return _context.abrupt("return", prettier.format(fixed, mergedPrettierOptions));
+        case 16:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _removeTypes.apply(this, arguments);
+}