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

package/esm/pipeline/loadPrecomputedSitemap/loadPrecomputedSitemap.js

@@ -0,0 +1,220 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// webpack does not like node: imports
+// eslint-disable-next-line n/prefer-node-protocol
+import path from 'path';
+// eslint-disable-next-line n/prefer-node-protocol
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createPerformanceLogger, logPerformance, nameMark, performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.js";
+import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
+import { replacePrecomputeValue } from "../loadPrecomputedCodeHighlighter/replacePrecomputeValue.js";
+import { rewriteImportsToNull } from "../loaderUtils/rewriteImports.js";
+import { createLoadServerPageIndex } from "../loadServerPageIndex/loadServerPageIndex.js";
+import { createSitemapSchema } from "../loadServerSitemap/loadServerSitemap.js";
+var functionName = 'Load Precomputed Sitemap';
+export function loadPrecomputedSitemap(_x) {
+  return _loadPrecomputedSitemap.apply(this, arguments);
+}
+function _loadPrecomputedSitemap() {
+  _loadPrecomputedSitemap = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
+    var _options$performance$, _options$performance, _options$performance$2, _options$performance2, _options$performance3;
+    var callback, options, performanceNotableMs, performanceShowWrapperMeasures, relativePath, observer, currentMark, _observer, _observer2, resourceFileUrl, sitemapCall, variants, sitemapData, rootContext, loadPageIndex, entries, results, _iterator, _step, result, precomputeData, modifiedSource, relative, importPathsToRewrite, importResult, _i, _Object$entries, _Object$entries$_i, importPath, importData, _observer3, _observer4, _t2;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.p = _context2.n) {
+        case 0:
+          callback = this.async();
+          this.cacheable();
+          options = this.getOptions();
+          performanceNotableMs = (_options$performance$ = (_options$performance = options.performance) == null ? void 0 : _options$performance.notableMs) != null ? _options$performance$ : 100;
+          performanceShowWrapperMeasures = (_options$performance$2 = (_options$performance2 = options.performance) == null ? void 0 : _options$performance2.showWrapperMeasures) != null ? _options$performance$2 : false; // const resourceName = extractNameAndSlugFromUrl(
+          //   new URL('.', `file://${this.resourcePath}`).pathname,
+          // ).name;
+          relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
+          observer = undefined;
+          if ((_options$performance3 = options.performance) != null && _options$performance3.logging) {
+            observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+            observer.observe({
+              entryTypes: ['measure']
+            });
+          }
+          currentMark = nameMark(functionName, 'Start Loading', [relativePath]);
+          performance.mark(currentMark);
+          _context2.p = 1;
+          // Convert the filesystem path to a file:// URL for cross-platform compatibility
+          // pathToFileURL handles Windows drive letters correctly (e.g., C:\... → file:///C:/...)
+          resourceFileUrl = pathToFileURL(this.resourcePath).toString(); // Parse the source to find a single createSitemap call
+          _context2.n = 2;
+          return parseCreateFactoryCall(source, resourceFileUrl);
+        case 2:
+          sitemapCall = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed Factory',
+            measure: 'Factory Parsing'
+          }, [functionName, relativePath]);
+
+          // If no createSitemap call found, return the source unchanged
+          if (sitemapCall) {
+            _context2.n = 3;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 3:
+          if (!sitemapCall.options.skipPrecompute) {
+            _context2.n = 4;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 4:
+          // Extract the variants (imported markdown files)
+          variants = sitemapCall.variants;
+          if (!(!variants || Object.keys(variants).length === 0)) {
+            _context2.n = 5;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 5:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Extracted Variants',
+            measure: 'Variant Extraction'
+          }, [functionName, relativePath]);
+
+          // Read and parse each markdown file
+          sitemapData = {}; // Create page index loader with root context
+          rootContext = this.rootContext || process.cwd();
+          loadPageIndex = createLoadServerPageIndex({
+            rootContext: rootContext
+          }); // Process all markdown files in parallel using shared logic
+          entries = Object.entries(variants);
+          _context2.n = 6;
+          return Promise.all(entries.map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+              var _ref3, key, importPath, absolutePath, metadata, _t;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.p = _context.n) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), key = _ref3[0], importPath = _ref3[1];
+                    // Convert file:// URLs to proper file system paths for webpack's dependency tracking
+                    // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+                    absolutePath = importPath.startsWith('file://') ? fileURLToPath(importPath) : importPath;
+                    _context.p = 1;
+                    _context.n = 2;
+                    return loadPageIndex(importPath);
+                  case 2:
+                    metadata = _context.v;
+                    return _context.a(2, {
+                      key: key,
+                      absolutePath: absolutePath,
+                      metadata: metadata,
+                      error: null
+                    });
+                  case 3:
+                    _context.p = 3;
+                    _t = _context.v;
+                    return _context.a(2, {
+                      key: key,
+                      absolutePath: absolutePath,
+                      metadata: null,
+                      error: _t instanceof Error ? _t : new Error(String(_t))
+                    });
+                }
+              }, _callee, null, [[1, 3]]);
+            }));
+            return function (_x2) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 6:
+          results = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Processed All Files',
+            measure: 'Process Markdown Files'
+          }, [functionName, relativePath]);
+
+          // Collect results and dependencies
+          _iterator = _createForOfIteratorHelper(results);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              result = _step.value;
+              if (result.error) {
+                // Log error but continue processing other files
+                console.error("Failed to process ".concat(result.key, " at ").concat(result.absolutePath, ":"), result.error);
+              } else if (result.metadata) {
+                sitemapData[result.key] = result.metadata;
+                // Add to dependencies for webpack watching
+                this.addDependency(result.absolutePath);
+              }
+            }
+
+            // Create sitemap with Orama schema for search indexing
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          precomputeData = {
+            schema: createSitemapSchema(),
+            data: sitemapData
+          }; // Replace the factory function call with the precomputed sitemap data
+          modifiedSource = replacePrecomputeValue(source, precomputeData, sitemapCall);
+          performanceMeasure(currentMark, {
+            mark: 'replaced precompute',
+            measure: 'precompute replacement'
+          }, [functionName, relativePath]);
+
+          // Rewrite MDX imports to const declarations since we've precomputed the data
+          if (sitemapCall.importsAndComments) {
+            relative = sitemapCall.importsAndComments.relative; // Build a set of MDX imports to rewrite
+            importPathsToRewrite = new Set();
+            importResult = {};
+            for (_i = 0, _Object$entries = Object.entries(relative); _i < _Object$entries.length; _i++) {
+              _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), importPath = _Object$entries$_i[0], importData = _Object$entries$_i[1];
+              // Check if this is an MDX file
+              if (importPath.endsWith('.mdx')) {
+                // Add to the set of imports to rewrite
+                importPathsToRewrite.add(importPath);
+                importResult[importPath] = {
+                  positions: importData.positions,
+                  names: importData.names
+                };
+              }
+            }
+
+            // Rewrite the import statements to const declarations if there are any MDX imports
+            if (importPathsToRewrite.size > 0) {
+              modifiedSource = rewriteImportsToNull(modifiedSource, importPathsToRewrite, importResult);
+              currentMark = performanceMeasure(currentMark, {
+                mark: 'rewritten imports',
+                measure: 'import rewriting'
+              }, [functionName, relativePath]);
+            }
+          }
+
+          // log any pending performance entries before completing
+          (_observer = observer) == null || (_observer = _observer.takeRecords()) == null || _observer.forEach(function (entry) {
+            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
+          });
+          (_observer2 = observer) == null || _observer2.disconnect();
+          callback(null, modifiedSource);
+          _context2.n = 8;
+          break;
+        case 7:
+          _context2.p = 7;
+          _t2 = _context2.v;
+          // log any pending performance entries before completing
+          (_observer3 = observer) == null || (_observer3 = _observer3.takeRecords()) == null || _observer3.forEach(function (entry) {
+            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
+          });
+          (_observer4 = observer) == null || _observer4.disconnect();
+          callback(_t2 instanceof Error ? _t2 : new Error(String(_t2)));
+        case 8:
+          return _context2.a(2);
+      }
+    }, _callee2, this, [[1, 7]]);
+  }));
+  return _loadPrecomputedSitemap.apply(this, arguments);
+}

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

