@lupinum/ginko-content 0.1.0

package/dist/public/provider.js

@@ -0,0 +1,6 @@
+export const contentProviderResultMarker = "__ginkoContentProviderResult";
+export const withContentCache = (data, cache) => ({
+  [contentProviderResultMarker]: true,
+  data,
+  cache
+});

package/dist/public/server

@@ -0,0 +1 @@
+export * from './server.js'

package/dist/public/server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Server-side public API surface (Nitro / H3 contexts).
+ *
+ * The unified query API (ADR-0016) is the same on the server as on the client
+ * — same option shapes, same handle objects, same types. Pure functions are
+ * re-exported here for ergonomic discoverability from `@lupinum/ginko-content/server`.
+ */
+export { one, many, paginate, backlinks, resolveOne, variants, tree, neighbors, createServerContentQueryContext } from '../runtime/server/query-api.js';
+export { getCollectionPath } from '../runtime/query/routes.js';
+export type { CollectionPathOptions } from '../runtime/query/routes.js';
+export type { QueryWhere, QueryOperators, ContentSelector, ContentPageResult, ContentQueryBuilderParams, ContentRouteMeta, ContentSearchSection, ContentResolvedMeta, ContentSitemapEntry, BacklinkFields, BacklinkSource, BacklinksOptions, BacklinksResult, LocaleFallback, DocumentFromHandle, OneOptions, ManyOptions, PaginationOptions, PaginationResult, PopulateSpec, PopulatedDocument, ResolveOneOptions, ResolveOneResult, LocalizedDoc, LocalePathEntry, NeighborsOptions, NeighborsResult, SortSpec, TreeOptions, VariantsOptions, ContentVariant } from '../types/query.js';
+export type { ContentQueryResponse } from '../types/api.js';
+export declare const queryCollectionsSitemapEntries: typeof import('../runtime/server/sitemap-provider.js').queryCollectionsSitemapEntries;
+export { createContentProviderError } from './provider-errors.js';
+export { contentCacheHeaders, noopContentCache, vercelContentCache, type VercelContentCacheOptions } from '../runtime/server/cache-adapters.js';
+export { clearContentCacheHint, collectContentCacheHint, getContentCacheHint } from '../runtime/server/cache-hints.js';
+export type { ContentCacheAdapter, ContentCacheHint, ContentCacheHintInput, ContentCacheInvalidateInput, ContentProvider, ContentProviderCapabilities, ContentProviderResult, MaybeContentProviderResult } from './provider.js';
+export { withContentCache } from './provider.js';
+export type { ContentProviderErrorCode } from './provider-errors.js';

package/dist/public/server.js

@@ -0,0 +1,28 @@
+export {
+  one,
+  many,
+  paginate,
+  backlinks,
+  resolveOne,
+  variants,
+  tree,
+  neighbors,
+  createServerContentQueryContext
+} from "../runtime/server/query-api.js";
+export { getCollectionPath } from "../runtime/query/routes.js";
+export const queryCollectionsSitemapEntries = async (...args) => {
+  const { queryCollectionsSitemapEntries: queryCollectionsSitemapEntries2 } = await import("../runtime/server/sitemap-provider.js");
+  return await queryCollectionsSitemapEntries2(...args);
+};
+export { createContentProviderError } from "./provider-errors.js";
+export {
+  contentCacheHeaders,
+  noopContentCache,
+  vercelContentCache
+} from "../runtime/server/cache-adapters.js";
+export {
+  clearContentCacheHint,
+  collectContentCacheHint,
+  getContentCacheHint
+} from "../runtime/server/cache-hints.js";
+export { withContentCache } from "./provider.js";

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

