Source Loader

Copyexport function source<Page extends PageData, Meta extends MetaData>(config: {
  pages: VirtualPage<Page>[];
  metas: VirtualMeta<Meta>[];
}): StaticSource<{
  pageData: Page;
  metaData: Meta;
}> {
  return {
    files: [...config.pages, ...config.metas],
  };
}
 
interface SourceUpdater<Config extends SourceConfig> {
  files: <Page extends PageData, Meta extends MetaData>(
    fn: (files: VirtualFile<Config>[]) => (VirtualPage<Page> | VirtualMeta<Meta>)[],
  ) => SourceUpdater<{
    pageData: Page;
    metaData: Meta;
  }>;
  page: <V extends PageData>(
    fn: (page: VirtualPage<Config['pageData']>) => VirtualPage<V>,
  ) => SourceUpdater<{
    pageData: V;
    metaData: Config['metaData'];
  }>;
 
  meta: <V extends MetaData>(
    fn: (meta: VirtualMeta<Config['metaData']>) => VirtualMeta<V>,
  ) => SourceUpdater<{
    pageData: Config['pageData'];
    metaData: V;
  }>;
  build: () => StaticSource<Config>;
}
 
/**
 * update a source object in-place.
 */
export function update<Config extends SourceConfig>(
  source: StaticSource<Config>,
): SourceUpdater<Config> {
  return {
    files(fn) {
      source.files = fn(source.files);
      return this as SourceUpdater<never>;
    },
    page(fn) {
      for (let i = 0; i < source.files.length; i++) {
        const file = source.files[i];
        if (file.type === 'page') source.files[i] = fn(file);
      }
 
      return this as SourceUpdater<never>;
    },
    meta(fn) {
      for (let i = 0; i < source.files.length; i++) {
        const file = source.files[i];
        if (file.type === 'meta') source.files[i] = fn(file);
      }
 
      return this as SourceUpdater<never>;
    },
    build() {
      return source;
    },
  };
}