@@ -1 +1,2 @@
-export * from "./loadServerCodeMeta.js";
+export * from "./loadServerCodeMeta.js";
+export * from "./resolveModulePathWithFs.js";

package/esm/pipeline/loadServerCodeMeta/index.js

@@ -1 +1,2 @@
-export * from "./loadServerCodeMeta.js";
+export * from "./loadServerCodeMeta.js";
+export * from "./resolveModulePathWithFs.js";

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.d.ts

@@ -16,7 +16,7 @@ export declare const loadServerCodeMeta: LoadCodeMeta;
  * 3. Returns a Code object mapping variant names to their resolved file URLs
  *
  * The actual loading, parsing, and transformation of the variants is handled
- * elsewhere by the CodeHighlighter component using loadVariant.
+ * elsewhere by the CodeHighlighter component using loadCodeVariant.
  *
  * @param options - Configuration options (currently unused)
  * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.js

@@ -2,7 +2,8 @@ import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { readFile } from 'node:fs/promises';
-import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { fileURLToPath } from 'node:url';
+import { resolveVariantPathsWithFs } from "./resolveModulePathWithFs.js";
 import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
 /**
@@ -22,7 +23,7 @@ export var loadServerCodeMeta = createLoadServerCodeMeta();
  * 3. Returns a Code object mapping variant names to their resolved file URLs
  *
  * The actual loading, parsing, and transformation of the variants is handled
- * elsewhere by the CodeHighlighter component using loadVariant.
+ * elsewhere by the CodeHighlighter component using loadCodeVariant.
  *
  * @param options - Configuration options (currently unused)
  * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>
@@ -35,14 +36,15 @@ export function createLoadServerCodeMeta() {
       return _regenerator().w(function (_context) {
         while (1) switch (_context.n) {
           case 0:
-            // Remove file:// prefix if present to get file path
-            filePath = url.replace('file://', ''); // Read the source file to find createDemo calls
+            // Convert file:// URL to proper file system path for reading the file
+            // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+            filePath = url.startsWith('file://') ? fileURLToPath(url) : url; // Read the source file to find createDemo calls
             _context.n = 1;
             return readFile(filePath, 'utf-8');
           case 1:
             source = _context.v;
             _context.n = 2;
-            return parseCreateFactoryCall(source, filePath);
+            return parseCreateFactoryCall(source, url);
           case 2:
             demoCall = _context.v;
             if (!(!demoCall || !demoCall.variants)) {

package/esm/pipeline/{loaderUtils → loadServerCodeMeta}/resolveModulePathWithFs.d.ts

@@ -1,4 +1,4 @@
-import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions, type TypeAwareResolveResult } from "./resolveModulePath.js";
+import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions, type TypeAwareResolveResult } from "../loaderUtils/resolveModulePath.js";
 /**
  * Resolves a module path using Node.js filesystem APIs.
  * This is a convenience wrapper around the generic resolveModulePath function.
@@ -18,7 +18,7 @@ export declare function resolveModulePathWithFs(modulePath: string, options: Res
  * @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>>;
+export declare function resolveModulePathsWithFs(moduleUrls: 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.
@@ -30,7 +30,7 @@ export declare function resolveModulePathsWithFs(modulePaths: string[], options?
  * @returns Promise<Map<string, string>> - Map from import path to resolved file path
  */
 export declare function resolveImportResultWithFs(importResult: Record<string, {
-  path: string;
+  url: string;
   names: string[];
   includeTypeDefs?: true;
   positions?: Array<{

package/esm/pipeline/{loaderUtils → loadServerCodeMeta}/resolveModulePathWithFs.js

@@ -3,20 +3,26 @@ import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import { readdir } from 'fs/promises';
-import { resolveModulePath, resolveModulePaths, resolveImportResult, resolveVariantPaths } from "./resolveModulePath.js";
+// eslint-disable-next-line n/prefer-node-protocol
+import { fileURLToPath } from 'url';
+import { resolveModulePath, resolveModulePaths, resolveImportResult, resolveVariantPaths } from "../loaderUtils/resolveModulePath.js";
 
 /**
  * Node.js filesystem-based directory reader that converts Dirent objects
  * to the DirectoryEntry interface expected by the resolver functions.
+ *
+ * The input is a file:// URL. We convert it to a filesystem path using fileURLToPath.
  */
 var nodeDirectoryReader = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(path) {
-    var entries;
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(fileUrl) {
+    var fsPath, entries;
     return _regenerator().w(function (_context) {
       while (1) switch (_context.n) {
         case 0:
+          // Convert file:// URL to filesystem path for Node.js fs APIs
+          fsPath = fileURLToPath(fileUrl);
           _context.n = 1;
-          return readdir(path, {
+          return readdir(fsPath, {
             withFileTypes: true
           });
         case 1:
@@ -59,7 +65,7 @@ export function resolveModulePathWithFs(_x2) {
  * @returns Promise<Map<string, string>> - Map from input path to resolved file path
  */
 function _resolveModulePathWithFs() {
-  _resolveModulePathWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(modulePath) {
+  _resolveModulePathWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(moduleUrl) {
     var options,
       includeTypeDefs,
       _args2 = arguments;
@@ -68,7 +74,7 @@ function _resolveModulePathWithFs() {
         case 0:
           options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
           includeTypeDefs = _args2.length > 2 ? _args2[2] : undefined;
-          return _context2.a(2, resolveModulePath(modulePath, nodeDirectoryReader, options, includeTypeDefs));
+          return _context2.a(2, resolveModulePath(moduleUrl, nodeDirectoryReader, options, includeTypeDefs));
       }
     }, _callee2);
   }));
@@ -89,14 +95,14 @@ export function resolveModulePathsWithFs(_x3) {
  * @returns Promise<Map<string, string>> - Map from import path to resolved file path
  */
 function _resolveModulePathsWithFs() {
-  _resolveModulePathsWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(modulePaths) {
+  _resolveModulePathsWithFs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(moduleUrls) {
     var options,
       _args3 = arguments;
     return _regenerator().w(function (_context3) {
       while (1) switch (_context3.n) {
         case 0:
           options = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};
-          return _context3.a(2, resolveModulePaths(modulePaths, nodeDirectoryReader, options));
+          return _context3.a(2, resolveModulePaths(moduleUrls, nodeDirectoryReader, options));
       }
     }, _callee3);
   }));

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

@@ -0,0 +1,2 @@
+export { loadServerPageIndex, createLoadServerPageIndex, extractPrefixAndTitle, pathSegmentToTitle, stripTitleMarkdown } from "./loadServerPageIndex.js";
+export type { CreateLoadServerPageIndexOptions, LoadServerPageIndex } from "./loadServerPageIndex.js";

package/esm/pipeline/loadServerPageIndex/index.js

@@ -0,0 +1 @@
+export { loadServerPageIndex, createLoadServerPageIndex, extractPrefixAndTitle, pathSegmentToTitle, stripTitleMarkdown } from "./loadServerPageIndex.js";

package/esm/pipeline/loadServerPageIndex/loadServerPageIndex.d.ts

@@ -0,0 +1,51 @@
+import type { HeadingHierarchy } from "../transformMarkdownMetadata/types.js";
+import type { SitemapSection, SitemapSectionData } from "../../createSitemap/types.js";
+/**
+ * Options for creating a loadServerPageIndex function
+ */
+export interface CreateLoadServerPageIndexOptions {
+  /**
+   * The root context directory for resolving relative paths.
+   * Defaults to process.cwd().
+   */
+  rootContext?: string;
+}
+/**
+ * Function type for loading page index data from a markdown file
+ */
+export type LoadServerPageIndex = (filePath: string) => Promise<SitemapSectionData | null>;
+/**
+ * Converts a path segment to a title
+ * e.g., "docs-infra" -> "Docs Infra", "components" -> "Components"
+ */
+export declare function pathSegmentToTitle(segment: string): string;
+/**
+ * Recursively removes titleMarkdown fields from a heading hierarchy
+ */
+export declare function stripTitleMarkdown(hierarchy: HeadingHierarchy): Record<string, SitemapSection>;
+/**
+ * Extracts prefix and title from an import path
+ * e.g., "/path/to/app/docs-infra/components/page.mdx" -> { prefix: "/docs-infra/components/", title: "Docs Infra Components" }
+ */
+export declare function extractPrefixAndTitle(absolutePath: string, rootContext: string): {
+  prefix: string;
+  title: string;
+};
+/**
+ * Default loadServerPageIndex function that loads page index data from a markdown file.
+ * This function uses process.cwd() as the root context for resolving relative paths.
+ */
+export declare const loadServerPageIndex: LoadServerPageIndex;
+/**
+ * Creates a loadServerPageIndex function with custom options.
+ *
+ * This factory function creates a LoadServerPageIndex implementation that:
+ * 1. Reads the markdown file from the provided file path
+ * 2. Parses the markdown to extract metadata using markdownToMetadata
+ * 3. Enriches the metadata with prefix and title derived from the file path
+ * 4. Returns a SitemapSectionData object with page data
+ *
+ * @param options - Configuration options for the loader
+ * @returns LoadServerPageIndex function that takes a file path and returns Promise<SitemapSectionData | null>
+ */
+export declare function createLoadServerPageIndex(options?: CreateLoadServerPageIndexOptions): LoadServerPageIndex;

package/esm/pipeline/loadServerPageIndex/loadServerPageIndex.js

@@ -0,0 +1,176 @@
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["titleMarkdown", "children"],
+  _excluded2 = ["descriptionMarkdown", "sections"];
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { markdownToMetadata } from "../syncPageIndex/metadataToMarkdown.js";
+
+/**
+ * Options for creating a loadServerPageIndex function
+ */
+
+/**
+ * Function type for loading page index data from a markdown file
+ */
+
+/**
+ * Converts a path segment to a title
+ * e.g., "docs-infra" -> "Docs Infra", "components" -> "Components"
+ */
+export function pathSegmentToTitle(segment) {
+  return segment.split('-').map(function (word) {
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join(' ');
+}
+
+/**
+ * Recursively removes titleMarkdown fields from a heading hierarchy
+ */
+export function stripTitleMarkdown(hierarchy) {
+  var result = {};
+  for (var _i = 0, _Object$entries = Object.entries(hierarchy); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    if (_typeof(value) === 'object' && value !== null) {
+      var titleMarkdown = value.titleMarkdown,
+        children = value.children,
+        rest = _objectWithoutPropertiesLoose(value, _excluded);
+      var strippedChildren = children ? stripTitleMarkdown(children) : {};
+      result[key] = _extends(_extends({}, rest), {}, {
+        // Only include children if it has keys, otherwise set to undefined
+        children: Object.keys(strippedChildren).length > 0 ? strippedChildren : undefined
+      });
+    }
+  }
+  return result;
+}
+
+/**
+ * Extracts prefix and title from an import path
+ * e.g., "/path/to/app/docs-infra/components/page.mdx" -> { prefix: "/docs-infra/components/", title: "Docs Infra Components" }
+ */
+export function extractPrefixAndTitle(absolutePath, rootContext) {
+  // Get the relative path from the root context
+  var relativePath = path.relative(rootContext, absolutePath);
+
+  // Extract the directory path (remove filename)
+  var dirPath = path.dirname(relativePath);
+
+  // Split into segments
+  var allSegments = dirPath.split(path.sep);
+
+  // Filter out segments:
+  // - Remove leading 'src' and 'app' directory markers (only if they're at the start)
+  // - Remove Next.js route groups (segments in parentheses like '(public)')
+  // - Remove current directory markers ('.' and empty strings)
+  var segments = allSegments.filter(function (seg, index) {
+    // Remove 'src' only if it's the first segment
+    if (seg === 'src' && index === 0) {
+      return false;
+    }
+    // Remove 'app' only if it's the first or second segment (after 'src')
+    if (seg === 'app' && (index === 0 || index === 1 && allSegments[0] === 'src')) {
+      return false;
+    }
+    // Filter out Next.js route groups (e.g., '(public)', '(content)')
+    if (seg.startsWith('(') && seg.endsWith(')')) {
+      return false;
+    }
+    // Filter out current directory markers
+    if (seg === '.' || seg === '') {
+      return false;
+    }
+    return true;
+  });
+
+  // Generate prefix with leading and trailing slashes
+  var prefix = segments.length > 0 ? "/".concat(segments.join('/'), "/") : '/';
+
+  // Generate title from path segments
+  var title = segments.map(pathSegmentToTitle).join(' ');
+  return {
+    prefix: prefix,
+    title: title
+  };
+}
+
+/**
+ * Default loadServerPageIndex function that loads page index data from a markdown file.
+ * This function uses process.cwd() as the root context for resolving relative paths.
+ */
+export var loadServerPageIndex = createLoadServerPageIndex();
+
+/**
+ * Creates a loadServerPageIndex function with custom options.
+ *
+ * This factory function creates a LoadServerPageIndex implementation that:
+ * 1. Reads the markdown file from the provided file path
+ * 2. Parses the markdown to extract metadata using markdownToMetadata
+ * 3. Enriches the metadata with prefix and title derived from the file path
+ * 4. Returns a SitemapSectionData object with page data
+ *
+ * @param options - Configuration options for the loader
+ * @returns LoadServerPageIndex function that takes a file path and returns Promise<SitemapSectionData | null>
+ */
+export function createLoadServerPageIndex() {
+  var _options$rootContext;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var rootContext = (_options$rootContext = options.rootContext) != null ? _options$rootContext : process.cwd();
+  return /*#__PURE__*/function () {
+    var _loadPageIndex = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(filePath) {
+      var absolutePath, _extractPrefixAndTitl, prefix, generatedTitle, markdownContent, metadata, enrichedMetadata;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            // Convert file:// URLs to proper file system paths for reading the file
+            // Using fileURLToPath handles Windows drive letters correctly (e.g., file:///C:/... → C:\...)
+            absolutePath = filePath.startsWith('file://') ? fileURLToPath(filePath) : filePath; // Extract prefix and title from the import path
+            _extractPrefixAndTitl = extractPrefixAndTitle(absolutePath, rootContext), prefix = _extractPrefixAndTitl.prefix, generatedTitle = _extractPrefixAndTitl.title; // Read the markdown file
+            _context.n = 1;
+            return fs.readFile(absolutePath, 'utf-8');
+          case 1:
+            markdownContent = _context.v;
+            _context.n = 2;
+            return markdownToMetadata(markdownContent);
+          case 2:
+            metadata = _context.v;
+            if (metadata) {
+              _context.n = 3;
+              break;
+            }
+            return _context.a(2, null);
+          case 3:
+            // Add prefix and override title with the generated one from the path
+            // Strip descriptionMarkdown and titleMarkdown to reduce bundle size
+            enrichedMetadata = _extends(_extends({}, metadata), {}, {
+              prefix: prefix,
+              // Use the generated title from the path (override markdown's H1)
+              title: generatedTitle,
+              // Strip markdown AST fields from each page to reduce size
+              pages: metadata.pages.map(function (page) {
+                var descriptionMarkdown = page.descriptionMarkdown,
+                  sections = page.sections,
+                  pageWithoutMarkdown = _objectWithoutPropertiesLoose(page, _excluded2);
+                return _extends(_extends({}, pageWithoutMarkdown), {}, {
+                  // Strip titleMarkdown from sections hierarchy
+                  sections: sections ? stripTitleMarkdown(sections) : undefined
+                });
+              })
+            });
+            return _context.a(2, enrichedMetadata);
+        }
+      }, _callee);
+    }));
+    function loadPageIndex(_x) {
+      return _loadPageIndex.apply(this, arguments);
+    }
+    return loadPageIndex;
+  }();
+}

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

@@ -0,0 +1,2 @@
+export { loadServerSitemap, createLoadServerSitemap, createSitemapSchema } from "./loadServerSitemap.js";
+export type { CreateLoadServerSitemapOptions, LoadServerSitemap } from "./loadServerSitemap.js";

package/esm/pipeline/loadServerSitemap/index.js

@@ -0,0 +1 @@
+export { loadServerSitemap, createLoadServerSitemap, createSitemapSchema } from "./loadServerSitemap.js";

package/esm/pipeline/loadServerSitemap/loadServerSitemap.d.ts

@@ -0,0 +1,39 @@
+import type { Sitemap } from "../../createSitemap/types.js";
+/**
+ * Options for creating a loadServerSitemap function
+ */
+export interface CreateLoadServerSitemapOptions {
+  /**
+   * The root context directory for resolving relative paths.
+   * Defaults to the directory containing the sitemap index file.
+   */
+  rootContext?: string;
+}
+/**
+ * Function type for loading sitemap data from a sitemap index file URL
+ */
+export type LoadServerSitemap = (url: string) => Promise<Sitemap>;
+/**
+ * Creates the default Orama schema for search indexing.
+ * See: https://docs.orama.com/docs/orama-js/usage/create#schema-properties-and-types
+ */
+export declare function createSitemapSchema(): Sitemap['schema'];
+/**
+ * Default loadServerSitemap function that loads sitemap data from a sitemap index file.
+ * This function parses the sitemap index file to find createSitemap calls and resolves
+ * the page index paths from the imports.
+ */
+export declare const loadServerSitemap: LoadServerSitemap;
+/**
+ * Creates a loadServerSitemap function with custom options.
+ *
+ * This factory function creates a LoadServerSitemap implementation that:
+ * 1. Parses the sitemap index file to find createSitemap calls with page imports
+ * 2. Resolves all page index paths from the imports
+ * 3. Loads each page index using loadServerPageIndex
+ * 4. Returns a Sitemap object with schema and page data
+ *
+ * @param options - Configuration options for the loader
+ * @returns LoadServerSitemap function that takes a file URL and returns Promise<Sitemap>
+ */
+export declare function createLoadServerSitemap(options?: CreateLoadServerSitemapOptions): LoadServerSitemap;