docus 1.0.4 → 2.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,24 +1,9 @@
-# Docus CLI
-
-The Docus CLI.
-
-## Quick Setup
-
-Add `docus` package globally:
-
-```bash
-# Using Yarn
-yarn install --global docus
-# Using NPM
-npm install --global docus
-```
-
-## Commands
-
-TODO
-
-## Development
-
-1. Clone this repository
-2. Install dependencies using `yarn install`
-3. Start dev server using `yarn dev`
+<h1>
+  <img src="./.github/banner.png" >
+ </h1>
+
+ <p>
+  <a href="https://www.npmjs.com/package/docus"><img src="https://badgen.net/npm/dm/docus" alt="Downloads"></a>
+  <a href="https://www.npmjs.com/package/docus"><img src="https://badgen.net/npm/v/docus" alt="Version"></a>
+  <a href="https://www.npmjs.com/package/docus"><img src="https://badgen.net/npm/license/docus" alt="License"></a>
+ </p>

package/dist/index.cjs

@@ -0,0 +1,549 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const kit = require('@nuxt/kit');
+const pathe = require('pathe');
+const fetch = require('node-fetch');
+const ufo = require('ufo');
+const debounce = require('debounce');
+const unstorage = require('unstorage');
+const fsDriver = require('unstorage/drivers/fs');
+const ws = require('ws');
+const consola = require('consola');
+const url = require('url');
+const fs$1 = require('fs/promises');
+const fs = require('fs');
+const jiti = require('jiti');
+const clearModule = require('clear-module');
+const _glob = require('glob');
+const defu = require('defu');
+const chalk = require('chalk');
+const unctx = require('unctx');
+const iso639 = require('iso-639-1');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+const fsDriver__default = /*#__PURE__*/_interopDefaultLegacy(fsDriver);
+const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
+const fs__default$1 = /*#__PURE__*/_interopDefaultLegacy(fs);
+const jiti__default = /*#__PURE__*/_interopDefaultLegacy(jiti);
+const clearModule__default = /*#__PURE__*/_interopDefaultLegacy(clearModule);
+const _glob__default = /*#__PURE__*/_interopDefaultLegacy(_glob);
+const defu__default = /*#__PURE__*/_interopDefaultLegacy(defu);
+const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+const iso639__default = /*#__PURE__*/_interopDefaultLegacy(iso639);
+
+const useDefaultOptions = (nuxt) => ({
+  apiBase: "_docus",
+  dirs: ["content"],
+  watch: nuxt.options.dev,
+  locales: {
+    codes: ["en"],
+    defaultLocale: "en"
+  },
+  database: {
+    provider: "local",
+    options: {}
+  },
+  ignoreList: [],
+  search: {
+    inheritanceFields: ["layout"]
+  },
+  transformers: {
+    markdown: {
+      components: [],
+      rehypePlugins: [],
+      remarkPlugins: [],
+      tagMap: {
+        a: "prose-a",
+        blockquote: "prose-blockquote",
+        "code-inline": "prose-code-inline",
+        code: "prose-code",
+        em: "prose-em",
+        h1: "prose-h1",
+        h2: "prose-h2",
+        h3: "prose-h3",
+        h4: "prose-h4",
+        h5: "prose-h5",
+        h6: "prose-h6",
+        hr: "prose-hr",
+        img: "prose-img",
+        li: "prose-li",
+        ol: "prose-ol",
+        p: "prose-paragraph",
+        strong: "prose-strong",
+        table: "prose-table",
+        tbody: "prose-tbody",
+        td: "prose-td",
+        th: "prose-th",
+        thead: "prose-thead",
+        tr: "prose-tr",
+        ul: "prose-ul"
+      }
+    }
+  }
+});
+
+let wss;
+function useWebSocket() {
+  if (!wss)
+    wss = new ws.Server({ noServer: true });
+  const serve = (req, socket = req.socket, head = "") => wss.handleUpgrade(req, socket, head, (client) => wss.emit("connection", client, req));
+  const broadcast = (data) => {
+    data = JSON.stringify(data);
+    for (const client of wss.clients) {
+      try {
+        client.send(data);
+      } catch (err) {
+      }
+    }
+  };
+  return {
+    serve,
+    broadcast
+  };
+}
+
+const logger = consola__default.withScope("@docus");
+
+const distDir = pathe.resolve(typeof __dirname === "undefined" ? pathe.dirname(url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs', document.baseURI).href)))) : __dirname);
+const _makeResolve = (base) => {
+  return (...p) => pathe.resolve(base, ...p);
+};
+const runtimeDir = pathe.resolve(distDir, "runtime");
+const resolveRuntimeDir = _makeResolve(runtimeDir);
+const templateDir = pathe.resolve(distDir, "templates");
+const appDir = pathe.resolve(runtimeDir, "app");
+const resolveAppDir = _makeResolve(appDir);
+pathe.resolve(appDir, "components");
+
+const THEME_CONFIG_FILE = "theme.config";
+const DOCUS_CONFIG_FILE = "docus.config";
+
+const defineThemeConfig = (config) => config;
+const defineDocusConfig = (config) => config;
+const loadConfig = (file, rootDir) => {
+  const data = {
+    configFile: false,
+    configPath: pathe.resolve(rootDir, file)
+  };
+  if (fs.existsSync(data.configPath + ".js"))
+    data.configPath += ".js";
+  else if (fs.existsSync(data.configPath + ".ts"))
+    data.configPath += ".ts";
+  else
+    return data;
+  clearModule__default(data.configPath);
+  try {
+    data.configFile = jiti__default(distDir)(data.configPath);
+    data.configFile = data.configFile?.default || data.configFile;
+  } catch (err) {
+    throw new Error(`Could not find ${file}, this file is needed for Docus.`);
+  }
+  return data;
+};
+const writeConfig = async (file, cacheDir, content) => {
+  const jsonPath = pathe.join(cacheDir, `${file}.json`);
+  if (!fs.existsSync(cacheDir))
+    await fs__default.mkdir(cacheDir, { recursive: true });
+  if (fs.existsSync(jsonPath))
+    await fs__default.rm(jsonPath);
+  await fs__default.writeFile(jsonPath, JSON.stringify(content.default || content), { encoding: "utf8" });
+};
+const loadTheme = (path, rootDir) => {
+  let themeConfig = {};
+  let themeConfigPath = kit.resolveModule(pathe.join(path, THEME_CONFIG_FILE), { paths: rootDir });
+  try {
+    themeConfigPath = jiti__default(rootDir).resolve(themeConfigPath);
+  } catch (err) {
+    return themeConfig;
+  }
+  try {
+    themeConfig = jiti__default(rootDir)(themeConfigPath);
+  } catch (err) {
+    logger.warn(`Could not load theme config: ${themeConfigPath}`, err);
+  }
+  themeConfig = themeConfig.default || themeConfig;
+  return themeConfig;
+};
+const buildExternals = ["@nuxt/bridge", "@nuxt/kit", "#app", "@vue/composition-api"];
+const resolveApiRoute = (route) => {
+  const nuxt = kit.useNuxt();
+  const apiBase = nuxt.options.content?.apiBase || useDefaultOptions(nuxt).apiBase;
+  return ufo.joinURL("/api", apiBase, route);
+};
+async function loadNuxtIgnoreList(nuxt) {
+  const ignore = ["**/-*.*", "**/node_modules/**", "**/.git/**", "**/.**"];
+  const ignoreFile = pathe.resolve(nuxt.options.rootDir, ".nuxtignore");
+  const ignoreContent = await fs__default.readFile(ignoreFile, { encoding: "utf-8" }).catch(() => "");
+  if (ignoreContent) {
+    ignore.push(...ignoreContent.split("\n").filter(Boolean));
+  }
+  const refinedList = ignore.map((pattern) => {
+    if (typeof pattern === "string") {
+      return pattern.replace(/\//g, ":");
+    }
+    return pattern;
+  });
+  return refinedList;
+}
+
+function setupDevTarget(options, nuxt) {
+  const ws = useWebSocket();
+  if (options.watch) {
+    kit.addServerMiddleware({
+      route: resolveApiRoute("reload"),
+      handle: kit.resolveModule("./server/api/reload", { paths: runtimeDir }).replace(/\.js$/, ".mjs")
+    });
+    kit.addPlugin(kit.resolveModule("./hot", { paths: templateDir }));
+    const storage = unstorage.createStorage();
+    loadNuxtIgnoreList(nuxt).then((ignoreList) => {
+      options.dirs.forEach((dir) => {
+        const [path, key] = Array.isArray(dir) ? dir : [dir, dir];
+        storage.mount(key, fsDriver__default({
+          base: pathe.resolve(nuxt.options.rootDir, path),
+          ignore: ignoreList
+        }));
+      });
+    });
+    nuxt.server.listen(0).then(({ url, server }) => {
+      nuxt.options.publicRuntimeConfig.$docus.wsUrl = url.replace("http", "ws");
+      server.on("upgrade", (req, socket, head) => ws.serve(req, socket, head));
+      storage.watch(createDebounceContentWatcher(async (event, key) => {
+        await fetch__default(ufo.joinURL(url, "api", options.apiBase, "reload"), {
+          method: "POST",
+          body: JSON.stringify({ event, key })
+        });
+        ws.broadcast({ event, key });
+      }));
+    });
+  }
+}
+function createDebounceContentWatcher(callback) {
+  const handleEvent = debounce.debounce(callback, 200);
+  return (event, key) => {
+    if (key.endsWith(".md")) {
+      handleEvent(event, key);
+      switch (event) {
+        case "remove":
+          logger.info(`You removed ${key}`);
+          return;
+        case "update":
+          logger.info(`You updated ${key}`);
+          return;
+        default:
+          logger.info(`You updated ${key}`);
+      }
+    }
+  };
+}
+
+const glob = (pattern, options = {}) => new Promise((resolve2, reject) => _glob__default(pattern, options, (err, matches) => {
+  if (err)
+    return reject(err);
+  resolve2(matches);
+}));
+const setupAppModule = (nuxt, options) => {
+  loadNuxtIgnoreList(nuxt).then((ignoreList) => options.ignoreList = ignoreList);
+  nuxt.options.alias["#docus$"] = runtimeDir;
+  nuxt.options.alias["#docus/composables"] = resolveAppDir("composables");
+  nuxt.options.alias["#docus/database"] = resolveRuntimeDir("database/providers", options.database.provider);
+  nuxt.options.alias["#docus/cache"] = pathe.join(nuxt.options.rootDir, "node_modules/.cache/docus");
+  nuxt.options.meta = nuxt.options.meta || {};
+  nuxt.options.head = nuxt.options.head || {};
+  nuxt.options.head.meta = nuxt.options.head.meta || [];
+  nuxt.options.head.meta.push({ charset: "utf-8" }, { name: "viewport", content: "width=device-width, initial-scale=1" });
+  nuxt.options.bridge = nuxt.options.bridge || {};
+  nuxt.options.bridge.autoImports = false;
+  nuxt.options.bridge.postcss8 = true;
+  nuxt.options.components = Array.isArray(nuxt.options.components) ? nuxt.options.components : [];
+  nuxt.options.components.push({
+    path: resolveAppDir("components"),
+    isAsync: false,
+    prefix: "",
+    level: 999
+  });
+  nuxt.options.colorMode = nuxt.options.colorMode || {};
+  nuxt.options.colorMode.classSuffix = "";
+  nuxt.options.image = nuxt.options.image || {};
+  nuxt.options.image.domains = nuxt.options.image.domains || [];
+  nuxt.options.image.domains.push("https://i3.ytimg.com");
+  nuxt.options.target = "server";
+  nuxt.options.server = nuxt.options.server || {};
+  nuxt.options.server.port = parseInt(process.env.PORT || "4000", 10);
+  nuxt.options.generate = nuxt.options.generate || {};
+  nuxt.options.generate.routes = nuxt.options.generate.routes || [];
+  nuxt.options.generate.fallback = "404.html";
+  nuxt.options.generate.routes.push("/");
+  nuxt.options.nitro = nuxt.options.nitro || {};
+  nuxt.options.nitro.experiments = nuxt.options.nitro.experiments || {};
+  nuxt.options.nitro.experiments.wasm = true;
+  nuxt.options.nitro.inlineDynamicImports = true;
+  nuxt.options.nitro.externals = process.env.NITRO_PRESET === "cloudflare" ? false : {
+    inline: ["docus", "ohmyfetch", "property-information", "@docus/mdc"],
+    external: [
+      "vue-docgen-api",
+      "@nuxt/kit",
+      "@nuxt/image",
+      "@nuxtjs/i18n",
+      "vue-meta",
+      "vue-router",
+      "vue-i18n",
+      "ufo",
+      "vue-client-only",
+      "vue-no-ssr",
+      "ohmyfetch"
+    ]
+  };
+  nuxt.options.build = nuxt.options.build || {};
+  nuxt.options.build.transpile = nuxt.options.build.transpile || [];
+  nuxt.options.build.transpile.push("@docus/", "ohmyfetch", "property-information", "nuxt-component-meta", "@nuxt/bridge");
+  nuxt.options.layouts.default = resolveAppDir("layouts/default.vue");
+  nuxt.hook("build:extendRoutes", (routes) => {
+    const hasRoute = (name) => routes.some((route) => route.name === name);
+    if (!hasRoute("all")) {
+      routes.push({
+        path: "/*",
+        name: "all",
+        component: resolveAppDir("pages/_.vue")
+      });
+    }
+  });
+  nuxt.hook("build:before", async () => {
+    const errorPagePath = pathe.resolve(nuxt.options.srcDir, nuxt.options.dir.layouts, "error.vue");
+    const errorPageExists = await fs__default.stat(errorPagePath).catch(() => false);
+    if (!errorPageExists)
+      nuxt.options.ErrorPage = nuxt.options.ErrorPage || resolveAppDir("layouts/error.vue");
+    const pagesDirPath = pathe.resolve(nuxt.options.srcDir, nuxt.options.dir.pages);
+    const pagesDirExists = await fs__default.stat(pagesDirPath).catch(() => false);
+    if (!pagesDirExists) {
+      nuxt.options.build.createRoutes = () => [];
+      nuxt.options.watch.push(pagesDirPath);
+    }
+  });
+  nuxt.hook("components:dirs", async (dirs) => {
+    const componentsDirPath = pathe.resolve(nuxt.options.rootDir, "components");
+    const componentsDirStat = await fs__default.stat(componentsDirPath).catch(() => null);
+    if (componentsDirStat && componentsDirStat.isDirectory()) {
+      dirs.push({
+        path: componentsDirPath,
+        isAsync: false
+      });
+      const subDirs = await glob(componentsDirPath + "/**/");
+      subDirs.forEach((path) => dirs.push({ path, isAsync: false }));
+    } else {
+      nuxt.options.watch.push(componentsDirPath);
+    }
+  });
+  kit.addTemplate({
+    src: kit.resolveModule("./options", { paths: templateDir }),
+    filename: "docus/options.mjs",
+    options
+  });
+  kit.addPluginTemplate({
+    src: kit.resolveModule("./docus", { paths: templateDir })
+  }, {
+    append: true
+  });
+  nuxt.hook("modules:done", () => nuxt.callHook("docus:options", options));
+};
+
+const version = "2.1.0";
+
+const themeContext = unctx.getContext("docus:theme");
+const setThemeConfig = themeContext.set;
+themeContext.use;
+const configContext = unctx.getContext("docus:config");
+const setDocusConfig = configContext.set;
+const useDocusConfig = configContext.use;
+
+const setupThemeModule = (nuxt) => {
+  const cacheDir = nuxt.options.alias["#docus/cache"];
+  const docusConfig = useDocusConfig();
+  let themeConfig = {};
+  if (docusConfig?.theme) {
+    const themePath = kit.resolveAlias(docusConfig?.theme, nuxt.options.alias);
+    themeConfig = loadTheme(themePath, nuxt.options.rootDir);
+  }
+  const { configFile, configPath } = loadConfig(THEME_CONFIG_FILE, nuxt.options.rootDir);
+  themeConfig = defu__default(configFile || {}, themeConfig);
+  setThemeConfig(themeConfig, true);
+  nuxt.hook("modules:done", async () => await writeConfig(THEME_CONFIG_FILE, cacheDir, themeConfig));
+  nuxt.options.cli.badgeMessages.push("", chalk__default.bold("\u{1F484} Theme: ") + chalk__default.underline.yellow(themeConfig?.name || "Blank"));
+  nuxt.options.watch.push(configPath);
+};
+
+const defaultConfig = defineDocusConfig({
+  title: "Docus",
+  contentDir: "content",
+  url: "http://localhost:3000",
+  description: "A website built with Docus.",
+  template: "page"
+});
+const setupConfigModule = (nuxt) => {
+  const cacheDir = nuxt.options.alias["#docus/cache"];
+  const { configFile: docusConfig, configPath } = loadConfig(DOCUS_CONFIG_FILE, nuxt.options.rootDir);
+  const config = defu__default(docusConfig || {}, defaultConfig);
+  nuxt.options.cli.badgeMessages.push(chalk__default.bold("\u{1F4DD} Docus: ") + chalk__default.underline.yellow(`v${version}`));
+  setDocusConfig(config, true);
+  setupThemeModule(nuxt);
+  nuxt.options.meta.name = config.title;
+  nuxt.options.meta.description = config.description;
+  nuxt.hook("modules:done", async () => await writeConfig(DOCUS_CONFIG_FILE, cacheDir, config));
+  nuxt.options.watch.push(configPath);
+};
+
+const defaultI18nConfig = {
+  baseUrl: (nuxt) => nuxt.app?.$docus?.config?.value?.url || "",
+  locales: [],
+  defaultLocale: "en",
+  parsePages: false,
+  vuex: false,
+  vueI18n: {
+    fallbackLocale: "en",
+    dateTimeFormats: {
+      en: {
+        long: {
+          year: "numeric",
+          month: "short",
+          day: "numeric",
+          weekday: "short"
+        }
+      },
+      fr: {
+        long: {
+          year: "numeric",
+          month: "long",
+          day: "numeric",
+          weekday: "short"
+        }
+      }
+    }
+  }
+};
+const setupI18nModule = async (nuxt) => {
+  const config = useDocusConfig();
+  nuxt.options.i18n = defu__default(nuxt.options.i18n, defaultI18nConfig);
+  const i18nConfig = nuxt.options.i18n;
+  try {
+    if (!nuxt.options.i18n?.locales?.length) {
+      const contentDir = pathe.resolve(nuxt.options.srcDir, config?.contentDir || "content");
+      const contentDirectories = fs__default$1.readdirSync(contentDir);
+      i18nConfig.locales = contentDirectories.filter((lang) => !!iso639__default.getName(lang)).map((code) => ({ code, iso: code, name: iso639__default.getName(code) }));
+      if (!i18nConfig.locales.length)
+        throw new Error("No locales detected from `contentDir`! Using fallback.");
+    }
+  } catch (e) {
+    const defaultLocale = i18nConfig.defaultLocale || "en";
+    i18nConfig.locales = [
+      {
+        code: defaultLocale,
+        iso: defaultLocale,
+        name: iso639__default.getName(defaultLocale) || defaultLocale
+      }
+    ];
+  }
+  kit.addPlugin(kit.resolveModule("./i18n", { paths: templateDir }));
+  const localesList = i18nConfig.locales?.map(({ code }) => code).join(", ") || "en";
+  nuxt.options.cli.badgeMessages.push("", chalk__default.bold("\u{1F4D9} Languages: ") + chalk__default.underline.yellow(localesList));
+  await kit.installModule(nuxt, "@nuxtjs/i18n");
+  nuxt.hook("docus:context", (docusContext) => {
+    const codes = nuxt.options.i18n?.locales.map((locale) => locale.code || locale);
+    docusContext.locales.codes = codes || docusContext.locales.codes;
+    docusContext.locales.defaultLocale = nuxt.options.i18n?.defaultLocale || docusContext.locales.defaultLocale;
+  });
+  nuxt.hook("build:extendRoutes", (routes) => {
+    const index = routes.findIndex((route) => route.path === "/*");
+    const [all] = routes.splice(index, 1);
+    routes.push(all);
+  });
+};
+
+async function setupComponentMetaModule(nuxt) {
+  const markdownTemplateHanlder = (documentation, ast) => {
+    if (ast.tag === "Markdown") {
+      const useValue = ast.props?.find((prop) => prop.name === "use")?.value;
+      const slotName = (typeof useValue === "object" ? useValue.content : useValue) ?? "default";
+      documentation.getSlotDescriptor(slotName);
+    }
+  };
+  await kit.installModule(nuxt, {
+    src: "nuxt-component-meta/module",
+    options: {
+      parserOptions: {
+        addTemplateHandlers: [markdownTemplateHanlder]
+      }
+    }
+  });
+}
+
+const setupContentModule = (nuxt, options) => {
+  nuxt.hook("nitro:context", (ctx) => {
+    if (ctx.preset === "dev") {
+      for (const dir of options.dirs) {
+        const [path, key] = Array.isArray(dir) ? dir : [dir, dir.replace(/[/:]/g, "_")];
+        ctx.storage.mounts[`docus:source:${key}`] = {
+          driver: "fs",
+          driverOptions: {
+            base: pathe.resolve(nuxt.options.rootDir, path)
+          }
+        };
+      }
+      ctx.storage.mounts["assets:docus:build"] = {
+        driver: "fs",
+        driverOptions: {
+          base: pathe.resolve(nuxt.options.buildDir, "docus/build")
+        }
+      };
+    } else {
+      ctx.assets.dirs["docus:build"] = {
+        dir: pathe.resolve(nuxt.options.buildDir, "docus/build"),
+        meta: true
+      };
+    }
+    if (!ctx.storage.mounts["docus:preview"]) {
+      ctx.storage.mounts["docus:preview"] = {
+        driver: "memory"
+      };
+    }
+  });
+  for (const api of ["get", "list", "search", "navigation", "preview"]) {
+    kit.addServerMiddleware({
+      route: resolveApiRoute(api),
+      handle: kit.resolveModule(`./server/api/${api}`, { paths: runtimeDir }).replace(/\.js$/, ".mjs")
+    });
+  }
+  nuxt.options.publicRuntimeConfig.$docus = {
+    apiBase: options.apiBase,
+    tagMap: options.transformers.markdown.tagMap
+  };
+  kit.addPlugin(kit.resolveModule("./content", { paths: templateDir }));
+};
+
+const index = kit.defineNuxtModule((nuxt) => ({
+  configKey: "content",
+  defaults: useDefaultOptions(nuxt),
+  async setup(options, nuxt2) {
+    if (nuxt2.options.dev)
+      setupDevTarget(options, nuxt2);
+    setupAppModule(nuxt2, options);
+    setupContentModule(nuxt2, options);
+    setupConfigModule(nuxt2);
+    await setupI18nModule(nuxt2);
+    await setupComponentMetaModule(nuxt2);
+    await kit.installModule(nuxt2, "@nuxt/image");
+  }
+}));
+
+exports.buildExternals = buildExternals;
+exports["default"] = index;
+exports.defineDocusConfig = defineDocusConfig;
+exports.defineThemeConfig = defineThemeConfig;
+exports.loadConfig = loadConfig;
+exports.loadNuxtIgnoreList = loadNuxtIgnoreList;
+exports.loadTheme = loadTheme;
+exports.resolveApiRoute = resolveApiRoute;
+exports.writeConfig = writeConfig;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Nuxt } from '@nuxt/schema';
+import { ThemeConfig, DocusConfig } from 'types';
+
+declare const _default: _nuxt_schema.LegacyNuxtModule;
+
+/**
+ * Define the the theme configuration object.
+ */
+declare const defineThemeConfig: <T = ThemeConfig>(config: Partial<T>) => Partial<T>;
+/**
+ * Define the Docus configuration object.
+ */
+declare const defineDocusConfig: (config: DocusConfig) => DocusConfig;
+declare const loadConfig: <T = any>(file: string, rootDir: string) => {
+    configFile: false | T;
+    configPath: string;
+};
+declare const writeConfig: (file: string, cacheDir: string, content: any) => Promise<void>;
+declare const loadTheme: (path: string, rootDir: string) => ThemeConfig;
+declare const buildExternals: string[];
+declare const resolveApiRoute: (route: string) => string;
+declare function loadNuxtIgnoreList(nuxt: Nuxt): Promise<string[]>;
+
+export { buildExternals, _default as default, defineDocusConfig, defineThemeConfig, loadConfig, loadNuxtIgnoreList, loadTheme, resolveApiRoute, writeConfig };