@hanzo/docs-core 16.2.5

package/dist/search/server.js

@@ -0,0 +1,400 @@
+import {
+  searchAdvanced,
+  searchSimple
+} from "../chunk-XOFXGHS4.js";
+import "../chunk-ZMWYLUDP.js";
+import {
+  basename,
+  extname
+} from "../chunk-XZSI7AHE.js";
+import {
+  createContentHighlighter
+} from "../chunk-OTD7MV33.js";
+import {
+  findPath
+} from "../chunk-L4JKQWCM.js";
+import "../chunk-U67V476Y.js";
+
+// src/search/server.ts
+import {
+  save
+} from "@orama/orama";
+
+// src/search/orama/create-endpoint.ts
+function createEndpoint(server) {
+  const { search } = server;
+  return {
+    ...server,
+    async staticGET() {
+      return Response.json(await server.export());
+    },
+    async GET(request) {
+      const url = new URL(request.url);
+      const query = url.searchParams.get("query");
+      if (!query) return Response.json([]);
+      return Response.json(
+        await search(query, {
+          tag: url.searchParams.get("tag")?.split(",") ?? void 0,
+          locale: url.searchParams.get("locale") ?? void 0,
+          mode: url.searchParams.get("mode") === "vector" ? "vector" : "full"
+        })
+      );
+    }
+  };
+}
+
+// src/search/orama/create-db.ts
+import {
+  create,
+  insertMultiple
+} from "@orama/orama";
+var simpleSchema = {
+  url: "string",
+  title: "string",
+  breadcrumbs: "string[]",
+  description: "string",
+  content: "string",
+  keywords: "string"
+};
+var advancedSchema = {
+  content: "string",
+  page_id: "string",
+  type: "string",
+  breadcrumbs: "string[]",
+  tags: "enum[]",
+  url: "string",
+  embeddings: "vector[512]"
+};
+async function createDB({
+  indexes,
+  tokenizer,
+  search: _,
+  ...rest
+}) {
+  const items = typeof indexes === "function" ? await indexes() : indexes;
+  const db = create({
+    schema: advancedSchema,
+    ...rest,
+    components: {
+      ...rest.components,
+      tokenizer: tokenizer ?? rest.components?.tokenizer
+    }
+  });
+  const mapTo = [];
+  items.forEach((page) => {
+    const pageTag = page.tag ?? [];
+    const tags = Array.isArray(pageTag) ? pageTag : [pageTag];
+    const data = page.structuredData;
+    let id = 0;
+    mapTo.push({
+      id: page.id,
+      page_id: page.id,
+      type: "page",
+      content: page.title,
+      breadcrumbs: page.breadcrumbs,
+      tags,
+      url: page.url
+    });
+    const nextId = () => `${page.id}-${id++}`;
+    if (page.description) {
+      mapTo.push({
+        id: nextId(),
+        page_id: page.id,
+        tags,
+        type: "text",
+        url: page.url,
+        content: page.description
+      });
+    }
+    for (const heading of data.headings) {
+      mapTo.push({
+        id: nextId(),
+        page_id: page.id,
+        type: "heading",
+        tags,
+        url: `${page.url}#${heading.id}`,
+        content: heading.content
+      });
+    }
+    for (const content of data.contents) {
+      mapTo.push({
+        id: nextId(),
+        page_id: page.id,
+        tags,
+        type: "text",
+        url: content.heading ? `${page.url}#${content.heading}` : page.url,
+        content: content.content
+      });
+    }
+  });
+  await insertMultiple(db, mapTo);
+  return db;
+}
+async function createDBSimple({
+  indexes,
+  tokenizer,
+  ...rest
+}) {
+  const items = typeof indexes === "function" ? await indexes() : indexes;
+  const db = create({
+    schema: simpleSchema,
+    ...rest,
+    components: {
+      ...rest.components,
+      tokenizer: tokenizer ?? rest.components?.tokenizer
+    }
+  });
+  await insertMultiple(
+    db,
+    items.map((page) => ({
+      title: page.title,
+      description: page.description,
+      breadcrumbs: page.breadcrumbs,
+      url: page.url,
+      content: page.content,
+      keywords: page.keywords
+    }))
+  );
+  return db;
+}
+
+// src/search/orama/create-from-source.ts
+function defaultBuildIndex(source) {
+  function isBreadcrumbItem(item) {
+    return typeof item === "string" && item.length > 0;
+  }
+  return async (page) => {
+    let breadcrumbs;
+    let structuredData;
+    if ("structuredData" in page.data) {
+      structuredData = page.data.structuredData;
+    } else if ("load" in page.data && typeof page.data.load === "function") {
+      structuredData = (await page.data.load()).structuredData;
+    }
+    if (!structuredData)
+      throw new Error(
+        "Cannot find structured data from page, please define the page to index function."
+      );
+    const pageTree = source.getPageTree(page.locale);
+    const path = findPath(
+      pageTree.children,
+      (node) => node.type === "page" && node.url === page.url
+    );
+    if (path) {
+      breadcrumbs = [];
+      path.pop();
+      if (isBreadcrumbItem(pageTree.name)) {
+        breadcrumbs.push(pageTree.name);
+      }
+      for (const segment of path) {
+        if (!isBreadcrumbItem(segment.name)) continue;
+        breadcrumbs.push(segment.name);
+      }
+    }
+    return {
+      title: page.data.title ?? basename(page.path, extname(page.path)),
+      breadcrumbs,
+      description: page.data.description,
+      url: page.url,
+      id: page.url,
+      structuredData
+    };
+  };
+}
+function createFromSource(source, options = {}) {
+  const { buildIndex = defaultBuildIndex(source) } = options;
+  if (source._i18n) {
+    return createI18nSearchAPI("advanced", {
+      ...options,
+      i18n: source._i18n,
+      indexes: async () => {
+        const indexes = source.getLanguages().flatMap((entry) => {
+          return entry.pages.map(async (page) => ({
+            ...await buildIndex(page),
+            locale: entry.language
+          }));
+        });
+        return Promise.all(indexes);
+      }
+    });
+  }
+  return createSearchAPI("advanced", {
+    ...options,
+    indexes: async () => {
+      const indexes = source.getPages().map((page) => buildIndex(page));
+      return Promise.all(indexes);
+    }
+  });
+}
+
+// src/search/orama/_stemmers.ts
+var STEMMERS = {
+  arabic: "ar",
+  armenian: "am",
+  bulgarian: "bg",
+  czech: "cz",
+  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/orama/create-i18n.ts
+async function getTokenizer(locale) {
+  return {
+    language: Object.keys(STEMMERS).find((lang) => STEMMERS[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 mapped = options.localeMap?.[locale] ?? await getTokenizer(locale);
+    map.set(
+      locale,
+      typeof mapped === "object" ? initSimpleSearch({
+        ...options,
+        ...mapped,
+        indexes: localeIndexes
+      }) : initSimpleSearch({
+        ...options,
+        language: mapped,
+        indexes: localeIndexes
+      })
+    );
+  }
+  return map;
+}
+async function initAdvanced(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 mapped = options.localeMap?.[locale] ?? await getTokenizer(locale);
+    map.set(
+      locale,
+      typeof mapped === "object" ? initAdvancedSearch({
+        ...options,
+        indexes: localeIndexes,
+        ...mapped
+      }) : initAdvancedSearch({
+        ...options,
+        language: mapped,
+        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 = Array.from(map.entries()).map(async ([k, v]) => [
+        k,
+        await v.export()
+      ]);
+      return {
+        type: "i18n",
+        data: Object.fromEntries(await Promise.all(entries))
+      };
+    },
+    async 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 [];
+    }
+  });
+}
+
+// src/search/server.ts
+function createSearchAPI(type, options) {
+  if (type === "simple") {
+    return createEndpoint(initSimpleSearch(options));
+  }
+  return createEndpoint(initAdvancedSearch(options));
+}
+function initSimpleSearch(options) {
+  const doc = createDBSimple(options);
+  return {
+    async export() {
+      return {
+        type: "simple",
+        ...save(await doc)
+      };
+    },
+    async search(query) {
+      const db = await doc;
+      return searchSimple(db, query, options.search);
+    }
+  };
+}
+function initAdvancedSearch(options) {
+  const get = createDB(options);
+  return {
+    async export() {
+      return {
+        type: "advanced",
+        ...save(await get)
+      };
+    },
+    async search(query, searchOptions) {
+      const db = await get;
+      const mode = searchOptions?.mode;
+      return searchAdvanced(db, query, searchOptions?.tag, {
+        ...options.search,
+        mode: mode === "vector" ? "vector" : "fulltext"
+      }).catch((err) => {
+        if (mode === "vector") {
+          throw new Error(
+            "failed to search, make sure you have installed `@orama/plugin-embeddings` according to their docs.",
+            {
+              cause: err
+            }
+          );
+        }
+        throw err;
+      });
+    }
+  };
+}
+export {
+  createContentHighlighter,
+  createFromSource,
+  createI18nSearchAPI,
+  createSearchAPI,
+  initAdvancedSearch,
+  initSimpleSearch
+};

package/dist/source/client/index.d.ts

@@ -0,0 +1,16 @@
+import { R as Root } from '../../definitions-pJ7PybYY.js';
+import 'react';
+
+declare function deserializePageTree(root: Root): Root;
+/**
+ * Deserialize data passed from server-side loader.
+ *
+ * It only receives the serialized data from server-side, hence not sharing plugins and some properties.
+ */
+declare function useFumadocsLoader<V extends {
+    pageTree?: object;
+}>(serialized: V): {
+    pageTree: V["pageTree"] extends object ? Root : undefined;
+};
+
+export { deserializePageTree, useFumadocsLoader };

package/dist/source/client/index.js

@@ -0,0 +1,41 @@
+import {
+  visit
+} from "../../chunk-L4JKQWCM.js";
+import "../../chunk-U67V476Y.js";
+
+// src/source/client/index.tsx
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+function deserializePageTree(root) {
+  function deserializeHTML(html) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        dangerouslySetInnerHTML: {
+          __html: html
+        }
+      }
+    );
+  }
+  visit(root, (item) => {
+    if ("icon" in item && typeof item.icon === "string") {
+      item.icon = deserializeHTML(item.icon);
+    }
+    if (typeof item.name === "string") {
+      item.name = deserializeHTML(item.name);
+    }
+  });
+  return root;
+}
+function useFumadocsLoader(serialized) {
+  const { pageTree } = serialized;
+  return useMemo(() => {
+    return {
+      pageTree: pageTree ? deserializePageTree(pageTree) : void 0
+    };
+  }, [pageTree]);
+}
+export {
+  deserializePageTree,
+  useFumadocsLoader
+};

