docus 1.0.7 → 2.1.0

package/dist/runtime/app/components/DocusContent.vue

@@ -0,0 +1,215 @@
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _scule = require("scule");
+
+var _propertyInformation = require("property-information");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const rootKeys = ["class-name", "class", "className", "style"];
+const rxOn = /^@|^v-on:/;
+const rxBind = /^:|^v-bind:/;
+const rxModel = /^v-model/;
+const nativeInputs = ["select", "textarea", "input"];
+
+const number = d => +d;
+
+const trim = d => d.trim();
+
+const noop = d => d;
+
+const lazyComponents = new Set();
+
+function valueInContext(code, context) {
+  return code.split(".").reduce((o, k) => o && o[k], context);
+}
+
+function evalInContext(code, context) {
+  let result = valueInContext(code, context);
+
+  if (typeof result === "undefined") {
+    try {
+      result = JSON.parse(code);
+    } catch (e) {
+      console.error(`Error evaluating ${code}`, e);
+      result = code;
+    }
+  }
+
+  return result;
+}
+
+function propsToData(node, doc) {
+  const {
+    tag = "",
+    props = {}
+  } = node;
+  return Object.keys(props).reduce(function (data, key) {
+    const k = key.replace(/.*:/, "");
+    let obj = rootKeys.includes(k) ? data : data.attrs;
+    const value = props[key];
+    const {
+      attribute
+    } = (0, _propertyInformation.find)(_propertyInformation.html, key);
+    const native = nativeInputs.includes(tag);
+
+    if (rxModel.test(key) && value in doc && !native) {
+      const mods = key.replace(rxModel, "").split(".").filter(d => d).reduce((d, k2) => {
+        d[k2] = true;
+        return d;
+      }, {});
+      const field = "value";
+      const event = mods.lazy ? "change" : "input";
+      const processor = mods.number ? number : mods.trim ? trim : noop;
+      obj[field] = evalInContext(value, doc);
+      data.on = data.on || {};
+
+      data.on[event] = e => doc[value] = processor(e);
+    } else if (key === "v-bind") {
+      const val = evalInContext(value, doc);
+      obj = Object.assign(obj, val);
+    } else if (rxOn.test(key)) {
+      key = key.replace(rxOn, "");
+      data.on = data.on || {};
+
+      data.on[key] = () => evalInContext(value, doc);
+    } else if (rxBind.test(key)) {
+      key = key.replace(rxBind, "");
+      obj[key] = evalInContext(value, doc);
+    } else if (Array.isArray(value)) {
+      obj[attribute] = value.join(" ");
+    } else if (typeof value === "string") {
+      obj[attribute] = valueInContext(value, doc) || value;
+    } else {
+      obj[attribute] = value;
+    }
+
+    return data;
+  }, {
+    attrs: {}
+  });
+}
+
+function slotsToData(node, h, doc) {
+  const data = {};
+  const children = node.children || [];
+  children.forEach(child => {
+    if (!isTemplate(child) || isDefaultTemplate(child)) return;
+    data.scopedSlots = data.scopedSlots || {};
+    const template = child;
+    const name = getSlotName(template);
+    const vDomTree = template.content.map(tmplNode => processNode(tmplNode, h, doc));
+
+    data.scopedSlots[name] = function () {
+      return vDomTree;
+    };
+  });
+  return data;
+}
+
+function processNode(node, h, doc) {
+  if (node.type === "text") return node.value;
+  const slotData = slotsToData(node || {}, h, doc);
+  const propData = propsToData(node || {}, doc);
+  const data = Object.assign({}, slotData, propData);
+  const children = [];
+
+  for (const child of node.children) {
+    if (isTemplate(child) && !isDefaultTemplate(child)) continue;
+    const processQueue = isDefaultTemplate(child) ? child.content : [child];
+    children.push(...processQueue.map(node2 => processNode(node2, h, doc)));
+  }
+
+  if (process.server && typeof _vue.default.component((0, _scule.pascalCase)(node.tag)) === "function") {
+    lazyComponents.add((0, _scule.pascalCase)(node.tag));
+  }
+
+  return h(node.tag, data, children);
+}
+
+const DEFAULT_SLOT = "default";
+
+function isDefaultTemplate(node) {
+  return isTemplate(node) && getSlotName(node) === DEFAULT_SLOT;
+}
+
+function isTemplate(node) {
+  return node.tag === "template";
+}
+
+function getSlotName(node) {
+  let name = "";
+
+  for (const propName of Object.keys(node.props || {})) {
+    if (!propName.startsWith("#") && !propName.startsWith("v-slot:")) continue;
+    name = propName.split(/[:#]/, 2)[1];
+    break;
+  }
+
+  return name || DEFAULT_SLOT;
+}
+
+var _default = {
+  name: "DocusContent",
+  functional: true,
+  props: {
+    document: {
+      type: [Object, String],
+      required: true
+    },
+    tag: {
+      type: String,
+      default: void 0
+    }
+  },
+
+  render(h, {
+    data,
+    props,
+    parent,
+    _v
+  }) {
+    const {
+      tag,
+      document
+    } = props;
+    if (!document) return;
+    if (typeof document === "string") return _v(document);
+    let body = document.body || document;
+    body = body.ast || body;
+    let classes = [];
+
+    if (Array.isArray(data.class)) {
+      classes = data.class;
+    } else if (typeof data.class === "object") {
+      const keys = Object.keys(data.class);
+      classes = keys.filter(key => data.class[key]);
+    } else {
+      classes = [data.class];
+    }
+
+    data.class = classes;
+    data.props = Object.assign({ ...body.props
+    }, data.props);
+    const children = (body.children || []).map(child => processNode(child, h, document));
+
+    if (process.server) {
+      ;
+      parent.$root.context.beforeSerialize(nuxtState => {
+        if (nuxtState.fetch._lazyComponents) lazyComponents.forEach(name => nuxtState.fetch._lazyComponents.add(name));else nuxtState.fetch._lazyComponents = lazyComponents;
+      });
+    }
+
+    return h(tag || body.tag || "div", data, children);
+  }
+
+};
+module.exports = _default;</script>

package/dist/runtime/app/components/DocusContent.vue.d.ts

@@ -0,0 +1,25 @@
+import type { CreateElement, RenderContext } from 'vue';
+declare const _default: {
+    name: string;
+    functional: boolean;
+    props: {
+        /**
+         *
+         */
+        document: {
+            type: (StringConstructor | ObjectConstructor)[];
+            required: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: any;
+        };
+    };
+    render(h: CreateElement, { data, props, parent, _v }: RenderContext<import("vue/types/options").DefaultProps> & {
+        _v: any;
+    }): any;
+};
+/**
+ * DocusContent component
+ */
+export default _default;

package/dist/runtime/app/components/Error.vue

@@ -0,0 +1,19 @@
+<template>
+  <div>{{ error.message }}</div>
+</template>
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _default = {
+  props: {
+    error: {
+      type: Object,
+      required: true
+    }
+  }
+};
+module.exports = _default;</script>

package/dist/runtime/app/components/Error.vue.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    namespace props {
+        namespace error {
+            const type: ObjectConstructor;
+            const required: boolean;
+        }
+    }
+}
+export default _default;

package/dist/runtime/app/components/Markdown.vue

@@ -0,0 +1,56 @@
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("@docus/mdc/utils");
+
+var _default = {
+  name: "Markdown",
+  functional: true,
+  props: {
+    use: {
+      type: [String, Object, Function, Array],
+      default: "default"
+    },
+    unwrap: {
+      type: String,
+      default: ""
+    }
+  },
+  render: (_, ctx) => {
+    const slot = ctx.props.use || "default";
+    let node = typeof slot === "string" ? ctx.parent.$scopedSlots[slot] || ctx.parent.$slots[slot] || ctx.parent.$parent?.$scopedSlots[slot] || ctx.parent.$parent?.$slots[slot] : slot;
+    if (typeof node === "function") node = node();
+    if (typeof node === "string") return [node];
+
+    if (node && ctx.props.unwrap) {
+      const tags = (0, _utils.expandTags)(ctx.props.unwrap.split(/[,\s]/), ctx.parent.$config.$docus.tagMap);
+      const first = Array.isArray(node) && node[0];
+      const requireSplitor = ctx.scopedSlots.between && first && !first.text && !["span", "strong", "em", "a", "code"].some(tag => (0, _utils.isTag)(first, tag));
+
+      if (requireSplitor) {
+        node = node.flatMap((n, i) => i === 0 ? (0, _utils.unwrap)(n, tags) : [ctx.scopedSlots.between(), (0, _utils.unwrap)(n, tags)]);
+      } else {
+        node = (0, _utils.flatUnwrap)(node, tags);
+      }
+    }
+
+    if (Array.isArray(node) && node.length > 1 && (ctx.data.staticClass || ctx.data.class)) {
+      console.warn("Markdown: `class` prop is ignored because there is multiple elements on component root.");
+      console.warn("Markdown: This is likely to happen when you use `unwrap` attribute.");
+    } else {
+      const tmpNode = Array.isArray(node) ? node[0] : node;
+
+      if (tmpNode?.data) {
+        Object.assign(tmpNode.data, ctx.data);
+      }
+    }
+
+    return node;
+  }
+};
+module.exports = _default;</script>

package/dist/runtime/app/components/Markdown.vue.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    name: string;
+    functional: boolean;
+    props: {
+        /**
+         * A slot name or function
+         */
+        use: {
+            type: (StringConstructor | ArrayConstructor | ObjectConstructor | FunctionConstructor)[];
+            default: string;
+        };
+        /**
+         *
+         */
+        unwrap: {
+            type: StringConstructor;
+            default: string;
+        };
+    };
+    render: (_: any, ctx: any) => any;
+};
+/**
+ * Markdown component
+ */
+export default _default;

