fromsrc 0.0.0 → 0.0.1

package/dist/config.d.ts

@@ -0,0 +1,54 @@
+type FromsrcConfig = {
+    title: string;
+    description?: string;
+    baseUrl?: string;
+    docsDir?: string;
+    outDir?: string;
+    theme?: string;
+    search?: {
+        provider?: string;
+        options?: Record<string, unknown>;
+    };
+    sidebar?: {
+        defaultOpen?: boolean;
+        collapsible?: boolean;
+    };
+    toc?: {
+        minDepth?: number;
+        maxDepth?: number;
+    };
+    i18n?: {
+        defaultLocale?: string;
+        locales?: string[];
+    };
+    editUrl?: string;
+    lastUpdated?: boolean;
+    draft?: boolean;
+};
+type ResolvedConfig = Required<Pick<FromsrcConfig, "title" | "docsDir" | "outDir" | "theme" | "lastUpdated" | "draft">> & {
+    description: string;
+    baseUrl: string;
+    search: {
+        provider: string;
+        options: Record<string, unknown>;
+    };
+    sidebar: {
+        defaultOpen: boolean;
+        collapsible: boolean;
+    };
+    toc: {
+        minDepth: number;
+        maxDepth: number;
+    };
+    i18n: {
+        defaultLocale: string;
+        locales: string[];
+    };
+    editUrl: string;
+};
+declare function defineConfig(config: FromsrcConfig): FromsrcConfig;
+declare function resolveConfig(config: FromsrcConfig): ResolvedConfig;
+declare function loadConfig(dir: string): Promise<FromsrcConfig>;
+declare function mergeConfig(base: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown>;
+
+export { type FromsrcConfig, type ResolvedConfig, defineConfig, loadConfig, mergeConfig, resolveConfig };

package/dist/config.js

@@ -0,0 +1,102 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const defaults = {
+  description: "",
+  baseUrl: "/",
+  docsDir: "docs",
+  outDir: ".fromsrc",
+  theme: "default",
+  search: { provider: "local", options: {} },
+  sidebar: { defaultOpen: true, collapsible: true },
+  toc: { minDepth: 2, maxDepth: 3 },
+  i18n: { defaultLocale: "en", locales: ["en"] },
+  editUrl: "",
+  lastUpdated: false,
+  draft: false
+};
+function isrecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isstring(value) {
+  return typeof value === "string";
+}
+function isboolean(value) {
+  return typeof value === "boolean";
+}
+function parseconfig(value) {
+  if (!isrecord(value)) return null;
+  const title = value.title;
+  if (!isstring(title)) return null;
+  const config = { title };
+  if (isstring(value.description)) config.description = value.description;
+  if (isstring(value.baseUrl)) config.baseUrl = value.baseUrl;
+  if (isstring(value.docsDir)) config.docsDir = value.docsDir;
+  if (isstring(value.outDir)) config.outDir = value.outDir;
+  if (isstring(value.theme)) config.theme = value.theme;
+  if (isstring(value.editUrl)) config.editUrl = value.editUrl;
+  if (isboolean(value.lastUpdated)) config.lastUpdated = value.lastUpdated;
+  if (isboolean(value.draft)) config.draft = value.draft;
+  if (isrecord(value.search)) {
+    const provider = isstring(value.search.provider) ? value.search.provider : void 0;
+    const options = isrecord(value.search.options) ? value.search.options : void 0;
+    config.search = { provider, options };
+  }
+  if (isrecord(value.sidebar)) {
+    const defaultOpen = isboolean(value.sidebar.defaultOpen) ? value.sidebar.defaultOpen : void 0;
+    const collapsible = isboolean(value.sidebar.collapsible) ? value.sidebar.collapsible : void 0;
+    config.sidebar = { defaultOpen, collapsible };
+  }
+  if (isrecord(value.toc)) {
+    const minDepth = typeof value.toc.minDepth === "number" ? value.toc.minDepth : void 0;
+    const maxDepth = typeof value.toc.maxDepth === "number" ? value.toc.maxDepth : void 0;
+    config.toc = { minDepth, maxDepth };
+  }
+  if (isrecord(value.i18n)) {
+    const defaultLocale = isstring(value.i18n.defaultLocale) ? value.i18n.defaultLocale : void 0;
+    const locales = Array.isArray(value.i18n.locales) && value.i18n.locales.every((entry) => isstring(entry)) ? value.i18n.locales : void 0;
+    config.i18n = { defaultLocale, locales };
+  }
+  return config;
+}
+function defineConfig(config) {
+  return config;
+}
+function resolveConfig(config) {
+  return mergeConfig(
+    defaults,
+    config
+  );
+}
+async function loadConfig(dir) {
+  for (const name of ["fromsrc.config.ts", "fromsrc.config.js"]) {
+    try {
+      const mod = await import(/* webpackIgnore: true */ join(dir, name));
+      const parsed = parseconfig(mod.default ?? mod);
+      if (parsed) return parsed;
+    } catch {
+    }
+  }
+  try {
+    const raw = await readFile(join(dir, "fromsrc.config.json"), "utf-8");
+    const parsed = parseconfig(JSON.parse(raw));
+    if (parsed) return parsed;
+  } catch {
+  }
+  throw new Error("no config found");
+}
+function mergeConfig(base, overrides) {
+  const result = { ...base };
+  for (const key of Object.keys(overrides)) {
+    const b = base[key];
+    const o = overrides[key];
+    if (b && o && typeof b === "object" && typeof o === "object" && !Array.isArray(o)) {
+      result[key] = mergeConfig(b, o);
+    } else if (o !== void 0) {
+      result[key] = o;
+    }
+  }
+  return result;
+}
+
+export { defineConfig, loadConfig, mergeConfig, resolveConfig };

package/dist/content.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { baseSchema } from './schema.js';
+
+interface DocMeta {
+    slug: string;
+    title: string;
+    description?: string;
+    order?: number;
+}
+interface Heading {
+    id: string;
+    text: string;
+    level: number;
+}
+interface SearchDoc extends DocMeta {
+    content: string;
+    headings?: Heading[];
+}
+interface Doc<T extends Record<string, unknown> = Record<string, unknown>> extends DocMeta {
+    content: string;
+    data: T;
+}
+type SchemaType = z.ZodObject<z.ZodRawShape>;
+interface ContentConfig<T extends SchemaType = typeof baseSchema> {
+    dir: string;
+    schema?: T;
+}
+declare function defineContent<T extends SchemaType>(config: ContentConfig<T>): {
+    getDoc: (slug: string[]) => Promise<(z.TypeOf<T> & {
+        slug: string;
+    } & {
+        content: string;
+        data: z.infer<T>;
+    }) | null>;
+    getDocs: () => Promise<(z.TypeOf<T> & {
+        slug: string;
+    } & {
+        content: string;
+        data: z.infer<T>;
+    })[]>;
+    getAllDocs: () => Promise<(z.TypeOf<T> & {
+        slug: string;
+    })[]>;
+    getNavigation: () => Promise<{
+        title: string;
+        items: (z.TypeOf<T> & {
+            slug: string;
+        })[];
+    }[]>;
+    getSearchDocs: () => Promise<((z.TypeOf<T> & {
+        slug: string;
+    }) & {
+        content: string;
+        headings?: Heading[];
+    })[]>;
+    schema: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodNumber>;
+        draft: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        draft?: boolean | undefined;
+    }, {
+        title: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        draft?: boolean | undefined;
+    }> | T;
+};
+declare function extractHeadings(content: string): Heading[];
+declare function getDoc(docsDir: string, slug: string[]): Promise<Doc | null>;
+declare function getAllDocs(docsDir: string): Promise<DocMeta[]>;
+declare function getNavigation(docsDir: string): Promise<{
+    title: string;
+    items: DocMeta[];
+}[]>;
+declare function getSearchDocs(docsDir: string): Promise<SearchDoc[]>;
+declare function clearContentCache(): void;
+
+export { type ContentConfig, type Doc, type DocMeta, type Heading, type SearchDoc, clearContentCache, defineContent, extractHeadings, getAllDocs, getDoc, getNavigation, getSearchDocs };

