docus 1.0.7 → 2.1.0

package/dist/runtime/app/composables/theme-colors.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._variants = void 0;
+exports.getColors = getColors;
+exports.hexValue = hexValue;
+exports.parseColor = parseColor;
+exports.shade = shade;
+exports.tint = tint;
+exports.withTint = exports.withShade = void 0;
+
+function parseColor(color = "") {
+  if (typeof color !== "string") {
+    throw new TypeError("Color should be string!");
+  }
+
+  const hexMatch = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+
+  if (hexMatch) {
+    return hexMatch.splice(1).map(c => parseInt(c, 16));
+  }
+
+  const hexMatchShort = /^#?([a-f\d])([a-f\d])([a-f\d])$/i.exec(color);
+
+  if (hexMatchShort) {
+    return hexMatchShort.splice(1).map(c => parseInt(c + c, 16));
+  }
+
+  if (color.includes(",")) {
+    return color.split(",").map(p => parseInt(p));
+  }
+
+  throw new Error("Invalid color format! Use #ABC or #AABBCC or r,g,b");
+}
+
+function hexValue(components) {
+  return "#" + components.map(c => `0${c.toString(16).toUpperCase()}`.slice(-2)).join("");
+}
+
+function tint(components, intensity) {
+  return components.map(c => Math.round(c + (255 - c) * intensity));
+}
+
+function shade(components, intensity) {
+  return components.map(c => Math.round(c * intensity));
+}
+
+const withTint = intensity => hex => tint(hex, intensity);
+
+exports.withTint = withTint;
+
+const withShade = intensity => hex => shade(hex, intensity);
+
+exports.withShade = withShade;
+const _variants = {
+  50: withTint(0.95),
+  100: withTint(0.9),
+  200: withTint(0.75),
+  300: withTint(0.6),
+  400: withTint(0.3),
+  500: c => c,
+  600: withShade(0.9),
+  700: withShade(0.6),
+  800: withShade(0.45),
+  900: withShade(0.3)
+};
+exports._variants = _variants;
+
+function getColors(color, variants = _variants) {
+  const colors = {};
+  const components = parseColor(color);
+
+  for (const [name, fn] of Object.entries(variants)) {
+    colors[name] = hexValue(fn(components));
+  }
+
+  return colors;
+}

package/dist/runtime/app/composables/theme-colors.mjs

@@ -0,0 +1,48 @@
+export function parseColor(color = "") {
+  if (typeof color !== "string") {
+    throw new TypeError("Color should be string!");
+  }
+  const hexMatch = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
+  if (hexMatch) {
+    return hexMatch.splice(1).map((c) => parseInt(c, 16));
+  }
+  const hexMatchShort = /^#?([a-f\d])([a-f\d])([a-f\d])$/i.exec(color);
+  if (hexMatchShort) {
+    return hexMatchShort.splice(1).map((c) => parseInt(c + c, 16));
+  }
+  if (color.includes(",")) {
+    return color.split(",").map((p) => parseInt(p));
+  }
+  throw new Error("Invalid color format! Use #ABC or #AABBCC or r,g,b");
+}
+export function hexValue(components) {
+  return "#" + components.map((c) => `0${c.toString(16).toUpperCase()}`.slice(-2)).join("");
+}
+export function tint(components, intensity) {
+  return components.map((c) => Math.round(c + (255 - c) * intensity));
+}
+export function shade(components, intensity) {
+  return components.map((c) => Math.round(c * intensity));
+}
+export const withTint = (intensity) => (hex) => tint(hex, intensity);
+export const withShade = (intensity) => (hex) => shade(hex, intensity);
+export const _variants = {
+  50: withTint(0.95),
+  100: withTint(0.9),
+  200: withTint(0.75),
+  300: withTint(0.6),
+  400: withTint(0.3),
+  500: (c) => c,
+  600: withShade(0.9),
+  700: withShade(0.6),
+  800: withShade(0.45),
+  900: withShade(0.3)
+};
+export function getColors(color, variants = _variants) {
+  const colors = {};
+  const components = parseColor(color);
+  for (const [name, fn] of Object.entries(variants)) {
+    colors[name] = hexValue(fn(components));
+  }
+  return colors;
+}

package/dist/runtime/app/composables/websocket.d.ts

@@ -0,0 +1,3 @@
+export declare function useWebSocket(base: string): {
+    connect: (retry?: boolean) => void;
+};