package/dist/runtime/app/components/Page.vue

@@ -0,0 +1,29 @@
+<template>
+  <DocusContent :document="page" />
+</template>
+
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _app = require("#app");
+
+var _default = (0, _app.defineComponent)({
+  props: {
+    page: {
+      type: Object,
+      required: true
+    }
+  },
+  templateOptions: {
+    aside: false,
+    asideClass: "",
+    fluid: false
+  }
+});
+
+module.exports = _default;</script>

package/dist/runtime/app/components/Page.vue.d.ts

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

package/dist/runtime/app/components/Props.vue

@@ -0,0 +1,130 @@
+<template>
+  <ProseTable v-if="component">
+    <ProseThead>
+      <ProseTr>
+        <ProseTh>Prop</ProseTh>
+        <ProseTh>Type</ProseTh>
+        <ProseTh v-if="showRequired">Required</ProseTh>
+        <ProseTh v-if="showDefault">Default</ProseTh>
+        <ProseTh v-if="showValues">Values</ProseTh>
+        <ProseTh v-if="showDescription">Description</ProseTh>
+      </ProseTr>
+    </ProseThead>
+    <ProseTbody>
+      <ProseTr v-for="prop in properties" :key="prop.name">
+        <ProseTd>
+          <ProseCodeInline>{{ prop.name }}</ProseCodeInline>
+        </ProseTd>
+        <ProseTd>
+          <ProseCodeInline>{{ prop.type.join(' | ') }}</ProseCodeInline>
+        </ProseTd>
+        <ProseTd v-if="showRequired">{{ prop.required ? 'Yes' : 'No' }}</ProseTd>
+        <ProseTd v-if="showDefault">
+          <ProseCodeInline v-if="prop.default">{{ prop.default }}</ProseCodeInline>
+        </ProseTd>
+        <ProseTd v-if="showValues">
+          <ProseCodeInline v-if="prop.values">{{
+            prop.values && JSON.stringify(prop.values).replace(/,/g, ', ')
+          }}</ProseCodeInline>
+          <span v-else>-</span>
+        </ProseTd>
+        <ProseTd v-if="showDescription">
+          <div v-html="prop.description"></div>
+        </ProseTd>
+      </ProseTr>
+    </ProseTbody>
+  </ProseTable>
+</template>
+
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _compositionApi = require("@vue/composition-api");
+
+var _nuxtComponentMeta = require("nuxt-component-meta");
+
+var _default = (0, _compositionApi.defineComponent)({
+  props: {
+    of: {
+      type: String,
+      required: true
+    },
+    required: {
+      type: Boolean,
+      default: undefined,
+      description: 'Toggle required column.'
+    },
+    values: {
+      type: Boolean,
+      default: undefined,
+      description: 'Toggle values column.'
+    },
+    description: {
+      type: Boolean,
+      default: undefined,
+      description: 'Toggle description column.'
+    },
+    default: {
+      type: Boolean,
+      default: undefined,
+      description: 'Toggle default column.'
+    }
+  },
+
+  setup(props) {
+    const component = (0, _compositionApi.computed)(() => (0, _nuxtComponentMeta.getComponent)(props.of));
+    const properties = (0, _compositionApi.computed)(() => component.value.props.map(prop => ({
+      name: prop.name,
+      type: prop.type,
+      default: prop.default,
+      required: prop.required,
+      values: prop.values,
+      description: prop.description,
+      internal: prop.internal
+    })).filter(prop => prop.internal !== true));
+    const showRequired = (0, _compositionApi.computed)(() => {
+      if (props.required !== undefined) {
+        return props.required;
+      }
+
+      return properties.value?.find(prop => prop.required !== undefined);
+    });
+    const showValues = (0, _compositionApi.computed)(() => {
+      if (props.values !== undefined) {
+        return props.values;
+      }
+
+      return properties.value?.find(prop => prop.values);
+    });
+    const showDescription = (0, _compositionApi.computed)(() => {
+      if (props.description !== undefined) {
+        return props.description;
+      }
+
+      return properties.value?.find(prop => prop.description);
+    });
+    const showDefault = (0, _compositionApi.computed)(() => {
+      if (props.default !== undefined) {
+        return props.default;
+      }
+
+      return properties.value?.find(prop => prop.default);
+    });
+    return {
+      component,
+      properties,
+      showRequired,
+      showValues,
+      showDescription,
+      showDefault
+    };
+  }
+
+});
+
+module.exports = _default;</script>