package/dist/content.js

@@ -0,0 +1,464 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+import { z } from 'zod';
+import { sortByMeta, loadMeta } from './meta';
+import { baseSchema } from './schema';
+
+const fileCache = /* @__PURE__ */ new Map();
+const metaCache = /* @__PURE__ */ new Map();
+const isProduction = () => process.env.NODE_ENV === "production";
+const isDraft = (data) => data.draft === true;
+function isnotfound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readCached(filepath) {
+  if (!isProduction()) {
+    return readFile(filepath, "utf-8");
+  }
+  const cached = fileCache.get(filepath);
+  if (cached) return cached;
+  const content = await readFile(filepath, "utf-8");
+  fileCache.set(filepath, content);
+  return content;
+}
+async function resolveSource(docsDir, slug) {
+  const path = slug.length === 0 ? "index" : slug.join("/");
+  const filepath = join(docsDir, `${path}.mdx`);
+  const indexPath = join(docsDir, `${path}/index.mdx`);
+  try {
+    const source = await readCached(filepath);
+    return { source, actualPath: path, filepath };
+  } catch (error) {
+    if (!isnotfound(error)) throw error;
+  }
+  try {
+    const source = await readCached(indexPath);
+    return { source, actualPath: `${path}/index`, filepath: indexPath };
+  } catch (error) {
+    if (!isnotfound(error)) throw error;
+  }
+  return null;
+}
+function defineContent(config) {
+  const schema = config.schema ?? baseSchema;
+  let docsCache = null;
+  let fullDocsCache = null;
+  let navCache = null;
+  function asMeta(doc) {
+    const { content: _content, data: _data, ...meta } = doc;
+    return meta;
+  }
+  async function getDoc2(slug) {
+    const resolved = await resolveSource(config.dir, slug);
+    if (!resolved) return null;
+    try {
+      const { data, content } = matter(resolved.source);
+      const parsed = schema.parse(data);
+      if (isProduction() && isDraft(data)) return null;
+      return {
+        slug: resolved.actualPath,
+        ...parsed,
+        content,
+        data: parsed
+      };
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(`Schema validation failed for ${resolved.filepath}:`);
+        console.error(error.errors);
+        throw error;
+      }
+      console.error(`Failed to parse ${resolved.filepath}:`, error);
+      return null;
+    }
+  }
+  async function getAllDocs2() {
+    if (isProduction() && docsCache) return docsCache;
+    if (isProduction() && fullDocsCache) {
+      const sorted2 = fullDocsCache.map(asMeta);
+      docsCache = sorted2;
+      return sorted2;
+    }
+    const docs = [];
+    async function scan(dir, prefix = "") {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          await scan(join(dir, entry.name), `${prefix}${entry.name}/`);
+        } else if (entry.name.endsWith(".mdx")) {
+          const filepath = join(dir, entry.name);
+          const source = await readCached(filepath);
+          const { data } = matter(source);
+          const parsed = schema.parse(data);
+          if (isProduction() && isDraft(data)) continue;
+          const slug = `${prefix}${entry.name.replace(".mdx", "")}`;
+          docs.push({
+            slug: slug === "index" ? "" : slug,
+            ...parsed
+          });
+        }
+      }
+    }
+    try {
+      await scan(config.dir);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw error;
+      }
+      console.error(`Failed to scan docs in ${config.dir}:`, error);
+      return [];
+    }
+    const sorted = docs.sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+    if (isProduction()) {
+      docsCache = sorted;
+    }
+    return sorted;
+  }
+  async function getDocs() {
+    if (isProduction() && fullDocsCache) return fullDocsCache;
+    const docs = [];
+    async function scan(dir, prefix = "") {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          await scan(join(dir, entry.name), `${prefix}${entry.name}/`);
+        } else if (entry.name.endsWith(".mdx")) {
+          const filepath = join(dir, entry.name);
+          const source = await readCached(filepath);
+          const { data, content } = matter(source);
+          const parsed = schema.parse(data);
+          if (isProduction() && isDraft(data)) continue;
+          const slug = `${prefix}${entry.name.replace(".mdx", "")}`;
+          docs.push({
+            slug: slug === "index" ? "" : slug,
+            ...parsed,
+            content,
+            data: parsed
+          });
+        }
+      }
+    }
+    try {
+      await scan(config.dir);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw error;
+      }
+      console.error(`Failed to load docs in ${config.dir}:`, error);
+      return [];
+    }
+    const sorted = docs.sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+    if (isProduction()) {
+      fullDocsCache = sorted;
+    }
+    return sorted;
+  }
+  async function getNavigation2() {
+    if (isProduction() && navCache) return navCache;
+    try {
+      const docs = await getAllDocs2();
+      const filtered = await buildNavigation(docs, config.dir);
+      if (isProduction()) {
+        navCache = filtered;
+      }
+      return filtered;
+    } catch (error) {
+      console.error(`Failed to build navigation for ${config.dir}:`, error);
+      return [];
+    }
+  }
+  let searchCache2 = null;
+  async function getSearchDocs2() {
+    if (isProduction() && searchCache2) return searchCache2;
+    if (isProduction() && fullDocsCache) {
+      const sorted2 = fullDocsCache.map((doc) => {
+        const headings = extractHeadings(doc.content);
+        return {
+          ...asMeta(doc),
+          content: stripMdx(doc.content),
+          headings: headings.length > 0 ? headings : void 0
+        };
+      }).sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+      searchCache2 = sorted2;
+      return sorted2;
+    }
+    const docs = [];
+    async function scan(dir, prefix = "") {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          await scan(join(dir, entry.name), `${prefix}${entry.name}/`);
+        } else if (entry.name.endsWith(".mdx")) {
+          const filepath = join(dir, entry.name);
+          const source = await readCached(filepath);
+          const { data, content } = matter(source);
+          const parsed = schema.parse(data);
+          if (isProduction() && isDraft(data)) continue;
+          const slug = `${prefix}${entry.name.replace(".mdx", "")}`;
+          const headings = extractHeadings(content);
+          docs.push({
+            slug: slug === "index" ? "" : slug,
+            ...parsed,
+            content: stripMdx(content),
+            headings: headings.length > 0 ? headings : void 0
+          });
+        }
+      }
+    }
+    try {
+      await scan(config.dir);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw error;
+      }
+      console.error(`Failed to build search docs in ${config.dir}:`, error);
+      return [];
+    }
+    const sorted = docs.sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+    if (isProduction()) {
+      searchCache2 = sorted;
+    }
+    return sorted;
+  }
+  return {
+    getDoc: getDoc2,
+    getDocs,
+    getAllDocs: getAllDocs2,
+    getNavigation: getNavigation2,
+    getSearchDocs: getSearchDocs2,
+    schema
+  };
+}
+function stripHeadingFormatting(text) {
+  return text.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim();
+}
+function headingId(text) {
+  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function extractHeadings(content) {
+  const headings = [];
+  const seen = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(#{2,4})\s+(.+)$/);
+    if (!match) continue;
+    const hashes = match[1];
+    const heading = match[2];
+    if (!hashes || !heading) continue;
+    const level = hashes.length;
+    const raw = stripHeadingFormatting(heading);
+    const base = headingId(raw);
+    if (!base) continue;
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    const id = count === 0 ? base : `${base}-${count}`;
+    headings.push({ id, text: raw, level });
+  }
+  return headings;
+}
+function stripMdx(content) {
+  return content.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").replace(/import\s+.*?from\s+['"][^'"]+['"];?/g, "").replace(/export\s+.*?;/g, "").replace(/<[^>]+>/g, " ").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/#{1,6}\s+/g, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+}
+async function getDoc(docsDir, slug) {
+  const resolved = await resolveSource(docsDir, slug);
+  if (!resolved) return null;
+  try {
+    const { data, content } = matter(resolved.source);
+    const parsed = baseSchema.parse(data);
+    if (isProduction() && isDraft(data)) return null;
+    return {
+      slug: resolved.actualPath,
+      title: parsed.title,
+      description: parsed.description,
+      order: parsed.order,
+      content,
+      data: parsed
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error(`Schema validation failed for ${resolved.filepath}:`);
+      console.error(error.errors);
+      throw error;
+    }
+    console.error(`Failed to parse ${resolved.filepath}:`, error);
+    return null;
+  }
+}
+async function getAllDocs(docsDir) {
+  const cacheKey = docsDir;
+  if (isProduction()) {
+    const cached = metaCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  const docs = [];
+  const folderMetas = /* @__PURE__ */ new Map();
+  async function scan(dir, prefix = "") {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const meta = await loadMeta(dir);
+    folderMetas.set(prefix, meta);
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await scan(join(dir, entry.name), `${prefix}${entry.name}/`);
+      } else if (entry.name.endsWith(".mdx")) {
+        const filepath = join(dir, entry.name);
+        const source = await readCached(filepath);
+        const { data } = matter(source);
+        const parsed = baseSchema.parse(data);
+        if (isProduction() && isDraft(data)) continue;
+        const slug = `${prefix}${entry.name.replace(".mdx", "")}`;
+        docs.push({
+          slug: slug === "index" ? "" : slug,
+          title: parsed.title,
+          description: parsed.description,
+          order: parsed.order
+        });
+      }
+    }
+  }
+  try {
+    await scan(docsDir);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw error;
+    }
+    console.error(`Failed to scan docs in ${docsDir}:`, error);
+    return [];
+  }
+  const rootMeta = folderMetas.get("");
+  let sorted;
+  if (rootMeta?.pages) {
+    sorted = sortByMeta(docs, rootMeta.pages, "");
+  } else {
+    sorted = docs.sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+  }
+  if (isProduction()) {
+    metaCache.set(cacheKey, sorted);
+  }
+  return sorted;
+}
+async function getNavigation(docsDir) {
+  try {
+    const docs = await getAllDocs(docsDir);
+    return buildNavigation(docs, docsDir);
+  } catch (error) {
+    console.error(`Failed to build navigation for ${docsDir}:`, error);
+    return [];
+  }
+}
+const searchCache = /* @__PURE__ */ new Map();
+async function getSearchDocs(docsDir) {
+  const cacheKey = docsDir;
+  if (isProduction()) {
+    const cached = searchCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  const docs = [];
+  async function scan(dir, prefix = "") {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await scan(join(dir, entry.name), `${prefix}${entry.name}/`);
+      } else if (entry.name.endsWith(".mdx")) {
+        const filepath = join(dir, entry.name);
+        const source = await readCached(filepath);
+        const { data, content } = matter(source);
+        const parsed = baseSchema.parse(data);
+        if (isProduction() && isDraft(data)) continue;
+        const slug = `${prefix}${entry.name.replace(".mdx", "")}`;
+        const headings = extractHeadings(content);
+        docs.push({
+          slug: slug === "index" ? "" : slug,
+          title: parsed.title,
+          description: parsed.description,
+          order: parsed.order,
+          content: stripMdx(content),
+          headings: headings.length > 0 ? headings : void 0
+        });
+      }
+    }
+  }
+  try {
+    await scan(docsDir);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw error;
+    }
+    console.error(`Failed to build search docs in ${docsDir}:`, error);
+    return [];
+  }
+  const sorted = docs.sort((a, b) => (a.order ?? 99) - (b.order ?? 99));
+  if (isProduction()) {
+    searchCache.set(cacheKey, sorted);
+  }
+  return sorted;
+}
+function fallbacktitle(key) {
+  if (key === "") return "docs";
+  return key.replace(/-/g, " ");
+}
+async function buildNavigation(docs, docsDir) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    const key = groupkey(doc.slug);
+    const section = grouped.get(key) ?? {
+      key,
+      title: fallbacktitle(key),
+      items: []
+    };
+    section.items.push(doc);
+    grouped.set(key, section);
+  }
+  const rootMeta = await loadMeta(docsDir);
+  const order = sectionOrder(rootMeta?.pages);
+  const sections = [...grouped.values()];
+  sections.sort((left, right) => {
+    const leftOrder = order.get(left.key);
+    const rightOrder = order.get(right.key);
+    if (leftOrder !== void 0 && rightOrder !== void 0) return leftOrder - rightOrder;
+    if (leftOrder !== void 0) return -1;
+    if (rightOrder !== void 0) return 1;
+    if (left.key === "") return -1;
+    if (right.key === "") return 1;
+    return left.key.localeCompare(right.key);
+  });
+  const metas = await Promise.all(
+    sections.map((section) => {
+      if (section.key === "") return Promise.resolve(rootMeta);
+      return loadMeta(join(docsDir, section.key));
+    })
+  );
+  return sections.map((section, index) => {
+    const prefix = section.key ? `${section.key}/` : "";
+    const sorted = sortByMeta(section.items, metas[index]?.pages, prefix);
+    const label = metas[index]?.title ?? section.title;
+    return {
+      title: label,
+      items: sorted
+    };
+  }).filter((section) => section.items.length > 0);
+}
+function sectionOrder(pages) {
+  const order = /* @__PURE__ */ new Map();
+  if (!pages) return order;
+  for (const page of pages) {
+    const key = groupkey(page);
+    if (!order.has(key)) {
+      order.set(key, order.size);
+    }
+  }
+  return order;
+}
+function groupkey(slug) {
+  if (!slug || slug === "index") return "";
+  if (!slug.includes("/")) return slug;
+  const [head] = slug.split("/");
+  if (!head || head === "index") return "";
+  return head;
+}
+function clearContentCache() {
+  fileCache.clear();
+  metaCache.clear();
+  searchCache.clear();
+}
+
+export { clearContentCache, defineContent, extractHeadings, getAllDocs, getDoc, getNavigation, getSearchDocs };