package/dist/runtime/app/composables/websocket.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useWebSocket = useWebSocket;
+const logger = {
+  log: (...args) => console.log("[Docus]", ...args),
+  warn: (...args) => console.warn("[Docus]", ...args)
+};
+let $nuxt;
+let ws = null;
+
+function useWebSocket(base) {
+  if (!window.WebSocket) {
+    logger.warn("Could not activate hot reload, your browser does not support WebSocket.");
+    return;
+  }
+
+  window.onNuxtReady(_nuxt => {
+    $nuxt = _nuxt;
+  });
+
+  const onMessage = async message => {
+    try {
+      const data = JSON.parse(message.data);
+      if (!data) return;
+      $nuxt.$emit("content:update", data);
+
+      if ($nuxt.$store && $nuxt.$store._actions.nuxtServerInit) {
+        await $nuxt.$store.dispatch("nuxtServerInit", $nuxt.$options.context);
+      }
+
+      $nuxt.refresh();
+    } catch (err) {}
+  };
+
+  const onOpen = () => logger.log("WS connected!");
+
+  const onError = e => {
+    switch (e.code) {
+      case "ECONNREFUSED":
+        connect(true);
+        break;
+
+      default:
+        logger.warn("WS Error:", e);
+        break;
+    }
+  };
+
+  const onClose = e => {
+    if (e.code === 1e3 || e.code === 1005) {
+      logger.log("WS closed!");
+    } else {
+      connect(true);
+    }
+  };
+
+  const connect = (retry = false) => {
+    if (retry) {
+      logger.log("WS reconnecting..");
+      setTimeout(connect, 1e3);
+      return;
+    }
+
+    const wsURL = `${base}/ws`;
+    logger.log(`WS connect to ${wsURL}`);
+    ws = new WebSocket(wsURL);
+    ws.onopen = onOpen;
+    ws.onmessage = onMessage;
+    ws.onerror = onError;
+    ws.onclose = onClose;
+  };
+
+  return {
+    connect
+  };
+}

package/dist/runtime/app/composables/websocket.mjs

@@ -0,0 +1,63 @@
+const logger = {
+  log: (...args) => console.log("[Docus]", ...args),
+  warn: (...args) => console.warn("[Docus]", ...args)
+};
+let $nuxt;
+let ws = null;
+export function useWebSocket(base) {
+  if (!window.WebSocket) {
+    logger.warn("Could not activate hot reload, your browser does not support WebSocket.");
+    return;
+  }
+  window.onNuxtReady((_nuxt) => {
+    $nuxt = _nuxt;
+  });
+  const onMessage = async (message) => {
+    try {
+      const data = JSON.parse(message.data);
+      if (!data)
+        return;
+      $nuxt.$emit("content:update", data);
+      if ($nuxt.$store && $nuxt.$store._actions.nuxtServerInit) {
+        await $nuxt.$store.dispatch("nuxtServerInit", $nuxt.$options.context);
+      }
+      $nuxt.refresh();
+    } catch (err) {
+    }
+  };
+  const onOpen = () => logger.log("WS connected!");
+  const onError = (e) => {
+    switch (e.code) {
+      case "ECONNREFUSED":
+        connect(true);
+        break;
+      default:
+        logger.warn("WS Error:", e);
+        break;
+    }
+  };
+  const onClose = (e) => {
+    if (e.code === 1e3 || e.code === 1005) {
+      logger.log("WS closed!");
+    } else {
+      connect(true);
+    }
+  };
+  const connect = (retry = false) => {
+    if (retry) {
+      logger.log("WS reconnecting..");
+      setTimeout(connect, 1e3);
+      return;
+    }
+    const wsURL = `${base}/ws`;
+    logger.log(`WS connect to ${wsURL}`);
+    ws = new WebSocket(wsURL);
+    ws.onopen = onOpen;
+    ws.onmessage = onMessage;
+    ws.onerror = onError;
+    ws.onclose = onClose;
+  };
+  return {
+    connect
+  };
+}

package/dist/runtime/app/layouts/default.vue

@@ -0,0 +1,5 @@
+<template>
+  <AppLayout>
+    <Nuxt />
+  </AppLayout>
+</template>

package/dist/runtime/app/layouts/error.vue