@@ -0,0 +1,62 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: ObjectConstructor;
+        required: false;
+        default: () => {};
+    };
+    excerpt: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    class: {
+        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: boolean;
+    };
+}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: ObjectConstructor;
+        required: false;
+        default: () => {};
+    };
+    excerpt: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    class: {
+        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    excerpt: boolean;
+    value: Record<string, any>;
+    class: string | unknown[] | Record<string, any>;
+    prose: boolean;
+    tag: string;
+    unwrap: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,84 @@
+<script>
+import { defineComponent, watch, h, useSlots } from "vue";
+import ContentRendererMarkdown from "./internal/ContentRendererMarkdown.vue";
+function normalizeBody(value, excerpt) {
+  let body = excerpt ? value?.excerpt : value?.body;
+  if (!body && value?.type) {
+    body = value;
+  }
+  if (body?.type === "root" && Array.isArray(body.children)) {
+    return body;
+  }
+  return null;
+}
+export default defineComponent({
+  name: "ContentRenderer",
+  props: {
+    value: {
+      type: Object,
+      required: false,
+      default: () => ({})
+    },
+    excerpt: {
+      type: Boolean,
+      default: false
+    },
+    tag: {
+      type: String,
+      default: "div"
+    },
+    prose: {
+      type: Boolean,
+      default: void 0
+    },
+    class: {
+      type: [String, Array, Object],
+      default: void 0
+    },
+    unwrap: {
+      type: [Boolean, String],
+      default: false
+    }
+  },
+  setup(props) {
+    watch(
+      () => props.excerpt,
+      (newExcerpt) => {
+        if (newExcerpt && !props.value?.excerpt) {
+          console.warn(`No excerpt found for document content/${props?.value?._path}.${props?.value?._extension}!`);
+          console.warn("Make sure to use <!--more--> in your content if you want to use excerpt feature.");
+        }
+      },
+      {
+        immediate: true
+      }
+    );
+  },
+  render() {
+    const slots = useSlots();
+    const { value, excerpt, tag, prose, unwrap } = this;
+    const markdownBody = normalizeBody(value, excerpt);
+    if (!markdownBody?.children?.length && slots?.empty) {
+      return slots.empty({ value, excerpt, tag, prose, unwrap, ...this.$attrs });
+    }
+    if (slots?.default) {
+      return slots.default({ value, excerpt, tag, prose, unwrap, ...this.$attrs });
+    }
+    if (markdownBody?.children?.length) {
+      return h(ContentRendererMarkdown, {
+        value,
+        excerpt,
+        tag,
+        prose,
+        unwrap,
+        ...this.$attrs
+      });
+    }
+    return h(
+      "pre",
+      null,
+      JSON.stringify({ message: "You should use slots with <ContentRenderer>", value, excerpt, tag, prose, unwrap }, null, 2)
+    );
+  }
+});
+</script>

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

@@ -0,0 +1,62 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: ObjectConstructor;
+        required: false;
+        default: () => {};
+    };
+    excerpt: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    class: {
+        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: boolean;
+    };
+}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: ObjectConstructor;
+        required: false;
+        default: () => {};
+    };
+    excerpt: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    class: {
+        type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    excerpt: boolean;
+    value: Record<string, any>;
+    class: string | unknown[] | Record<string, any>;
+    prose: boolean;
+    tag: string;
+    unwrap: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,50 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    components: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    components: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    components: Record<string, any>;
+    prose: boolean;
+    tag: string;
+    unwrap: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,97 @@
+<script setup>
+import { hash } from "ohash";
+import { parse } from "comark";
+import { computed, onServerPrefetch, shallowRef, useAttrs, watch } from "vue";
+import { useRuntimeConfig, useState } from "#imports";
+import MarkdownRenderer from "./internal/MarkdownRenderer.js";
+import { useUnwrap } from "../composables/useUnwrap";
+import { resolveMarkdownPlugins, resolveMarkdownRendererComponents } from "../../markdown/plugins";
+import { toMarkdownRoot } from "../../../core/markdown/tree";
+import { loadContentComponentEntries } from "../../../integrations/vue/content-components";
+const props = defineProps({
+  value: {
+    type: String,
+    required: true
+  },
+  tag: {
+    type: String,
+    default: "span"
+  },
+  unwrap: {
+    type: [Boolean, String],
+    default: "p"
+  },
+  prose: {
+    type: Boolean,
+    default: void 0
+  },
+  components: {
+    type: Object,
+    default: () => ({})
+  }
+});
+const runtimeContent = useRuntimeConfig().public.content;
+const attrs = useAttrs();
+const { unwrap: unwrapRoot } = useUnwrap();
+const stateKey = `content:inline:${hash({
+  value: props.value,
+  unwrap: props.unwrap,
+  prose: props.prose,
+  plugins: runtimeContent.markdown?.plugins || [],
+  tags: runtimeContent.markdown?.tags || {}
+})}`;
+const initialState = useState(stateKey, () => ({
+  tree: null
+}));
+const tree = shallowRef(initialState.value.tree);
+const resolvedComponents = computed(() => ({
+  ...Object.fromEntries(loadContentComponentEntries({
+    type: "root",
+    children: tree.value?.children || []
+  }, runtimeContent.markdown?.tags || {})),
+  ...resolveMarkdownRendererComponents(runtimeContent.markdown.plugins),
+  ...props.components
+}));
+const rendererAttrs = computed(() => {
+  const { class: className, ...rest } = attrs;
+  return className == null ? rest : {
+    ...rest,
+    class: className
+  };
+});
+const refresh = async () => {
+  const plugins = await resolveMarkdownPlugins(runtimeContent.markdown.plugins);
+  const parsed = await parse(props.value || "", { plugins });
+  const body = unwrapRoot({
+    ...toMarkdownRoot(parsed.nodes)
+  }, props.unwrap);
+  tree.value = body;
+};
+onServerPrefetch(async () => {
+  await refresh();
+  initialState.value = {
+    tree: tree.value
+  };
+});
+if (import.meta.client && !tree.value) {
+  void refresh();
+}
+watch(
+  [() => props.value, () => props.unwrap, () => props.components, () => runtimeContent.markdown?.plugins, () => runtimeContent.markdown?.tags],
+  () => {
+    void refresh();
+  },
+  { deep: true }
+);
+</script>
+
+<template>
+  <MarkdownRenderer
+    v-if="tree"
+    :tree="tree"
+    :tag="tag"
+    :prose="prose"
+    :components="resolvedComponents"
+    v-bind="rendererAttrs"
+  />
+</template>

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

@@ -0,0 +1,50 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    components: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    unwrap: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: string;
+    };
+    prose: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    components: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    components: Record<string, any>;
+    prose: boolean;
+    tag: string;
+    unwrap: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Prose/ProseCode.d.vue.ts

@@ -0,0 +1,61 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    code: string;
+    meta: string;
+    language: string;
+    filename: string;
+    highlights: number[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,32 @@
+<template>
+  <slot />
+</template>
+
+<script setup>
+defineProps({
+  code: {
+    type: String,
+    default: ""
+  },
+  language: {
+    type: String,
+    default: null
+  },
+  filename: {
+    type: String,
+    default: null
+  },
+  highlights: {
+    type: Array,
+    default: () => []
+  },
+  meta: {
+    type: String,
+    default: null
+  }
+});
+</script>
+
+<style>
+pre code .line{display:block;min-height:1rem}
+</style>

package/dist/runtime/app/components/Prose/ProseCode.vue.d.ts

@@ -0,0 +1,61 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    code: string;
+    meta: string;
+    language: string;
+    filename: string;
+    highlights: number[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/Prose/ProseCodeInline.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/dist/runtime/app/components/Prose/ProseCodeInline.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};