Copyexport function createContentStorageBuilder(loaderConfig: ResolvedLoaderConfig) {
  const { input, plugins, i18n } = loaderConfig;
 
  let parser: (normalizedPath: string) => [string, (string | string[])?];
  if (!i18n) {
    parser = (path) => [path];
  } else if (i18n.parser === 'dir') {
    const langSet = new Set(i18n.languages);
 
    parser = (path) => {
      const [locale, ...segs] = path.split('/');
      if (!locale || segs.length === 0) return [path];
 
      if (langSet.has(locale)) return [segs.join('/'), locale];
      if (locale === '$') return [segs.join('/'), i18n.languages];
 
      return [path];
    };
  } else {
    const langSet = new Set(i18n.languages);
 
    parser = (path) => {
      const segs = path.split('/');
      const base = segs.pop();
      if (!base) return [path];
 
      const parts = base.split('.');
      if (parts.length < 3) return [path];
 
      const [locale] = parts.splice(parts.length - 2, 1);
      segs.push(parts.join('.'));
 
      if (langSet.has(locale)) return [segs.join('/'), locale];
      if (locale === '$') return [segs.join('/'), i18n.languages];
 
      return [path];
    };
  }

Copyfunction makeStorage(locale: string | typeof EmptyLang, inherit?: ContentStorage) {
  const storage = new FileSystem(inherit) as ContentStorage;
  for (const [storageKey, file] of fileMap.get(locale) ?? []) {
    storage.write(storageKey, file);
  }
 
  const context = { storage };
  for (const plugin of plugins) {
    plugin.transformStorage?.(context);
  }
 
  return storage;
}

Copyasync function resolveSources(skipCache = false): Promise<ResolvedSource> {
  if (isStaticSource(input) || isDynamicSource(input)) {
    return resolveSource(input, skipCache);
  }
 
  const entries = await Promise.all(
    Object.entries(input).map(async ([k, v]) => [k, await resolveSource(v, skipCache)]),
  );
 
  return Object.fromEntries(entries);
}

Copyfunction isEqual(a: ResolvedSource, b: ResolvedSource): boolean {
  if (isStaticSource(a) && isStaticSource(b)) {
    return a === b;
  }
 
  if (!isStaticSource(a) && !isStaticSource(b)) {
    const aKeys = Object.keys(a);
    const bKeys = Object.keys(b);
    return aKeys.length === bKeys.length && aKeys.every((k) => a[k] === b[k]);
  }
 
  return false;
}

Copyexport function loader<I extends ResolvedInput, I18n extends I18nConfig | undefined = undefined>(
  ...args:
    | [
        LoaderOptions & {
          source: I;
        },
      ]
    | [I, LoaderOptions]
): LoaderOutput<{
  meta: GenerateMeta<I>;
  page: GeneratePage<I>;
  i18n: I18n;
}> {
  const loaderConfig =
    args.length === 2 ? resolveConfig(args[0], args[1]) : resolveConfig(args[0].source, args[0]);

CopytransformStorage({ storage }) {
  const indexFiles: string[] = [];
  const taken = new Set<string>();
 
  for (const path of storage.getFiles()) {
    const file = storage.read(path);
    if (!file || file.format !== 'page' || file.slugs) continue;
 
    const customSlugs = slugFn?.(file);
    // for custom slugs function, don't handle conflicting cases like `dir/index.mdx` vs `dir.mdx`
    if (customSlugs === undefined && isIndex(path)) {
      indexFiles.push(path);
      continue;
    }
 
    file.slugs = customSlugs ?? getSlugs(path);
    const key = file.slugs.join('/');
    if (taken.has(key)) throw new Error(`Duplicated slugs: ${key}`);
    taken.add(key);
  }

Copyexport function getSlugs(file: string): string[] {
  const dir = dirname(file);
  const name = basename(file, extname(file));
  const slugs: string[] = [];
 
  for (const seg of dir.split('/')) {
    // filter empty names and file groups like (group_name)
    if (seg.length > 0 && !GroupRegex.test(seg)) slugs.push(encodeURI(seg));
  }
 
  if (GroupRegex.test(name)) throw new Error(`Cannot use folder group in file names: ${file}`);
 
  if (name !== 'index') {
    slugs.push(encodeURI(name));
  }
 
  return slugs;

Copyasync getPages() {
  const files = await glob(include, {
    cwd: dir,
  });
  const chunks: Promise<($Page | $Meta | undefined)[]>[] = [];
 
  for (let i = 0; i < files.length; i += CHUNK_SIZE) {
    const promises: Promise<$Page | $Meta | undefined>[] = [];
    const L = Math.min(files.length, i + CHUNK_SIZE);
 
    for (let j = i; j < L; j++) {
      promises.push(buildFile(files[j]));
    }
 
    chunks.push(Promise.all(promises));
  }
 
  const pages: $Page[] = [];
  const metas: $Meta[] = [];
  for await (const chunk of chunks) {
    for (const item of chunk) {
      if (!item) continue;
      if ('frontmatter' in item) pages.push(item);
      else metas.push(item);
    }
  }
 
  return { pages, metas };
},

Copyasync function md(absolutePath: string, file: string): Promise<$Page> {
  const content = await fs.readFile(absolutePath, 'utf-8');
  const parsed = parseFrontmatter(content);
 
  const frontmatterResult = await frontmatterSchema['~standard'].validate(parsed.data);
  if (frontmatterResult.issues) {
    const message = frontmatterResult.issues
      .map((issue) => (issue.path ? `${issue.path}: ${issue.message}` : issue.message))
      .join('\n');
    throw new Error(`invalid frontmatter in "${absolutePath}": ${message}`);
  }
 
  return {
    path: file,
    absolutePath,
    content: parsed.content,
    frontmatter: frontmatterResult.value,
  };
}

Copyexport function localMd<
  FrontmatterSchema extends StandardSchemaV1 = typeof defaultSchemas.pageSchema,
  MetaSchema extends StandardSchemaV1 = typeof defaultSchemas.metaSchema,
>(
  config: LocalMarkdownConfig<FrontmatterSchema, MetaSchema>,
): LocalMarkdown<FrontmatterSchema, MetaSchema> {
  const storage = createStorage(config);
  const compiler = createMarkdownCompiler(config);
  const compilerCache = new WeakMap<RawPage<unknown>, Promise<CompileResult>>();
  const registeredLoaders = new Set<DynamicLoader>();
  let cachedStaticSource: Promise<
    StaticSource<{
      pageData: LocalMarkdownPage<StandardSchemaV1.InferOutput<FrontmatterSchema>, never>;
      metaData: StandardSchemaV1.InferOutput<MetaSchema> & MetaData;
    }>
  > | null = null;
 
  async function createFiles(options?: SourceOptions) {
    const { metas, pages } = await storage.getPages();
    const baseDir = options?.baseDir;
    const files: VirtualFile<{
      pageData: LocalMarkdownPage<StandardSchemaV1.InferOutput<FrontmatterSchema>, never>;
      metaData: StandardSchemaV1.InferOutput<MetaSchema> & MetaData;
    }>[] = [];
 
    for (const page of pages) {
      const frontmatter = page.frontmatter as PageData & { _openapi?: unknown };
 
      files.push({
        type: 'page',
        path: baseDir ? path.join(baseDir, page.path) : page.path,
        absolutePath: page.absolutePath,
        data: {
          title: frontmatter.title ?? path.basename(page.path, path.extname(page.path)),
          description: frontmatter.description,
          icon: frontmatter.icon,
          // for Fumadocs OpenAPI
          ['_openapi' as never]: frontmatter._openapi,
 
          content: page.content,
          frontmatter: page.frontmatter,
          async load() {
            let promise = compilerCache.get(page);
            if (!promise) {
              promise = compiler.compile({
                path: page.absolutePath,
                value: page.content,
                data: { frontmatter: page.frontmatter },
              });
            }
 
            const res = await promise;
            return res.type === 'ast'
              ? fromAst({
                  tree: res.tree,
                  filePath: res.file.path,
                  rehypeToc: res.file.data.rehypeToc,
                  structuredData: res.file.data.structuredData,
                  ...config.rendererOptions,
                })
              : fromJS({
                  code: res.code,
                  filePath: res.file.path,
                  baseUrl: pathToFileURL(res.file.path).href,
                  structuredData: res.file.data.structuredData,
                });
          },
        },
      });
    }

Copyexport function deserializePageTree(serialized: SerializedPageTree): PageTree.Root {
  const root = serialized.data as PageTree.Root;
  visit(root, (item) => {
    if ('icon' in item && typeof item.icon === 'string') {
      item.icon = (
        <span
          dangerouslySetInnerHTML={{
            __html: item.icon,
          }}
        />
      );
    }
    if (typeof item.name === 'string') {
      item.name = (
        <span
          className="fd-page-tree-item-name"
          dangerouslySetInnerHTML={{
            __html: item.name,
          }}
        />
      );
    }
  });
 
  return root;
}

Copyexport function useFumadocsLoader<V>(serialized: V): Serialized<V> {
  return useMemo(() => {
    const out: Record<string, unknown> = {};
    for (const k in serialized) {
      const v = serialized[k];
      if (isSerializedPageTree(v)) {
        out[k] = deserializePageTree(v);
      } else {
        out[k] = v;
      }
    }
    return out as Serialized<V>;
  }, [serialized]);
}

Copyexport const getSource = revalidable({
  async create(config: ParsedAppConfig) {
    return loader({
      source: source(await getPages(config.content)),
      plugins: [lucideIconsPlugin()],
      baseUrl: '/',
    });
  },
});

Copyexport default async function DocPage({ slugs }: PageProps<'/docs/[...slugs]'>) {
  const config = await getConfigRuntime();
  const source = await getSource(config);
  const page = source.getPage(slugs);
  const mdPreset = config.layout.presets?.md ?? 'docs';
  let mdPresetComponents: MdPresetComponents;
 
  if (mdPreset === 'docs') {
    mdPresetComponents = {
      layout: await import('fumadocs-ui/layouts/docs'),
      page: await import('fumadocs-ui/layouts/docs/page'),
    };
  } else {
    mdPresetComponents = {
      layout: await import('fumadocs-ui/layouts/flux'),
      page: await import('fumadocs-ui/layouts/flux/page'),
    };
  }
 
  return <MdContent slugs={slugs} page={page} components={mdPresetComponents} />;
}