@ztl-uwu/nuxt-content 2.13.5

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

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/components/ContentDoc.vue

@@ -0,0 +1,108 @@
+<script>
+import { defineComponent, h, useSlots } from "vue";
+import { withTrailingSlash } from "ufo";
+import ContentRenderer from "./ContentRenderer.vue";
+import ContentQuery from "./ContentQuery.vue";
+import { useRuntimeConfig, useRoute, useContentHead } from "#imports";
+const ContentDoc = defineComponent({
+  name: "ContentDoc",
+  props: {
+    /**
+     * Renderer props
+     */
+    /**
+     * The tag to use for the renderer element if it is used.
+     * @default 'div'
+     */
+    tag: {
+      type: String,
+      required: false,
+      default: "div"
+    },
+    /**
+     * Whether or not to render the excerpt.
+     * @default false
+     */
+    excerpt: {
+      type: Boolean,
+      default: false
+    },
+    /**
+     * Query props
+     */
+    /**
+     * The path of the content to load from content source.
+     * @default useRoute().path
+     */
+    path: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    /**
+     * A query builder params object to be passed to <ContentQuery /> component.
+     */
+    query: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Whether or not to map the document data to the `head` property.
+     */
+    head: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    }
+  },
+  /**
+   * Document empty fallback
+   * @slot empty
+   */
+  /**
+   * Document not found fallback
+   * @slot not-found
+   */
+  render(ctx) {
+    const { contentHead } = useRuntimeConfig().public.content;
+    const slots = useSlots();
+    const { tag, excerpt, path, query, head } = ctx;
+    const shouldInjectContentHead = head === void 0 ? contentHead : head;
+    const contentQueryProps = {
+      ...query || {},
+      path: path || query?.path || withTrailingSlash(useRoute().path),
+      find: "one"
+    };
+    const emptyNode = (slot, data) => h("pre", null, JSON.stringify({ message: "You should use slots with <ContentDoc>", slot, data }, null, 2));
+    return h(
+      ContentQuery,
+      contentQueryProps,
+      {
+        // Default slot
+        default: slots?.default ? ({ data, refresh, isPartial }) => {
+          if (shouldInjectContentHead) {
+            useContentHead(data);
+          }
+          return slots.default?.({ doc: data, refresh, isPartial, excerpt, ...this.$attrs });
+        } : ({ data }) => {
+          if (shouldInjectContentHead) {
+            useContentHead(data);
+          }
+          return h(
+            ContentRenderer,
+            { value: data, excerpt, tag, ...this.$attrs },
+            // Forward local `empty` slots to ContentRenderer if it is used.
+            { empty: (bindings) => slots?.empty ? slots.empty(bindings) : emptyNode("default", data) }
+          );
+        },
+        // Empty slot
+        empty: (bindings) => slots?.empty?.(bindings) || h("p", null, "Document is empty, overwrite this content with #empty slot in <ContentDoc>."),
+        // Not Found slot
+        "not-found": (bindings) => slots?.["not-found"]?.(bindings) || h("p", null, "Document not found, overwrite this content with #not-found slot in <ContentDoc>.")
+      }
+    );
+  }
+});
+export default ContentDoc;
+</script>

package/dist/runtime/components/ContentDoc.vue.d.ts