@@ -0,0 +1,33 @@
+<template>
+  <Component :is="template" :error="error" />
+</template>
+
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _default = {
+  props: {
+    error: {
+      type: Object,
+      required: true
+    }
+  },
+
+  data() {
+    return {
+      template: 'Error'
+    };
+  },
+
+  head() {
+    return {
+      title: this.error.message
+    };
+  }
+
+};
+module.exports = _default;</script>

package/dist/runtime/app/layouts/error.vue.d.ts

@@ -0,0 +1,21 @@
+declare namespace _default {
+    namespace props {
+        namespace error {
+            const type: ObjectConstructor;
+            const required: boolean;
+        }
+    }
+    function data(): {
+        template: string;
+    };
+    function data(): {
+        template: string;
+    };
+    function head(): {
+        title: any;
+    };
+    function head(): {
+        title: any;
+    };
+}
+export default _default;

package/dist/runtime/app/pages/_.vue

@@ -0,0 +1,222 @@
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _ufo = require("ufo");
+
+var _app = require("#app");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _app.defineComponent)({
+  name: "PageSlug",
+
+  middleware({
+    app,
+    params,
+    redirect
+  }) {
+    if (params.pathMatch === "index") redirect(app.localePath("/"));
+  },
+
+  async asyncData(context) {
+    const {
+      app: {
+        i18n,
+        localePath
+      },
+      route,
+      params,
+      error,
+      redirect,
+      $docus
+    } = context;
+    const language = i18n.locale;
+    const {
+      config,
+      theme,
+      navigation,
+      layout,
+      page: currentPage
+    } = $docus;
+    const themeLayout = theme.value?.layout || {};
+    let templateOptions = { ...themeLayout,
+      ...layout.value
+    };
+    const to = (0, _ufo.withoutTrailingSlash)(`/${params.pathMatch || ""}`) || "/";
+    const draft = false;
+    const [match] = await $docus.content.search({
+      deep: true
+    }).where({
+      language,
+      to,
+      draft,
+      page: {
+        $ne: false
+      }
+    }).fetch();
+    if (!match) return error({
+      statusCode: 404,
+      message: "404 - Page not found"
+    });
+    const page = await $docus.content.get(match.id);
+    page.template = navigation.getPageTemplate(page);
+
+    let component = _vue.default.component(page.template);
+
+    if (component) {
+      try {
+        if (typeof component === "function" && !component.options) {
+          component = await component();
+          if (!component.options) component = _vue.default.extend(component);
+        }
+      } catch (e) {
+        console.error(e);
+        component = new component({
+          props: {
+            page
+          }
+        });
+      }
+
+      const componentTemplateOptions = component.options.templateOptions || component.extendOptions.templateOptions || component.sealedOptions.templateOptions || {};
+      if (templateOptions) templateOptions = { ...templateOptions,
+        ...componentTemplateOptions
+      };
+    }
+
+    if (match.layout) templateOptions = { ...templateOptions,
+      ...match.layout
+    };
+
+    if (process.server) {
+      layout.value = templateOptions;
+      currentPage.value = page;
+      navigation.currentPath = `/${route.params.pathMatch}`;
+    }
+
+    if (page.navigation && page.navigation.redirect) redirect(localePath(page.navigation.redirect));
+    return {
+      page,
+      templateOptions,
+      preview: config.value.preview
+    };
+  },
+
+  head() {
+    const head = {
+      title: this.page.title,
+      meta: [],
+      ...(this.page.head || {})
+    };
+    this.mergeMeta(head.meta, this.pageMeta);
+    return head;
+  },
+
+  computed: {
+    currentPath() {
+      return this.$docus.navigation.currentPath.value;
+    },
+
+    pageMeta() {
+      const config = this.$docus.config.value;
+      return [{
+        hid: "og:title",
+        property: "og:title",
+        content: this.page.title
+      }, {
+        hid: "twitter:title",
+        name: "twitter:title",
+        content: this.page.title
+      }, {
+        hid: "apple-mobile-web-app-title",
+        name: "apple-mobile-web-app-title",
+        content: config.title || ""
+      }, ...(this.page.description ? [{
+        hid: "description",
+        name: "description",
+        content: this.page.description
+      }, {
+        hid: "og:description",
+        property: "og:description",
+        content: this.page.description
+      }, {
+        hid: "twitter:description",
+        name: "twitter:description",
+        content: this.page.description
+      }] : [])];
+    }
+
+  },
+  watch: {
+    currentPath: {
+      handler() {
+        this.$docus.navigation.updateCurrentNav();
+      }
+
+    }
+  },
+
+  created() {
+    if (process.client) {
+      const {
+        layout,
+        page,
+        navigation
+      } = this.$docus;
+      layout.value = this.templateOptions;
+      page.value = this.page;
+      navigation.currentPath.value = `/${this.$route.params.pathMatch}`;
+    }
+  },
+
+  mounted() {
+    window.$nuxt.$on("docus:content:preview", this.updatePage);
+    if (this.page?.version) localStorage.setItem(`page-${this.page.slug}-version`, this.page.version);
+  },
+
+  unmounted() {
+    window.$nuxt.$off("docus:content:preview", this.updatePage);
+  },
+
+  methods: {
+    async updatePage({
+      key
+    }) {
+      if (key === this.page?.key) {
+        const $content = this.$docus.content;
+        const updatedPage = await $content.get(this.page.key);
+        Object.assign(this.page, updatedPage);
+      }
+    },
+
+    mergeMeta(to, from) {
+      from.forEach(newMeta => {
+        const key = newMeta.hid || newMeta.name || newMeta.property;
+        const index = to.findIndex(meta => meta.hid === key || meta.name === key || meta.property === key);
+
+        if (index < 0) {
+          to.push(newMeta);
+        }
+      });
+    }
+
+  },
+
+  render(h) {
+    return h(this.page.template, {
+      props: {
+        page: this.page
+      }
+    });
+  }
+
+});
+
+module.exports = _default;</script>

