fumadocs-core 13.4.9 → 14.0.0

package/dist/search/server.js

@@ -1,13 +1,23 @@
+import {
+  searchAdvanced,
+  searchSimple
+} from "../chunk-2ZSMGYVH.js";
+import "../chunk-2V6SCS43.js";
 import "../chunk-MLKGABMK.js";
 
 // src/search/server.ts
-import { Document } from "flexsearch";
+import {
+  save
+} from "@orama/orama";
 
 // src/search/create-endpoint.ts
 function createEndpoint(server) {
   const { search } = server;
   return {
-    search,
+    ...server,
+    async staticGET() {
+      return Response.json(await server.export());
+    },
     async GET(request) {
       const query = request.nextUrl.searchParams.get("query");
       if (!query) return Response.json([]);
@@ -21,70 +31,257 @@ function createEndpoint(server) {
   };
 }
 
-// src/search/i18n-api.ts
-function createI18nSearchAPI(type, options) {
-  const map = /* @__PURE__ */ new Map();
-  async function init() {
-    if (options.i18n.languages.length === 0) {
-      return;
+// src/search/create-db.ts
+import {
+  create,
+  insertMultiple
+} from "@orama/orama";
+var advancedSchema = {
+  content: "string",
+  page_id: "string",
+  type: "string",
+  keywords: "string",
+  tag: "string",
+  url: "string"
+};
+async function createDB({
+  indexes,
+  tokenizer,
+  search: _,
+  ...rest
+}) {
+  const items = typeof indexes === "function" ? await indexes() : indexes;
+  const db = create({
+    ...rest,
+    schema: advancedSchema,
+    components: {
+      tokenizer
     }
-    const indexes = typeof options.indexes === "function" ? await options.indexes() : options.indexes;
-    for (const locale of options.i18n.languages) {
-      const localeIndexes = indexes.filter((index) => index.locale === locale);
-      if (type === "simple") {
-        map.set(
-          locale,
-          initSimpleSearch({
-            ...options,
-            language: locale,
-            indexes: localeIndexes
-          })
-        );
-        continue;
-      }
-      map.set(
-        locale,
-        initAdvancedSearch({
-          ...options,
-          language: locale,
-          indexes: localeIndexes
-        })
-      );
+  });
+  const mapTo = [];
+  items.forEach((page) => {
+    const data = page.structuredData;
+    let id = 0;
+    mapTo.push({
+      id: page.id,
+      page_id: page.id,
+      type: "page",
+      content: page.title,
+      keywords: page.keywords,
+      tag: page.tag,
+      url: page.url
+    });
+    if (page.description) {
+      mapTo.push({
+        id: `${page.id}-${(id++).toString()}`,
+        page_id: page.id,
+        tag: page.tag,
+        type: "text",
+        url: page.url,
+        content: page.description
+      });
     }
-  }
-  return createEndpoint({
-    search: async (query, searchOptions) => {
-      if (map.size === 0) await init();
-      const handler = map.get(
-        searchOptions?.locale ?? options.i18n.defaultLanguage
-      );
-      if (handler) return handler.search(query, searchOptions);
-      return [];
+    for (const heading of data.headings) {
+      mapTo.push({
+        id: `${page.id}-${(id++).toString()}`,
+        page_id: page.id,
+        type: "heading",
+        tag: page.tag,
+        url: `${page.url}#${heading.id}`,
+        content: heading.content
+      });
+    }
+    for (const content of data.contents) {
+      mapTo.push({
+        id: `${page.id}-${(id++).toString()}`,
+        page_id: page.id,
+        tag: page.tag,
+        type: "text",
+        url: content.heading ? `${page.url}#${content.heading}` : page.url,
+        content: content.content
+      });
+    }
+  });
+  await insertMultiple(db, mapTo);
+  return db;
+}
+
+// src/search/create-db-simple.ts
+import {
+  create as create2,
+  insertMultiple as insertMultiple2
+} from "@orama/orama";
+async function createDBSimple({
+  indexes,
+  language
+}) {
+  const items = typeof indexes === "function" ? await indexes() : indexes;
+  const db = create2({
+    language,
+    schema: {
+      url: "string",
+      title: "string",
+      description: "string",
+      content: "string",
+      keywords: "string"
     }
   });
+  await insertMultiple2(
+    db,
+    items.map((page) => ({
+      title: page.title,
+      description: page.description,
+      url: page.url,
+      content: page.content,
+      keywords: page.keywords
+    }))
+  );
+  return db;
+}
+
+// src/search/create-from-source.ts
+function defaultToIndex(page) {
+  if (!("structuredData" in page.data)) {
+    throw new Error(
+      "Cannot find structured data from page, please define the page to index function."
+    );
+  }
+  return {
+    title: page.data.title,
+    description: "description" in page.data ? page.data.description : void 0,
+    url: page.url,
+    id: page.url,
+    structuredData: page.data.structuredData
+  };
+}
+function createFromSource(source, pageToIndex = defaultToIndex, options = {}) {
+  if (source._i18n) {
+    return createI18nSearchAPI("advanced", {
+      ...options,
+      i18n: source._i18n,
+      indexes: source.getLanguages().flatMap((entry) => {
+        return entry.pages.map((page) => {
+          return {
+            ...pageToIndex(page),
+            locale: entry.language
+          };
+        });
+      })
+    });
+  }
+  return createSearchAPI("advanced", {
+    ...options,
+    indexes: source.getPages().map((page) => {
+      return pageToIndex(page);
+    })
+  });
 }
 
-// src/search/legacy-i18n-api.ts
-function createI18nSearchAPI2(type, options) {
+// src/search/_stemmers.ts
+var STEMMERS = {
+  arabic: "ar",
+  armenian: "am",
+  bulgarian: "bg",
+  danish: "dk",
+  dutch: "nl",
+  english: "en",
+  finnish: "fi",
+  french: "fr",
+  german: "de",
+  greek: "gr",
+  hungarian: "hu",
+  indian: "in",
+  indonesian: "id",
+  irish: "ie",
+  italian: "it",
+  lithuanian: "lt",
+  nepali: "np",
+  norwegian: "no",
+  portuguese: "pt",
+  romanian: "ro",
+  russian: "ru",
+  serbian: "rs",
+  slovenian: "ru",
+  spanish: "es",
+  swedish: "se",
+  tamil: "ta",
+  turkish: "tr",
+  ukrainian: "uk",
+  sanskrit: "sk"
+};
+
+// src/search/i18n-api.ts
+function defaultLocaleMap(locale) {
+  const map = STEMMERS;
+  return Object.keys(map).find((lang) => map[lang] === locale) ?? locale;
+}
+async function initSimple(options) {
+  const map = /* @__PURE__ */ new Map();
+  if (options.i18n.languages.length === 0) {
+    return map;
+  }
+  const indexes = typeof options.indexes === "function" ? await options.indexes() : options.indexes;
+  for (const locale of options.i18n.languages) {
+    const localeIndexes = indexes.filter((index) => index.locale === locale);
+    const searchLocale = options.localeMap?.[locale] ?? defaultLocaleMap(locale);
+    map.set(
+      locale,
+      typeof searchLocale === "object" ? initSimpleSearch({
+        ...options,
+        ...searchLocale,
+        indexes: localeIndexes
+      }) : initSimpleSearch({
+        ...options,
+        language: searchLocale,
+        indexes: localeIndexes
+      })
+    );
+  }
+  return map;
+}
+async function initAdvanced(options) {
   const map = /* @__PURE__ */ new Map();
-  for (const entry of options.indexes) {
-    const v = Array.isArray(entry) ? { language: entry[0], indexes: entry[1] } : entry;
+  if (options.i18n.languages.length === 0) {
+    return map;
+  }
+  const indexes = typeof options.indexes === "function" ? await options.indexes() : options.indexes;
+  for (const locale of options.i18n.languages) {
+    const localeIndexes = indexes.filter((index) => index.locale === locale);
+    const searchLocale = options.localeMap?.[locale] ?? defaultLocaleMap(locale);
     map.set(
-      v.language,
-      // @ts-expect-error -- Index depends on generic types
-      createSearchAPI(type, {
+      locale,
+      typeof searchLocale === "object" ? initAdvancedSearch({
+        ...options,
+        indexes: localeIndexes,
+        ...searchLocale
+      }) : initAdvancedSearch({
         ...options,
-        language: v.language,
-        indexes: v.indexes
+        language: searchLocale,
+        indexes: localeIndexes
       })
     );
   }
+  return map;
+}
+function createI18nSearchAPI(type, options) {
+  const get = type === "simple" ? initSimple(options) : initAdvanced(options);
   return createEndpoint({
+    async export() {
+      const map = await get;
+      const entries = Object.entries(map).map(async ([k, v]) => [
+        k,
+        await v.export()
+      ]);
+      return {
+        type: "i18n",
+        data: Object.fromEntries(await Promise.all(entries))
+      };
+    },
     search: async (query, searchOptions) => {
-      if (searchOptions?.locale) {
-        const handler = map.get(searchOptions.locale);
-        if (handler) return handler.search(query, searchOptions);
-      }
+      const map = await get;
+      const locale = searchOptions?.locale ?? options.i18n.defaultLanguage;
+      const handler = map.get(locale);
+      if (handler) return handler.search(query, searchOptions);
       return [];
     }
   });
@@ -97,198 +294,39 @@ function createSearchAPI(type, options) {
   }
   return createEndpoint(initAdvancedSearch(options));
 }
-function initSimpleSearch({
-  indexes,
-  language
-}) {
-  const store = ["title", "url"];
-  async function getDocument() {
-    const items = typeof indexes === "function" ? await indexes() : indexes;
-    const index = new Document({
-      language,
-      optimize: true,
-      cache: 100,
-      document: {
-        id: "url",
-        store,
-        index: [
-          {
-            field: "title",
-            tokenize: "forward",
-            resolution: 9
-          },
-          {
-            field: "description",
-            tokenize: "strict",
-            context: {
-              depth: 1,
-              resolution: 9
-            }
-          },
-          {
-            field: "content",
-            tokenize: "strict",
-            context: {
-              depth: 1,
-              resolution: 9
-            }
-          },
-          {
-            field: "keywords",
-            tokenize: "strict",
-            resolution: 9
-          }
-        ]
-      }
-    });
-    for (const page of items) {
-      index.add({
-        title: page.title,
-        description: page.description,
-        url: page.url,
-        content: page.content,
-        keywords: page.keywords
-      });
-    }
-    return index;
-  }
-  const doc = getDocument();
+function initSimpleSearch(options) {
+  const doc = createDBSimple(options);
   return {
+    async export() {
+      return {
+        type: "simple",
+        ...save(await doc)
+      };
+    },
     search: async (query) => {
-      const results = (await doc).search(query, 5, {
-        enrich: true,
-        suggest: true
-      });
-      if (results.length === 0) return [];
-      return results[0].result.map((page) => ({
-        type: "page",
-        content: page.doc.title,
-        id: page.doc.url,
-        url: page.doc.url
-      }));
+      const db = await doc;
+      return searchSimple(db, query, options.search);
     }
   };
 }
-function initAdvancedSearch({
-  indexes,
-  language,
-  tag = false
-}) {
-  const store = ["id", "url", "content", "page_id", "type", "keywords"];
-  async function getDocument() {
-    const items = typeof indexes === "function" ? await indexes() : indexes;
-    const index = new Document({
-      language,
-      cache: 100,
-      optimize: true,
-      document: {
-        id: "id",
-        tag: tag ? "tag" : void 0,
-        store,
-        index: [
-          {
-            field: "content",
-            tokenize: "forward",
-            context: { depth: 2, bidirectional: true, resolution: 9 }
-          },
-          {
-            field: "keywords",
-            tokenize: "strict",
-            resolution: 9
-          }
-        ]
-      }
-    });
-    for (const page of items) {
-      const data = page.structuredData;
-      let id = 0;
-      index.add({
-        id: page.id,
-        page_id: page.id,
-        type: "page",
-        content: page.title,
-        keywords: page.keywords,
-        tag: page.tag,
-        url: page.url
-      });
-      if (page.description) {
-        index.add({
-          id: page.id + (id++).toString(),
-          page_id: page.id,
-          tag: page.tag,
-          type: "text",
-          url: page.url,
-          content: page.description
-        });
-      }
-      for (const heading of data.headings) {
-        index.add({
-          id: page.id + (id++).toString(),
-          page_id: page.id,
-          type: "heading",
-          tag: page.tag,
-          url: `${page.url}#${heading.id}`,
-          content: heading.content
-        });
-      }
-      for (const content of data.contents) {
-        index.add({
-          id: page.id + (id++).toString(),
-          page_id: page.id,
-          tag: page.tag,
-          type: "text",
-          url: content.heading ? `${page.url}#${content.heading}` : page.url,
-          content: content.content
-        });
-      }
-    }
-    return index;
-  }
-  const doc = getDocument();
+function initAdvancedSearch(options) {
+  const get = createDB(options);
   return {
-    search: async (query, options) => {
-      const index = await doc;
-      const results = index.search(query, 5, {
-        enrich: true,
-        tag: options?.tag,
-        limit: 6
-      });
-      const map = /* @__PURE__ */ new Map();
-      for (const item of results[0]?.result ?? []) {
-        if (item.doc.type === "page") {
-          if (!map.has(item.doc.id)) {
-            map.set(item.doc.id, []);
-          }
-          continue;
-        }
-        const list = map.get(item.doc.page_id) ?? [];
-        list.push({
-          id: item.doc.id,
-          content: item.doc.content,
-          type: item.doc.type,
-          url: item.doc.url
-        });
-        map.set(item.doc.page_id, list);
-      }
-      const sortedResult = [];
-      for (const [id, items] of map.entries()) {
-        const page = index.get(id);
-        if (!page) continue;
-        sortedResult.push({
-          id: page.id,
-          content: page.content,
-          type: "page",
-          url: page.url
-        });
-        sortedResult.push(...items);
-      }
-      return sortedResult;
+    async export() {
+      return {
+        type: "advanced",
+        ...save(await get)
+      };
+    },
+    search: async (query, searchOptions) => {
+      const db = await get;
+      return searchAdvanced(db, query, searchOptions?.tag, options.search);
     }
   };
 }
 export {
-  createI18nSearchAPI2 as createI18nSearchAPI,
-  createI18nSearchAPI as createI18nSearchAPIExperimental,
+  createFromSource,
+  createI18nSearchAPI,
   createSearchAPI,
   initAdvancedSearch,
   initSimpleSearch

package/dist/server/index.d.ts

@@ -1,8 +1,12 @@
 export { a as TOCItemType, T as TableOfContents, g as getTableOfContents } from '../get-toc-CM4X3hbw.js';
-import { N as Node, I as Item, R as Root } from '../page-tree-BTCDMLTU.js';
-export { p as PageTree } from '../page-tree-BTCDMLTU.js';
-export { SortedResult } from '../search/shared.js';
+import { N as Node, I as Item, R as Root } from '../page-tree-r8qjoUla.js';
+export { p as PageTree } from '../page-tree-r8qjoUla.js';
+export { S as SortedResult } from '../types-Ch8gnVgO.js';
+import { Metadata } from 'next';
+import { NextRequest } from 'next/server';
+import { LoaderOutput, LoaderConfig, InferPageType } from '../source/index.js';
 import 'react';
+import '../config-inq6kP6y.js';
 
 /**
  * Flatten tree to an array of page nodes
@@ -53,4 +57,52 @@ interface GetGithubLastCommitOptions {
  */
 declare function getGithubLastEdit({ repo, token, owner, path, sha, options, params: customParams, }: GetGithubLastCommitOptions): Promise<Date | null>;
 
-export { type GetGithubLastCommitOptions, findNeighbour, flattenTree, getGithubLastEdit, separatePageTree };
+interface ImageMeta {
+    alt: string;
+    url: string;
+    width: number;
+    height: number;
+}
+declare function createMetadataImage<S extends LoaderOutput<LoaderConfig>>(options: {
+    source: S;
+    /**
+     * the route of your OG image generator.
+     *
+     * @example '/docs-og'
+     * @defaultValue '/docs-og'
+     */
+    imageRoute?: string;
+    /**
+     * The filename of generated OG Image
+     *
+     * @defaultValue 'image.png'
+     */
+    filename?: string;
+}): {
+    getImageMeta: (slugs: string[]) => ImageMeta;
+    /**
+     * Add image meta tags to metadata
+     */
+    withImage: (slugs: string[], metadata?: Metadata) => Metadata;
+    /**
+     * Generate static params for OG Image Generator
+     */
+    generateParams: () => {
+        slug: string[];
+        lang?: string;
+    }[];
+    /**
+     * create route handler for OG Image Generator
+     */
+    createAPI: (handler: (page: InferPageType<S>, request: NextRequest, options: {
+        params: {
+            slug: string[];
+            lang?: string;
+        } | Promise<{
+            slug: string[];
+            lang?: string;
+        }>;
+    }) => Response | Promise<Response>) => (request: NextRequest, options: any) => Response | Promise<Response>;
+};
+
+export { type GetGithubLastCommitOptions, createMetadataImage, findNeighbour, flattenTree, getGithubLastEdit, separatePageTree };

package/dist/server/index.js

@@ -1,6 +1,6 @@
 import {
   remarkHeading
-} from "../chunk-UQV4A7HQ.js";
+} from "../chunk-4MNUWZIW.js";
 import "../chunk-MLKGABMK.js";
 
 // src/server/get-toc.ts
@@ -87,8 +87,66 @@ async function getGithubLastEdit({
   if (data.length === 0) return null;
   return new Date(data[0].commit.committer.date);
 }
+
+// src/server/metadata.ts
+import { notFound } from "next/navigation";
+function createMetadataImage(options) {
+  const { filename = "image.png", imageRoute = "/docs-og" } = options;
+  function getImageMeta(slugs) {
+    return {
+      alt: "Banner",
+      url: `/${[...imageRoute.split("/"), ...slugs, filename].filter((v) => v.length > 0).join("/")}`,
+      width: 1200,
+      height: 630
+    };
+  }
+  return {
+    getImageMeta,
+    withImage(slugs, data) {
+      const imageData = getImageMeta(slugs);
+      return {
+        ...data,
+        openGraph: {
+          images: imageData,
+          ...data?.openGraph
+        },
+        twitter: {
+          images: imageData,
+          card: "summary_large_image",
+          ...data?.twitter
+        }
+      };
+    },
+    generateParams() {
+      return options.source.generateParams().map((params) => ({
+        ...params,
+        slug: [...params.slug, filename]
+      }));
+    },
+    createAPI(handler) {
+      return async (req, args) => {
+        const params = await args.params;
+        if (!params || !("slug" in params) || params.slug === void 0)
+          throw new Error(`Invalid params: ${JSON.stringify(params)}`);
+        const lang = "lang" in params && typeof params.lang === "string" ? params.lang : void 0;
+        const input = {
+          slug: Array.isArray(params.slug) ? params.slug : [params.slug],
+          lang
+        };
+        const page = options.source.getPage(
+          input.slug.slice(0, -1),
+          //remove filename
+          lang
+        );
+        if (!page) notFound();
+        return handler(page, req, { params: input });
+      };
+    }
+  };
+}
 export {
   page_tree_exports as PageTree,
+  createMetadataImage,
   findNeighbour,
   flattenTree,
   getGithubLastEdit,