docus 1.0.4 → 2.1.0

package/dist/index.mjs

@@ -0,0 +1,523 @@
+import { resolveModule, useNuxt, addServerMiddleware, addPlugin, addTemplate, addPluginTemplate, resolveAlias, installModule, defineNuxtModule } from '@nuxt/kit';
+import { resolve, dirname, join } from 'pathe';
+import fetch from 'node-fetch';
+import { joinURL } from 'ufo';
+import { debounce } from 'debounce';
+import { createStorage } from 'unstorage';
+import fsDriver from 'unstorage/drivers/fs';
+import { Server } from 'ws';
+import consola from 'consola';
+import { fileURLToPath } from 'url';
+import fs from 'fs/promises';
+import fs$1, { existsSync } from 'fs';
+import jiti from 'jiti';
+import clearModule from 'clear-module';
+import _glob from 'glob';
+import defu from 'defu';
+import chalk from 'chalk';
+import { getContext } from 'unctx';
+import iso639 from 'iso-639-1';
+
+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 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.withScope("@docus");
+
+const distDir = resolve(typeof __dirname === "undefined" ? dirname(fileURLToPath(import.meta.url)) : __dirname);
+const _makeResolve = (base) => {
+  return (...p) => resolve(base, ...p);
+};
+const runtimeDir = resolve(distDir, "runtime");
+const resolveRuntimeDir = _makeResolve(runtimeDir);
+const templateDir = resolve(distDir, "templates");
+const appDir = resolve(runtimeDir, "app");
+const resolveAppDir = _makeResolve(appDir);
+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: resolve(rootDir, file)
+  };
+  if (existsSync(data.configPath + ".js"))
+    data.configPath += ".js";
+  else if (existsSync(data.configPath + ".ts"))
+    data.configPath += ".ts";
+  else
+    return data;
+  clearModule(data.configPath);
+  try {
+    data.configFile = jiti(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 = join(cacheDir, `${file}.json`);
+  if (!existsSync(cacheDir))
+    await fs.mkdir(cacheDir, { recursive: true });
+  if (existsSync(jsonPath))
+    await fs.rm(jsonPath);
+  await fs.writeFile(jsonPath, JSON.stringify(content.default || content), { encoding: "utf8" });
+};
+const loadTheme = (path, rootDir) => {
+  let themeConfig = {};
+  let themeConfigPath = resolveModule(join(path, THEME_CONFIG_FILE), { paths: rootDir });
+  try {
+    themeConfigPath = jiti(rootDir).resolve(themeConfigPath);
+  } catch (err) {
+    return themeConfig;
+  }
+  try {
+    themeConfig = jiti(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 = useNuxt();
+  const apiBase = nuxt.options.content?.apiBase || useDefaultOptions(nuxt).apiBase;
+  return joinURL("/api", apiBase, route);
+};
+async function loadNuxtIgnoreList(nuxt) {
+  const ignore = ["**/-*.*", "**/node_modules/**", "**/.git/**", "**/.**"];
+  const ignoreFile = resolve(nuxt.options.rootDir, ".nuxtignore");
+  const ignoreContent = await fs.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) {
+    addServerMiddleware({
+      route: resolveApiRoute("reload"),
+      handle: resolveModule("./server/api/reload", { paths: runtimeDir }).replace(/\.js$/, ".mjs")
+    });
+    addPlugin(resolveModule("./hot", { paths: templateDir }));
+    const storage = createStorage();
+    loadNuxtIgnoreList(nuxt).then((ignoreList) => {
+      options.dirs.forEach((dir) => {
+        const [path, key] = Array.isArray(dir) ? dir : [dir, dir];
+        storage.mount(key, fsDriver({
+          base: 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(joinURL(url, "api", options.apiBase, "reload"), {
+          method: "POST",
+          body: JSON.stringify({ event, key })
+        });
+        ws.broadcast({ event, key });
+      }));
+    });
+  }
+}
+function createDebounceContentWatcher(callback) {
+  const handleEvent = 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(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"] = 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 = resolve(nuxt.options.srcDir, nuxt.options.dir.layouts, "error.vue");
+    const errorPageExists = await fs.stat(errorPagePath).catch(() => false);
+    if (!errorPageExists)
+      nuxt.options.ErrorPage = nuxt.options.ErrorPage || resolveAppDir("layouts/error.vue");
+    const pagesDirPath = resolve(nuxt.options.srcDir, nuxt.options.dir.pages);
+    const pagesDirExists = await fs.stat(pagesDirPath).catch(() => false);
+    if (!pagesDirExists) {
+      nuxt.options.build.createRoutes = () => [];
+      nuxt.options.watch.push(pagesDirPath);
+    }
+  });
+  nuxt.hook("components:dirs", async (dirs) => {
+    const componentsDirPath = resolve(nuxt.options.rootDir, "components");
+    const componentsDirStat = await fs.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);
+    }
+  });
+  addTemplate({
+    src: resolveModule("./options", { paths: templateDir }),
+    filename: "docus/options.mjs",
+    options
+  });
+  addPluginTemplate({
+    src: resolveModule("./docus", { paths: templateDir })
+  }, {
+    append: true
+  });
+  nuxt.hook("modules:done", () => nuxt.callHook("docus:options", options));
+};
+
+const version = "2.1.0";
+
+const themeContext = getContext("docus:theme");
+const setThemeConfig = themeContext.set;
+themeContext.use;
+const configContext = 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 = resolveAlias(docusConfig?.theme, nuxt.options.alias);
+    themeConfig = loadTheme(themePath, nuxt.options.rootDir);
+  }
+  const { configFile, configPath } = loadConfig(THEME_CONFIG_FILE, nuxt.options.rootDir);
+  themeConfig = defu(configFile || {}, themeConfig);
+  setThemeConfig(themeConfig, true);
+  nuxt.hook("modules:done", async () => await writeConfig(THEME_CONFIG_FILE, cacheDir, themeConfig));
+  nuxt.options.cli.badgeMessages.push("", chalk.bold("\u{1F484} Theme: ") + chalk.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(docusConfig || {}, defaultConfig);
+  nuxt.options.cli.badgeMessages.push(chalk.bold("\u{1F4DD} Docus: ") + chalk.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(nuxt.options.i18n, defaultI18nConfig);
+  const i18nConfig = nuxt.options.i18n;
+  try {
+    if (!nuxt.options.i18n?.locales?.length) {
+      const contentDir = resolve(nuxt.options.srcDir, config?.contentDir || "content");
+      const contentDirectories = fs$1.readdirSync(contentDir);
+      i18nConfig.locales = contentDirectories.filter((lang) => !!iso639.getName(lang)).map((code) => ({ code, iso: code, name: iso639.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.getName(defaultLocale) || defaultLocale
+      }
+    ];
+  }
+  addPlugin(resolveModule("./i18n", { paths: templateDir }));
+  const localesList = i18nConfig.locales?.map(({ code }) => code).join(", ") || "en";
+  nuxt.options.cli.badgeMessages.push("", chalk.bold("\u{1F4D9} Languages: ") + chalk.underline.yellow(localesList));
+  await 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 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: resolve(nuxt.options.rootDir, path)
+          }
+        };
+      }
+      ctx.storage.mounts["assets:docus:build"] = {
+        driver: "fs",
+        driverOptions: {
+          base: resolve(nuxt.options.buildDir, "docus/build")
+        }
+      };
+    } else {
+      ctx.assets.dirs["docus:build"] = {
+        dir: 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"]) {
+    addServerMiddleware({
+      route: resolveApiRoute(api),
+      handle: resolveModule(`./server/api/${api}`, { paths: runtimeDir }).replace(/\.js$/, ".mjs")
+    });
+  }
+  nuxt.options.publicRuntimeConfig.$docus = {
+    apiBase: options.apiBase,
+    tagMap: options.transformers.markdown.tagMap
+  };
+  addPlugin(resolveModule("./content", { paths: templateDir }));
+};
+
+const index = 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 installModule(nuxt2, "@nuxt/image");
+  }
+}));
+
+export { buildExternals, index as default, defineDocusConfig, defineThemeConfig, loadConfig, loadNuxtIgnoreList, loadTheme, resolveApiRoute, writeConfig };