package/dist/runtime/app/components/Props.vue.d.ts

@@ -0,0 +1,80 @@
+declare var _default: import("vue").ComponentOptions<import("vue").default, import("@vue/composition-api").ShallowUnwrapRef<{
+    component: import("@vue/composition-api").ComputedRef<import("nuxt-component-meta").ComponentMeta>;
+    properties: import("@vue/composition-api").ComputedRef<{
+        name: string;
+        type: string[];
+        default: string;
+        required: boolean;
+        values: string[];
+        description: string;
+        internal: any;
+    }[]>;
+    showRequired: import("@vue/composition-api").ComputedRef<any>;
+    showValues: import("@vue/composition-api").ComputedRef<any>;
+    showDescription: import("@vue/composition-api").ComputedRef<any>;
+    showDefault: import("@vue/composition-api").ComputedRef<any>;
+}> & import("@vue/composition-api").Data, {}, {}, {
+    of: {
+        type: StringConstructor;
+        required: true;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: any;
+        description: string;
+    };
+    values: {
+        type: BooleanConstructor;
+        default: any;
+        description: string;
+    };
+    description: {
+        type: BooleanConstructor;
+        default: any;
+        description: string;
+    };
+    default: {
+        type: BooleanConstructor;
+        default: any;
+        description: string;
+    };
+}, {
+    default: boolean;
+    of: string;
+    required: boolean;
+    description: boolean;
+    values: boolean;
+} & {}> & Omit<import("vue").VueConstructor<import("vue").default>, never> & (new (...args: any[]) => import("@vue/composition-api").ComponentRenderProxy<{
+    default: boolean;
+    of: string;
+    required: boolean;
+    description: boolean;
+    values: boolean;
+} & {}, import("@vue/composition-api").ShallowUnwrapRef<{
+    component: import("@vue/composition-api").ComputedRef<import("nuxt-component-meta").ComponentMeta>;
+    properties: import("@vue/composition-api").ComputedRef<{
+        name: string;
+        type: string[];
+        default: string;
+        required: boolean;
+        values: string[];
+        description: string;
+        internal: any;
+    }[]>;
+    showRequired: import("@vue/composition-api").ComputedRef<any>;
+    showValues: import("@vue/composition-api").ComputedRef<any>;
+    showDescription: import("@vue/composition-api").ComputedRef<any>;
+    showDefault: import("@vue/composition-api").ComputedRef<any>;
+}>, import("@vue/composition-api").Data, {}, {}, {}, {}, {}, {
+    default: boolean;
+    of: string;
+    required: boolean;
+    description: boolean;
+    values: boolean;
+} & {}, {
+    default: boolean;
+    required: boolean;
+    description: boolean;
+    values: boolean;
+}, true>);
+export default _default;