package/dist/source/index.d.ts

@@ -0,0 +1,42 @@
+export { C as ContentStorage, p as ContentStorageFile, F as FileSystem, h as InferMetaType, I as InferPageType, b as LoaderConfig, c as LoaderOptions, f as LoaderOutput, L as LoaderPlugin, r as LoaderPluginOption, e as Meta, M as MetaData, d as Page, P as PageData, n as PageTreeBuilder, i as PageTreeBuilderContext, k as PageTreeOptions, j as PageTreeTransformer, R as ResolvedLoaderConfig, S as Source, a as SourceConfig, V as VirtualFile, _ as _ConfigUnion_, q as buildContentStorage, t as buildPlugins, g as createGetUrl, o as createPageTreeBuilder, l as loader, m as multiple, s as source, u as update } from '../loader-BvlPPJX0.js';
+import '../definitions-pJ7PybYY.js';
+import 'react';
+import '../i18n/index.js';
+
+/**
+ * Convert file path into slugs, also encode non-ASCII characters, so they can work in pathname
+ */
+declare function getSlugs(file: string): string[];
+
+declare function basename(path: string, ext?: string): string;
+declare function extname(path: string): string;
+declare function dirname(path: string): string;
+/**
+ * Split path into segments, trailing/leading slashes are removed
+ */
+declare function splitPath(path: string): string[];
+/**
+ * Resolve paths, slashes within the path will be ignored
+ * @param paths - Paths to join
+ * @example
+ * ```
+ * ['a','b'] // 'a/b'
+ * ['/a'] // 'a'
+ * ['a', '/b'] // 'a/b'
+ * ['a', '../b/c'] // 'b/c'
+ * ```
+ */
+declare function joinPath(...paths: string[]): string;
+declare function slash(path: string): string;
+
+declare const path_basename: typeof basename;
+declare const path_dirname: typeof dirname;
+declare const path_extname: typeof extname;
+declare const path_joinPath: typeof joinPath;
+declare const path_slash: typeof slash;
+declare const path_splitPath: typeof splitPath;
+declare namespace path {
+  export { path_basename as basename, path_dirname as dirname, path_extname as extname, path_joinPath as joinPath, path_slash as slash, path_splitPath as splitPath };
+}
+
+export { path as PathUtils, getSlugs };