fumadocs-mdx 9.0.4 → 10.0.1

package/bin.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { postInstall } from './dist/next/index.mjs';
+
+void postInstall(process.argv[2]);

package/dist/chunk-LRV535YP.mjs

@@ -0,0 +1,161 @@
+// src/utils/schema.ts
+import { z } from "zod";
+var metaSchema = z.object({
+  title: z.string().optional(),
+  pages: z.array(z.string()).optional(),
+  root: z.boolean().optional(),
+  defaultOpen: z.boolean().optional(),
+  icon: z.string().optional()
+});
+var frontmatterSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  full: z.boolean().optional(),
+  // Fumadocs OpenAPI generated
+  _openapi: z.object({}).passthrough().optional()
+});
+
+// src/config/define.ts
+function defineCollections(options) {
+  return {
+    _doc: "collections",
+    ...options
+  };
+}
+function defineDocs(options) {
+  return {
+    docs: defineCollections({
+      type: "doc",
+      dir: "content/docs",
+      schema: frontmatterSchema,
+      ...options?.docs
+    }),
+    meta: defineCollections({
+      type: "meta",
+      dir: "content/docs",
+      schema: metaSchema,
+      ...options?.meta
+    })
+  };
+}
+function defineConfig(config = {}) {
+  return config;
+}
+
+// src/utils/mdx-options.ts
+import {
+  rehypeCode,
+  remarkGfm,
+  remarkHeading,
+  remarkImage,
+  remarkStructure
+} from "fumadocs-core/mdx-plugins";
+
+// src/mdx-plugins/utils.ts
+import { valueToEstree } from "estree-util-value-to-estree";
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+
+// src/mdx-plugins/remark-exports.ts
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data)) return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
+
+// src/utils/mdx-options.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function getDefaultMDXOptions({
+  valueToExport = [],
+  rehypeCodeOptions,
+  remarkImageOptions,
+  remarkHeadingOptions,
+  remarkStructureOptions,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "toc",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      remarkGfm,
+      [remarkHeading, remarkHeadingOptions],
+      remarkImageOptions !== false && [remarkImage, remarkImageOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        remarkStructure,
+        remarkStructureOptions
+      ],
+      [remarkMdxExport, { values: mdxExports }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [rehypeCode, rehypeCodeOptions],
+      ...v
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+
+export {
+  metaSchema,
+  frontmatterSchema,
+  defineCollections,
+  defineDocs,
+  defineConfig,
+  getDefaultMDXOptions
+};

package/dist/chunk-P6WKCOD5.mjs

@@ -0,0 +1,139 @@
+// src/config/cached.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+
+// src/config/load.ts
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { build } from "esbuild";
+
+// src/config/validate.ts
+function validateConfig(config) {
+  const out = {
+    collections: /* @__PURE__ */ new Map(),
+    _runtime: {
+      files: /* @__PURE__ */ new Map()
+    }
+  };
+  for (const [k, v] of Object.entries(config)) {
+    if (!v) {
+      continue;
+    }
+    if (typeof v === "object" && "_doc" in v && v._doc === "collections") {
+      out.collections.set(k, v);
+      continue;
+    }
+    if (k === "default") {
+      out.global = v;
+      continue;
+    }
+    return [
+      `Unknown export "${k}", you can only export collections from source configuration file.`,
+      null
+    ];
+  }
+  return [null, out];
+}
+
+// src/config/load.ts
+function findConfigFile() {
+  return path.resolve("source.config.ts");
+}
+async function loadConfig(configPath) {
+  const outputPath = path.resolve(".source/source.config.mjs");
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: ".source",
+    target: "node18",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true,
+    splitting: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+  const url = pathToFileURL(outputPath);
+  const [err, config] = validateConfig(
+    // every call to `loadConfig` will cause the previous cache to be ignored
+    await import(`${url.toString()}?hash=${Date.now().toString()}`)
+  );
+  if (err !== null) throw new Error(err);
+  return config;
+}
+
+// src/config/cached.ts
+var cache = /* @__PURE__ */ new Map();
+async function loadConfigCached(configPath, hash) {
+  const cached = cache.get(configPath);
+  if (cached && cached.hash === hash) {
+    return await cached.config;
+  }
+  const config = loadConfig(configPath);
+  cache.set(configPath, { config, hash });
+  return await config;
+}
+async function getConfigHash(configPath) {
+  const hash = createHash("sha256");
+  const rs = fs.createReadStream(configPath);
+  for await (const chunk of rs) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+
+// src/map/manifest.ts
+import fs2 from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import path2 from "node:path";
+
+// src/utils/get-type-from-path.ts
+import { extname } from "node:path";
+var docTypes = [".mdx", ".md"];
+var metaTypes = [".json", ".yaml"];
+function getTypeFromPath(path3) {
+  const ext = extname(path3);
+  if (docTypes.includes(ext)) return "doc";
+  if (metaTypes.includes(ext)) return "meta";
+}
+
+// src/map/manifest.ts
+function getKey(key) {
+  return createHash2("sha256").update(key).digest("hex");
+}
+function writeManifest(to, config) {
+  const output = { files: [] };
+  for (const [file, collection] of config._runtime.files.entries()) {
+    const type = config.collections.get(collection)?.type ?? getTypeFromPath(file);
+    if (type === "meta") continue;
+    try {
+      const content = fs2.readFileSync(
+        path2.resolve(".next/cache/fumadocs", `${getKey(file)}.json`)
+      );
+      const meta = JSON.parse(content.toString());
+      output.files.push({
+        ...meta,
+        collection
+      });
+    } catch (e) {
+      console.error(`cannot find the search index of ${file}`, e);
+    }
+  }
+  fs2.writeFileSync(to, JSON.stringify(output));
+}
+
+export {
+  findConfigFile,
+  loadConfig,
+  loadConfigCached,
+  getConfigHash,
+  getTypeFromPath,
+  getKey,
+  writeManifest
+};

package/dist/config/index.d.mts

@@ -0,0 +1,171 @@
+import { z, ZodTypeAny } from 'zod';
+import { MDXProps } from 'mdx/types';
+import { StructureOptions, RemarkHeadingOptions, RemarkImageOptions, RehypeCodeOptions, StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TableOfContents } from 'fumadocs-core/server';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { Pluggable } from 'unified';
+
+interface MDXOptions extends ProcessorOptions {
+    /**
+     * Name of collection
+     */
+    collection?: string;
+    /**
+     * Specify a file path for source
+     */
+    filePath?: string;
+    frontmatter?: Record<string, unknown>;
+    /**
+     * Custom Vfile data
+     */
+    data?: Record<string, unknown>;
+}
+
+declare const metaSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    root: z.ZodOptional<z.ZodBoolean>;
+    defaultOpen: z.ZodOptional<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    pages?: string[] | undefined;
+    root?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    icon?: string | undefined;
+}, {
+    title?: string | undefined;
+    pages?: string[] | undefined;
+    root?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    icon?: string | undefined;
+}>;
+declare const frontmatterSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+    _openapi: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    icon?: string | undefined;
+    description?: string | undefined;
+    full?: boolean | undefined;
+    _openapi?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    title: string;
+    icon?: string | undefined;
+    description?: string | undefined;
+    full?: boolean | undefined;
+    _openapi?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
+
+interface TransformContext {
+    path: string;
+    source: string;
+    /**
+     * Compile MDX to JavaScript
+     */
+    buildMDX: (source: string, options?: ProcessorOptions) => Promise<string>;
+}
+interface Collections<Schema extends ZodTypeAny = ZodTypeAny, Type extends SupportedType = SupportedType, Output extends BaseCollectionEntry = CollectionEntry<Type, z.output<Schema>>> {
+    /**
+     * Directories to scan
+     */
+    dir: string | string[];
+    /**
+     * what files to include/exclude (glob patterns)
+     *
+     * Include all files if not specified
+     */
+    files?: string[];
+    schema?: Schema | ((ctx: TransformContext) => Schema);
+    /**
+     * content type
+     */
+    type: Type;
+    /**
+     * Do transformation in runtime.
+     *
+     * This cannot be optimized by bundlers/loaders, avoid expensive calculations here.
+     */
+    transform?: (entry: CollectionEntry<Type, z.output<Schema>>, globalConfig?: GlobalConfig) => Output | Promise<Output>;
+    mdxOptions?: Type extends 'doc' ? MDXOptions : never;
+}
+declare function defineCollections<Schema extends ZodTypeAny, Type extends SupportedType, Output extends BaseCollectionEntry = CollectionEntry<Type, z.output<Schema>>>(options: Collections<Schema, Type, Output>): {
+    _doc: 'collections';
+} & Collections<Schema, Type, Output>;
+declare function defineDocs<F extends ZodTypeAny = typeof frontmatterSchema, M extends ZodTypeAny = typeof metaSchema, DocsOut extends BaseCollectionEntry = CollectionEntry<'doc', z.output<F>>, MetaOut extends BaseCollectionEntry = CollectionEntry<'meta', z.output<M>>>(options?: {
+    docs?: Partial<Collections<F, 'doc', DocsOut>>;
+    meta?: Partial<Collections<M, 'meta', MetaOut>>;
+}): {
+    docs: Collections<F, 'doc', DocsOut>;
+    meta: Collections<M, 'meta', MetaOut>;
+};
+declare function defineConfig(config?: GlobalConfig): GlobalConfig;
+
+type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
+type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    remarkStructureOptions?: StructureOptions | false;
+    remarkHeadingOptions?: RemarkHeadingOptions;
+    remarkImageOptions?: RemarkImageOptions | false;
+    rehypeCodeOptions?: RehypeCodeOptions | false;
+};
+declare function getDefaultMDXOptions({ valueToExport, rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, ...mdxOptions }: DefaultMDXOptions): ProcessorOptions;
+
+interface GlobalConfig {
+    /**
+     * Configure global MDX options
+     */
+    mdxOptions?: DefaultMDXOptions;
+    /**
+     * Fetch last modified time with specified version control
+     * @defaultValue 'none'
+     */
+    lastModifiedTime?: 'git' | 'none';
+    /**
+     * Generate manifest file on build mode
+     *
+     * @defaultValue false
+     */
+    generateManifest?: boolean;
+}
+type InferSchema<C> = C extends Collections<infer Schema, any, any> ? Schema : never;
+type InferSchemaType<C> = z.output<InferSchema<C>>;
+type InferCollectionsProps<C> = SupportedTypes[C extends Collections<any, infer Type, any> ? Type : never];
+interface FileInfo {
+    path: string;
+    absolutePath: string;
+}
+interface MarkdownProps {
+    body: (props: MDXProps) => React.ReactElement;
+    structuredData: StructuredData;
+    toc: TableOfContents;
+    _exports: Record<string, unknown>;
+    /**
+     * Only available when `lastModifiedTime` is enabled on MDX loader
+     */
+    lastModified?: Date;
+}
+interface SupportedTypes {
+    meta: {};
+    doc: MarkdownProps;
+}
+type SupportedType = keyof SupportedTypes;
+type CollectionEntry<Type extends SupportedType, Output> = Omit<SupportedTypes[Type], keyof Output> & Output & BaseCollectionEntry;
+interface BaseCollectionEntry {
+    _file: FileInfo;
+}
+type EntryFromCollection<C> = C extends Collections<any, any, infer Output> ? Output : never;
+/**
+ * Get output type of collections
+ */
+type GetOutput<C> = EntryFromCollection<C>[];
+
+export { type BaseCollectionEntry, type CollectionEntry, type Collections, type DefaultMDXOptions, type EntryFromCollection, type FileInfo, type GetOutput, type GlobalConfig, type InferCollectionsProps, type InferSchema, type InferSchemaType, type SupportedType, type SupportedTypes, type TransformContext, defineCollections, defineConfig, defineDocs, frontmatterSchema, getDefaultMDXOptions, metaSchema };