package/dist/runtime/app/pages/_.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/context.d.ts

@@ -0,0 +1 @@
+export declare const useDocusContext: () => DocusConfig;

package/dist/runtime/context.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDocusContext = void 0;
+
+var _unctx = require("unctx");
+
+var _options = _interopRequireDefault(require("#build/docus/options.mjs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const ctx = (0, _unctx.getContext)("docus_context");
+ctx.set(_options.default, true);
+const useDocusContext = ctx.use;
+exports.useDocusContext = useDocusContext;

package/dist/runtime/context.mjs

@@ -0,0 +1,5 @@
+import { getContext } from "unctx";
+import options from "#build/docus/options.mjs";
+const ctx = getContext("docus_context");
+ctx.set(options, true);
+export const useDocusContext = ctx.use;

package/dist/runtime/database/Query.d.ts

@@ -0,0 +1,18 @@
+import type { QueryBuilder, QueryBuilderParams } from 'types';
+/**
+ * Abstract query builder class, to be implemented by any provider.
+ */
+export declare abstract class BaseQueryBuilder<T> implements QueryBuilder<T> {
+    protected params: QueryBuilderParams;
+    only(keys: string | string[]): this;
+    without(keys: string | string[]): this;
+    sortBy(field: string, direction: 'asc' | 'desc'): this;
+    where(query: any): this;
+    surround(slugOrTo: string, options: {
+        before: number;
+        after: number;
+    }): this;
+    limit(count: number | string): this;
+    skip(count: number | string): this;
+    abstract fetch(params?: any): Promise<T | T[]>;
+}

package/dist/runtime/database/Query.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseQueryBuilder = void 0;
+
+class BaseQueryBuilder {
+  constructor() {
+    this.params = {
+      skip: 0,
+      limit: 0,
+      only: [],
+      without: [],
+      sortBy: [],
+      where: {}
+    };
+  }
+
+  only(keys) {
+    this.params.only = Array.isArray(keys) ? keys : [keys];
+    return this;
+  }
+
+  without(keys) {
+    this.params.without = Array.isArray(keys) ? keys : [keys];
+    return this;
+  }
+
+  sortBy(field, direction) {
+    this.params.sortBy.push([field, direction]);
+    return this;
+  }
+
+  where(query) {
+    this.params.where = query;
+    return this;
+  }
+
+  surround(slugOrTo, options) {
+    this.params.surround = {
+      slugOrTo,
+      options
+    };
+    return this;
+  }
+
+  limit(count) {
+    if (typeof count === "string") {
+      count = parseInt(count);
+    }
+
+    this.params.limit = count;
+    return this;
+  }
+
+  skip(count) {
+    if (typeof count === "string") {
+      count = parseInt(count);
+    }
+
+    this.params.skip = count;
+    return this;
+  }
+
+}
+
+exports.BaseQueryBuilder = BaseQueryBuilder;