package/dist/runtime/app/components/prose/ProseA.vue

@@ -0,0 +1,41 @@
+<template>
+  <a v-if="remote || static" target="blank" :href="href"><slot /></a>
+  <NuxtLink v-else :to="href" :target="blank" :static="static">
+    <!-- TODO: implement static & remote logic -->
+    <slot />
+  </NuxtLink>
+</template>
+
+<script>
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _ufo = require("ufo");
+
+var _default = {
+  props: {
+    href: {
+      type: String,
+      default: ""
+    },
+    blank: {
+      type: Boolean,
+      default: false
+    },
+    static: {
+      type: Boolean,
+      default: false
+    }
+  },
+  computed: {
+    remote() {
+      return (0, _ufo.hasProtocol)(this.href, true);
+    }
+
+  }
+};
+module.exports = _default;</script>

package/dist/runtime/app/components/prose/ProseA.vue.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    props: {
+        href: {
+            type: StringConstructor;
+            default: string;
+        };
+        blank: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        /**
+         * `true` if `href` points to a static file
+         */
+        static: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    computed: {
+        remote(): boolean;
+    };
+};
+export default _default;

package/dist/runtime/app/components/prose/ProseBlockquote.vue

@@ -0,0 +1,5 @@
+<template>
+  <blockquote>
+    <slot />
+  </blockquote>
+</template>

package/dist/runtime/app/components/prose/ProseCode.vue

@@ -0,0 +1,5 @@
+<template>
+  <div class="docus-highlight group">
+    <slot />
+  </div>
+</template>

package/dist/runtime/app/components/prose/ProseCodeInline.vue

@@ -0,0 +1,5 @@
+<template>
+  <code>
+    <slot />
+  </code>
+</template>

package/dist/runtime/app/components/prose/ProseEm.vue

@@ -0,0 +1,5 @@
+<template>
+  <em>
+    <slot />
+  </em>
+</template>

package/dist/runtime/app/components/prose/ProseH1.vue

@@ -0,0 +1,3 @@
+<template>
+  <h1><slot /></h1>
+</template>