package/dist/config/index.mjs

@@ -0,0 +1,16 @@
+import {
+  defineCollections,
+  defineConfig,
+  defineDocs,
+  frontmatterSchema,
+  getDefaultMDXOptions,
+  metaSchema
+} from "../chunk-LRV535YP.mjs";
+export {
+  defineCollections,
+  defineConfig,
+  defineDocs,
+  frontmatterSchema,
+  getDefaultMDXOptions,
+  metaSchema
+};

package/dist/index.d.mts

@@ -1,97 +1,24 @@
-import { MetaData, PageData, Source } from 'fumadocs-core/source';
-import { z } from 'zod';
-import { MDXProps } from 'mdx/types';
-import { StructuredData } from 'fumadocs-core/mdx-plugins';
-import { TableOfContents } from 'fumadocs-core/server';
-export { S as SearchIndex } from './search-index-plugin-DG9nZ1CX.mjs';
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import { SupportedType, FileInfo, EntryFromCollection, Collections, CollectionEntry } from './config/index.mjs';
+import { MetaFile } from './loader-mdx.mjs';
+import 'zod';
+import 'mdx/types';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/server';
+import '@mdx-js/mdx';
+import 'unified';
+import 'webpack';
 
-declare const defaultSchemas: {
-    frontmatter: z.ZodObject<{
-        title: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        icon: z.ZodOptional<z.ZodString>;
-        full: z.ZodOptional<z.ZodBoolean>;
-        _openapi: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, "strip", z.ZodTypeAny, {
-        title: string;
-        description?: string | undefined;
-        icon?: string | undefined;
-        full?: boolean | undefined;
-        _openapi?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        title: string;
-        description?: string | undefined;
-        icon?: string | undefined;
-        full?: boolean | undefined;
-        _openapi?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }>;
-    meta: z.ZodObject<{
-        title: z.ZodOptional<z.ZodString>;
-        pages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        root: z.ZodOptional<z.ZodBoolean>;
-        defaultOpen: z.ZodOptional<z.ZodBoolean>;
-        icon: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        title?: string | undefined;
-        pages?: string[] | undefined;
-        root?: boolean | undefined;
-        defaultOpen?: boolean | undefined;
-        icon?: string | undefined;
-    }, {
-        title?: string | undefined;
-        pages?: string[] | undefined;
-        root?: boolean | undefined;
-        defaultOpen?: boolean | undefined;
-        icon?: string | undefined;
-    }>;
-};
-
-type SourceFile<Meta extends MetaData, Fronmatter extends PageData> = {
-    type: 'meta';
-    path: string;
-    data: Meta;
-} | {
-    type: 'page';
-    path: string;
-    data: MDXPageData<Fronmatter>;
-};
-/**
- * Defalt MDX properties
- */
-interface MDXExport<Frontmatter = PageData> {
-    default: (props: MDXProps) => React.ReactElement;
-    frontmatter: Frontmatter;
-    lastModified: number | undefined;
-    toc: TableOfContents;
-    structuredData: StructuredData;
-}
-type MDXPageData<Frontmatter extends PageData = PageData> = Omit<Frontmatter, 'exports'> & {
-    exports: Omit<MDXExport<Frontmatter>, 'frontmatter'>;
-};
-interface InternalFrontmatter {
-    _mdx?: {
-        /**
-         * Mirror another MDX file
-         */
-        mirror?: string;
-    };
-}
+declare function toRuntime(type: SupportedType, file: Record<string, unknown>, info: FileInfo): EntryFromCollection<Collections>;
+declare function createMDXSource<Doc extends CollectionEntry<'doc', PageData>, Meta extends CollectionEntry<'meta', MetaData>>(docs: Doc[], meta: Meta[]): Source<{
+    pageData: Doc;
+    metaData: Meta;
+}>;
 
-interface SourceOptions<Frontmatter, Meta> {
-    schema?: {
-        frontmatter?: Frontmatter;
-        meta?: Meta;
-    };
-}
-interface LoadOptions<Frontmatter, Meta> extends SourceOptions<Frontmatter, Meta> {
-    rootDir?: string;
+interface Manifest {
+    files: (MetaFile & {
+        collection: string;
+    })[];
 }
-type DefaultFrontmatter = (typeof defaultSchemas)['frontmatter'];
-type DefaultMeta = (typeof defaultSchemas)['meta'];
-declare function createMDXSource<Frontmatter extends DefaultFrontmatter = DefaultFrontmatter, Meta extends DefaultMeta = DefaultMeta>(map: Record<string, unknown>, options?: SourceOptions<Frontmatter, Meta>): Source<{
-    metaData: z.infer<Meta>;
-    pageData: MDXPageData<z.infer<Frontmatter>>;
-}>;
-declare function loadMDXSource<Frontmatter extends DefaultFrontmatter = DefaultFrontmatter, Meta extends DefaultMeta = DefaultMeta>(map: Record<string, unknown>, options?: LoadOptions<Frontmatter, Meta>): SourceFile<z.infer<Meta>, z.infer<Frontmatter>>[];
 
-export { type InternalFrontmatter, type MDXExport, type MDXPageData, type SourceFile, createMDXSource, defaultSchemas, loadMDXSource };
+export { type Manifest, createMDXSource, toRuntime };