@@ -0,0 +1,118 @@
+import { type PropType, type VNode } from 'vue';
+import type { ParsedContent, QueryBuilderParams } from '@nuxt/content';
+declare const ContentDoc: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * Renderer props
+     */
+    /**
+     * The tag to use for the renderer element if it is used.
+     * @default 'div'
+     */
+    tag: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Whether or not to render the excerpt.
+     * @default false
+     */
+    excerpt: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Query props
+     */
+    /**
+     * The path of the content to load from content source.
+     * @default useRoute().path
+     */
+    path: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
+    /**
+     * A query builder params object to be passed to <ContentQuery /> component.
+     */
+    query: {
+        type: PropType<QueryBuilderParams>;
+        required: false;
+        default: undefined;
+    };
+    /**
+     * Whether or not to map the document data to the `head` property.
+     */
+    head: {
+        type: BooleanConstructor;
+        required: false;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Renderer props
+     */
+    /**
+     * The tag to use for the renderer element if it is used.
+     * @default 'div'
+     */
+    tag: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Whether or not to render the excerpt.
+     * @default false
+     */
+    excerpt: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Query props
+     */
+    /**
+     * The path of the content to load from content source.
+     * @default useRoute().path
+     */
+    path: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
+    /**
+     * A query builder params object to be passed to <ContentQuery /> component.
+     */
+    query: {
+        type: PropType<QueryBuilderParams>;
+        required: false;
+        default: undefined;
+    };
+    /**
+     * Whether or not to map the document data to the `head` property.
+     */
+    head: {
+        type: BooleanConstructor;
+        required: false;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    path: string;
+    query: QueryBuilderParams;
+    head: boolean;
+    tag: string;
+    excerpt: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof ContentDoc & {
+    new (): {
+        $slots: {
+            default: (context: {
+                doc: ParsedContent;
+                refresh: () => Promise<void>;
+            }) => VNode[] | undefined;
+        };
+    };
+};
+export default _default;

package/dist/runtime/components/ContentList.vue

@@ -0,0 +1,59 @@
+<script>
+import { defineComponent, h, useSlots } from "vue";
+import ContentQuery from "./ContentQuery.vue";
+const emptyNode = (slot, data) => h("pre", null, JSON.stringify({ message: "You should use slots with <ContentList>", slot, data }, null, 2));
+const ContentList = defineComponent({
+  name: "ContentList",
+  props: {
+    /**
+     * Query props
+     */
+    /**
+     * The path of the content to load from content source.
+     * @default '/'
+     */
+    path: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    /**
+     * A query builder params object to be passed to <ContentQuery /> component.
+     */
+    query: {
+      type: Object,
+      required: false,
+      default: void 0
+    }
+  },
+  /**
+   * Content empty fallback
+   * @slot empty
+   */
+  /**
+   * Content not found fallback
+   * @slot not-found
+   */
+  render(ctx) {
+    const slots = useSlots();
+    const { path, query } = ctx;
+    const contentQueryProps = {
+      ...query || {},
+      path: path || query?.path || "/"
+    };
+    return h(
+      ContentQuery,
+      contentQueryProps,
+      {
+        // Default slot
+        default: slots?.default ? ({ data, refresh, isPartial }) => slots.default({ list: data, refresh, isPartial, ...this.$attrs }) : (bindings) => emptyNode("default", bindings.data),
+        // Empty slot
+        empty: (bindings) => slots?.empty ? slots.empty(bindings) : emptyNode("default", bindings?.data),
+        // Not Found slot
+        "not-found": (bindings) => slots?.["not-found"] ? slots?.["not-found"]?.(bindings) : emptyNode("not-found", bindings?.data)
+      }
+    );
+  }
+});
+export default ContentList;
+</script>

package/dist/runtime/components/ContentList.vue.d.ts

@@ -0,0 +1,59 @@
+import { type PropType, type VNode } from 'vue';
+import type { ParsedContent, QueryBuilderParams } from '@nuxt/content';
+declare const ContentList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * Query props
+     */
+    /**
+     * The path of the content to load from content source.
+     * @default '/'
+     */
+    path: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
+    /**
+     * A query builder params object to be passed to <ContentQuery /> component.
+     */
+    query: {
+        type: PropType<QueryBuilderParams>;
+        required: false;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Query props
+     */
+    /**
+     * The path of the content to load from content source.
+     * @default '/'
+     */
+    path: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
+    /**
+     * A query builder params object to be passed to <ContentQuery /> component.
+     */
+    query: {
+        type: PropType<QueryBuilderParams>;
+        required: false;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    path: string;
+    query: QueryBuilderParams;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof ContentList & {
+    new (): {
+        $slots: {
+            default: (context: {
+                list: ParsedContent[];
+                refresh: () => Promise<void>;
+            }) => VNode[] | undefined;
+        };
+    };
+};
+export default _default;

package/dist/runtime/components/ContentNavigation.vue

@@ -0,0 +1,61 @@
+<script>
+import { toRefs, defineComponent, h, useSlots, computed } from "vue";
+import { hash } from "ohash";
+import { useAsyncData, fetchContentNavigation, useState, useContent } from "#imports";
+import { NuxtLink } from "#components";
+const ContentNavigation = defineComponent({
+  name: "ContentNavigation",
+  props: {
+    /**
+     * A query to be passed to `fetchContentNavigation()`.
+     */
+    query: {
+      type: Object,
+      required: false,
+      default: void 0
+    }
+  },
+  async setup(props) {
+    const {
+      query
+    } = toRefs(props);
+    const queryBuilder = computed(() => {
+      if (typeof query.value?.params === "function") {
+        return query.value.params();
+      }
+      return query.value;
+    });
+    if (!queryBuilder.value && useState("dd-navigation").value) {
+      const { navigation: navigation2 } = useContent();
+      return { navigation: navigation2 };
+    }
+    const { data: navigation } = await useAsyncData(
+      `content-navigation-${hash(queryBuilder.value)}`,
+      () => fetchContentNavigation(queryBuilder.value)
+    );
+    return { navigation };
+  },
+  /**
+   * Navigation empty fallback
+   * @slot empty
+   */
+  render(ctx) {
+    const slots = useSlots();
+    const { navigation } = ctx;
+    const renderLink = (link) => h(NuxtLink, { to: link._path }, () => link.title);
+    const renderLinks = (data, level) => h(
+      "ul",
+      level ? { "data-level": level } : null,
+      data.map((link) => {
+        if (link.children) {
+          return h("li", null, [renderLink(link), renderLinks(link.children, level + 1)]);
+        }
+        return h("li", null, renderLink(link));
+      })
+    );
+    const defaultNode = (data) => renderLinks(data, 0);
+    return slots?.default ? slots.default({ navigation, ...this.$attrs }) : defaultNode(navigation);
+  }
+});
+export default ContentNavigation;
+</script>

package/dist/runtime/components/ContentNavigation.vue.d.ts

@@ -0,0 +1,35 @@
+import { type PropType, type VNode } from 'vue';
+import type { NavItem, QueryBuilderParams, QueryBuilder } from '@nuxt/content';
+declare const ContentNavigation: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * A query to be passed to `fetchContentNavigation()`.
+     */
+    query: {
+        type: PropType<QueryBuilderParams | QueryBuilder>;
+        required: false;
+        default: undefined;
+    };
+}>, {
+    navigation: import("vue").Ref<NavItem[] | null, NavItem[] | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * A query to be passed to `fetchContentNavigation()`.
+     */
+    query: {
+        type: PropType<QueryBuilderParams | QueryBuilder>;
+        required: false;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    query: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof ContentNavigation & {
+    new (): {
+        $slots: {
+            default: ({ navigation }: {
+                navigation: NavItem[];
+            }) => VNode[] | undefined;
+        };
+    };
+};
+export default _default;

package/dist/runtime/components/ContentQuery.vue

@@ -0,0 +1,212 @@
+<script>
+import { hash } from "ohash";
+import { toRefs, defineComponent, h, useSlots, watch } from "vue";
+import { computed, useAsyncData, queryContent, useRuntimeConfig } from "#imports";
+const ContentQuery = defineComponent({
+  name: "ContentQuery",
+  props: {
+    /**
+     * The path of the content to load from content source.
+     */
+    path: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Select a subset of fields
+     */
+    only: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Remove a subset of fields
+     */
+    without: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Filter results
+     */
+    where: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Sort results
+     */
+    sort: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Limit number of results
+     */
+    limit: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Skip number of results
+     */
+    skip: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    /**
+     * Filter contents based on locale
+     */
+    locale: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    /**
+     * A type of query to be made.
+     */
+    find: {
+      type: String,
+      required: false,
+      default: void 0
+    }
+  },
+  async setup(props) {
+    const {
+      path,
+      only,
+      without,
+      where,
+      sort,
+      limit,
+      skip,
+      locale,
+      find
+    } = toRefs(props);
+    const isPartial = computed(() => path.value?.includes("/_"));
+    const legacy = !useRuntimeConfig().public.content.experimental.advanceQuery;
+    watch(() => props, () => refresh(), { deep: true });
+    const resolveResult = (result) => {
+      if (legacy) {
+        if (result?.surround) {
+          return result.surround;
+        }
+        return result?._id || Array.isArray(result) ? result : result?.result;
+      }
+      return result.result;
+    };
+    const { data, refresh } = await useAsyncData(
+      `content-query-${hash(props)}`,
+      () => {
+        let queryBuilder;
+        if (path.value) {
+          queryBuilder = queryContent(path.value);
+        } else {
+          queryBuilder = queryContent();
+        }
+        if (only.value) {
+          queryBuilder = queryBuilder.only(only.value);
+        }
+        if (without.value) {
+          queryBuilder = queryBuilder.without(without.value);
+        }
+        if (where.value) {
+          queryBuilder = queryBuilder.where(where.value);
+        }
+        if (sort.value) {
+          queryBuilder = queryBuilder.sort(sort.value);
+        }
+        if (limit.value) {
+          queryBuilder = queryBuilder.limit(limit.value);
+        }
+        if (skip.value) {
+          queryBuilder = queryBuilder.skip(skip.value);
+        }
+        if (locale.value) {
+          queryBuilder = queryBuilder.where({ _locale: locale.value });
+        }
+        if (find.value === "one") {
+          return queryBuilder.findOne().then(resolveResult);
+        }
+        if (find.value === "surround") {
+          if (!path.value) {
+            console.warn("[Content] Surround queries requires `path` prop to be set.");
+            console.warn("[Content] Query without `path` will return regular `find()` results.");
+            return queryBuilder.find().then(resolveResult);
+          }
+          if (legacy) {
+            return queryBuilder.findSurround(path.value);
+          } else {
+            return queryBuilder.withSurround(path.value).findOne().then(resolveResult);
+          }
+        }
+        return queryBuilder.find().then(resolveResult);
+      }
+    );
+    return {
+      isPartial,
+      data,
+      refresh
+    };
+  },
+  /**
+   * Content not found fallback
+   * @slot not-found
+   */
+  render(ctx) {
+    const slots = useSlots();
+    const {
+      // Setup
+      data,
+      refresh,
+      isPartial,
+      // Props
+      path,
+      only,
+      without,
+      where,
+      sort,
+      limit,
+      skip,
+      locale,
+      find
+    } = ctx;
+    const props = {
+      path,
+      only,
+      without,
+      where,
+      sort,
+      limit,
+      skip,
+      locale,
+      find
+    };
+    if (props.find === "one") {
+      if (!data && slots?.["not-found"]) {
+        return slots["not-found"]({ props, ...this.$attrs });
+      }
+      if (slots?.empty && data?._type === "markdown" && !data?.body?.children.length) {
+        return slots.empty({ props, ...this.$attrs });
+      }
+    } else if (!data || !data.length) {
+      if (slots?.["not-found"]) {
+        return slots["not-found"]({ props, ...this.$attrs });
+      }
+    }
+    if (slots?.default) {
+      return slots.default({ data, refresh, isPartial, props, ...this.$attrs });
+    }
+    const emptyNode = (slot, data2) => h("pre", null, JSON.stringify({ message: "You should use slots with <ContentQuery>!", slot, data: data2 }, null, 2));
+    return emptyNode("default", { data, props, isPartial });
+  }
+});
+export default ContentQuery;
+</script>