@lupinum/ginko-content 0.1.5 → 0.2.0

package/dist/runtime/app/composables/query-api.d.ts

@@ -1,10 +1,10 @@
 import type { ParsedContent } from '../../../types/content';
-import type { ContentCollectionTarget, ContentVariant, ContentTreeItem, BacklinksOptions, BacklinksResult, BacklinkSource, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../../types/query';
-import { type ContentQueryContext } from '../../query/unified';
+import type { ContentCollectionTarget, ContentVariant, ContentTreeItem, BacklinksOptions, BacklinksResult, BacklinkSource, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, OptionsArg, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, VariantsOptions } from '../../../types/query';
+import { type ContentQueryContext } from '../../../features/query/unified';
 export declare const createClientContentQueryContext: () => ContentQueryContext;
 export declare function resolveOne<const H extends ContentCollectionTarget, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(handle: H, options: O): Promise<ResolveOneResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
 export declare function one<const H extends ContentCollectionTarget, O extends OneOptions<H, PopulateSpec | undefined>>(handle: H, options: O): Promise<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>> | null>;
-export declare function many<const H extends ContentCollectionTarget, O extends ManyOptions<H, PopulateSpec | undefined>>(handle: H, options?: O & ManyOptions<H, PopulateSpec | undefined>): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
+export declare function many<const H extends ContentCollectionTarget, O extends ManyOptions<H, PopulateSpec | undefined>>(handle: H, ...args: OptionsArg<H, O & ManyOptions<H, PopulateSpec | undefined>>): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
 export declare function paginate<const H extends ContentCollectionTarget, O extends PaginationOptions<H, PopulateSpec | undefined>>(handle: H, options: O): Promise<PaginationResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
 export declare function backlinks<const Target extends ContentCollectionTarget, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(handle: Target, options: BacklinksOptions<Target, Source, P>): Promise<BacklinksResult<Source, P>>;
 export declare function variants<H extends ContentCollectionTarget>(handle: H, options: VariantsOptions<H>): Promise<Array<ContentVariant<H extends {
@@ -12,9 +12,9 @@ export declare function variants<H extends ContentCollectionTarget>(handle: H, o
         _output: infer O;
     };
 } ? O & ParsedContent : ParsedContent>>>;
-export declare function tree<H extends ContentCollectionTarget, Fields extends ReadonlyArray<string> | undefined = undefined>(handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+export declare function tree<H extends ContentCollectionTarget, Fields extends ReadonlyArray<string> | undefined = undefined>(handle: H, ...args: OptionsArg<H, Omit<TreeOptions<H>, 'fields'> & {
     fields?: Fields;
-}): Promise<ContentTreeItem<H extends {
+}>): Promise<ContentTreeItem<H extends {
     __schema: {
         _output: infer O;
     };

package/dist/runtime/app/composables/query-api.js

@@ -9,7 +9,7 @@ import {
   resolveOne as resolveOneWithContext,
   tree as treeWithContext,
   variants as variantsWithContext
-} from "../../query/unified.js";
+} from "../../../features/query/unified";
 export const createClientContentQueryContext = () => {
   const runtime = getContentRuntime();
   const fetcher = getContentApiFetcher();
@@ -26,7 +26,8 @@ export async function resolveOne(handle, options) {
 export async function one(handle, options) {
   return await oneWithContext(createClientContentQueryContext(), handle, options);
 }
-export async function many(handle, options = {}) {
+export async function many(handle, ...args) {
+  const options = args[0] ?? {};
   return await manyWithContext(createClientContentQueryContext(), handle, options);
 }
 export async function paginate(handle, options) {
@@ -38,7 +39,8 @@ export async function backlinks(handle, options) {
 export async function variants(handle, options) {
   return await variantsWithContext(createClientContentQueryContext(), handle, options);
 }
-export async function tree(handle, options = {}) {
+export async function tree(handle, ...args) {
+  const options = args[0] ?? {};
   return await treeWithContext(createClientContentQueryContext(), handle, options);
 }
 export async function neighbors(handle, options) {

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

@@ -5,7 +5,7 @@ export declare function useContentSwitchLocalePath(): (locale: string) => string
 export declare function useContentRoute(value: MaybeRefOrGetter<ContentRouteValue>): {
     switchLocalePath: (locale: string) => string;
     localePaths: ComputedRef<Record<string, string>>;
-    canonicalPath: ComputedRef<string | undefined>;
+    unprefixedPath: ComputedRef<string | undefined>;
     path: ComputedRef<string | undefined>;
 };
 export {};

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

@@ -25,7 +25,7 @@ const syncPublishedContentRoute = (meta, setI18nParams) => {
   meta[CONTENT_ROUTE_META_KEY] = {
     token: activePublisher.token,
     path: activePublisher.path,
-    canonicalPath: activePublisher.canonicalPath,
+    unprefixedPath: activePublisher.unprefixedPath,
     localePaths: activePublisher.localePaths
   };
   setI18nParams(activePublisher.localeParams);
@@ -46,7 +46,7 @@ const normalizeContentRoute = (value) => {
   }
   return {
     path: value.path,
-    canonicalPath: value.canonicalPath,
+    unprefixedPath: value.unprefixedPath,
     localePaths: stringPaths
   };
 };
@@ -58,7 +58,7 @@ const normalizeRoutePath = (path) => {
 };
 const contentRouteMatches = (contentRoute, path) => {
   const normalizedPath = normalizeRoutePath(path);
-  return normalizeRoutePath(contentRoute.path) === normalizedPath || normalizeRoutePath(contentRoute.canonicalPath) === normalizedPath || Object.values(contentRoute.localePaths).some((localePath) => normalizeRoutePath(localePath) === normalizedPath);
+  return normalizeRoutePath(contentRoute.path) === normalizedPath || normalizeRoutePath(contentRoute.unprefixedPath) === normalizedPath || Object.values(contentRoute.localePaths).some((localePath) => normalizeRoutePath(localePath) === normalizedPath);
 };
 const resolveLocalizedRouteParams = (page, router, route, getRouteBaseName) => {
   if (!page) {
@@ -144,7 +144,7 @@ export function useContentRoute(value) {
   return {
     switchLocalePath: useContentSwitchLocalePath(),
     localePaths: computed(() => activeContentRoute.value?.localePaths || {}),
-    canonicalPath: computed(() => activeContentRoute.value?.canonicalPath),
+    unprefixedPath: computed(() => activeContentRoute.value?.unprefixedPath),
     path: computed(() => activeContentRoute.value?.path)
   };
 }

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

@@ -90,7 +90,7 @@ const loadSearchSections = async (collection, options) => {
     loadPages: async (extraFields) => {
       return await many(collection, {
         ...locale ? { locale } : {},
-        select: ["_path", "title", "description", "body", ...extraFields]
+        select: ["path", "title", "description", "body", ...extraFields]
       });
     }
   });

package/dist/runtime/app/composables/use-content-document.js

@@ -4,7 +4,7 @@ import { createClientContentQueryContext } from "./query-api.js";
 import {
   one as oneWithContext,
   resolveOne as resolveOneWithContext
-} from "../../query/unified.js";
+} from "../../../features/query/unified";
 import { contentCollectionName, resolveOptions, stableKey } from "./use-content-shared.js";
 export async function useContentOne(handle, options) {
   const resolved = computed(() => resolveOptions(options));

package/dist/runtime/app/composables/use-content-list.js

@@ -6,7 +6,7 @@ import {
   many as manyWithContext,
   paginate as paginateWithContext,
   variants as variantsWithContext
-} from "../../query/unified.js";
+} from "../../../features/query/unified";
 import { contentCollectionName, resolveOptions, stableKey } from "./use-content-shared.js";
 export async function useContentMany(handle, options = {}) {
   const resolved = computed(() => resolveOptions(options));

package/dist/runtime/app/composables/use-content-navigation.js

@@ -2,11 +2,11 @@ import { computed } from "vue";
 import { useAsyncData } from "#imports";
 import { resolveCollectionI18n } from "../../../features/localization/path";
 import { createClientContentQueryContext } from "./query-api.js";
-import { neighbors as neighborsWithContext, tree as treeWithContext } from "../../query/unified.js";
+import { neighbors as neighborsWithContext, tree as treeWithContext } from "../../../features/query/unified";
 import { getContentRoute, getContentRuntime } from "./runtime.js";
 import { contentCollectionName, resolveLocaleFromRoutePath, resolveOptions, stableKey } from "./use-content-shared.js";
 const navigationNodeId = (item) => {
-  const id = item.id ?? item._id ?? item._canonicalKey ?? item.path ?? item._path ?? item.title;
+  const id = item.id ?? item.id ?? item.canonicalKey ?? item.path ?? item.path ?? item.title;
   return typeof id === "string" && id.length ? id : item.title;
 };
 export const normalizeContentNavigation = (items = []) => {

package/dist/runtime/app/composables/use-content-page.js

@@ -32,10 +32,10 @@ const localePathMatches = (entry, path) => {
 const routeMetaMatchesPath = (value, path) => {
   if (!value) return false;
   const normalizedPath = normalizeRoutePath(path);
-  const legacyPath = value;
-  if (normalizeRoutePath(legacyPath._path) === normalizedPath || normalizeRoutePath(legacyPath._requestedPath) === normalizedPath || normalizeRoutePath(legacyPath._requestedRoute) === normalizedPath) return true;
-  const requestedRoute = value.resolved?.requestedRoute ?? value._requestedRoute;
-  return normalizeRoutePath(value.path) === normalizedPath || normalizeRoutePath(value.canonicalPath) === normalizedPath || normalizeRoutePath(requestedRoute) === normalizedPath || Object.values(value.localePaths || {}).some((entry) => localePathMatches(entry, path));
+  const resolved = value.resolved;
+  if (normalizeRoutePath(value.path) === normalizedPath || normalizeRoutePath(resolved?.requestedPath) === normalizedPath || normalizeRoutePath(resolved?.requestedRoute) === normalizedPath) return true;
+  const requestedRoute = resolved?.requestedRoute;
+  return normalizeRoutePath(value.path) === normalizedPath || normalizeRoutePath(value.unprefixedPath) === normalizedPath || normalizeRoutePath(requestedRoute) === normalizedPath || Object.values(value.localePaths || {}).some((entry) => localePathMatches(entry, path));
 };
 export async function useContentPage(handle, options = {}) {
   const route = useRoute();

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

@@ -1,5 +1,6 @@
 <script setup>
-import { setResponseStatus, useContentPage } from "#imports";
+import { setResponseStatus } from "nuxt/app";
+import { useContentPage } from "../composables/use-content";
 const { page } = await useContentPage("pages", {
   notFound: false
 });

package/dist/runtime/markdown/plugins.js

@@ -1,23 +1,21 @@
 import { defineAsyncComponent } from "vue";
 export { resolveMarkdownPlugins } from "../../parsers/markdown-plugins";
+const importOptionalMarkdownComponent = async (specifier) => await import(
+  /* @vite-ignore */
+  specifier
+);
 const builtinMarkdownPlugins = {
   math: {
     componentName: "Math",
     component: defineAsyncComponent(async () => {
-      const mod = await import(
-        /* @vite-ignore */
-        ["@comark/vue", "plugins/math"].join("/")
-      );
+      const mod = await importOptionalMarkdownComponent("@comark/vue/plugins/math");
       return mod.Math;
     })
   },
   mermaid: {
     componentName: "Mermaid",
     component: defineAsyncComponent(async () => {
-      const mod = await import(
-        /* @vite-ignore */
-        ["@comark/vue", "plugins/mermaid"].join("/")
-      );
+      const mod = await importOptionalMarkdownComponent("@comark/vue/plugins/mermaid");
       return mod.Mermaid;
     })
   }

package/dist/runtime/server/agent-markdown.d.ts

@@ -1,74 +1,14 @@
 import type { H3Event } from 'h3';
-import type { MarkdownNode, ParsedContent } from '../../types/content';
-import type { AgentMetadataField, ContentCollectionConfig } from '../../types/config';
-export interface AgentMarkdownPublicSignals {
-    search?: 'yes' | 'no';
-    aiInput?: 'yes' | 'no';
-    aiTrain?: 'yes' | 'no';
-}
-export interface ResolvedAgentMarkdownOptions {
-    includeInIndex: boolean;
-    includeInFull: boolean;
-    metadata: AgentMetadataField[];
-}
-export interface AgentMarkdown {
-    path: string;
-    markdownPath: string;
-    rawPath: string;
-    locale?: string;
-    collection: string;
-    title: string;
-    description: string;
-    markdown: string;
-    sourceFile?: string;
-    canonicalUrl: string;
-    lastModified?: string;
-    publicSignals?: AgentMarkdownPublicSignals;
-    metadataFields: string[];
-    includeInIndex: boolean;
-    includeInFull: boolean;
-}
-export type AgentMarkdownMeta = Omit<AgentMarkdown, 'markdown'>;
-export interface AgentMarkdownContext {
-    collection: string;
-    page: ParsedContent;
-    path: string;
-    locale?: string;
-    prop: (name: string) => string;
-    props: (node?: MarkdownNode) => Record<string, unknown>;
-    cleanProps: (node?: MarkdownNode) => Record<string, unknown>;
-    children: (node?: MarkdownNode) => string;
-    renderChildren: (node: MarkdownNode) => string;
-    renderNode: (node: MarkdownNode) => string;
-    blockquote: (value: string) => string;
-    jsonFence: (value: unknown) => string;
-    link: (label: string, href: string) => string;
-    omitted: (name: string, reason?: string) => string;
-    xmlComponent: (name: string, props?: Record<string, unknown>, children?: string) => string;
-}
-export type AgentMarkdownSerializer = (node: MarkdownNode, ctx: AgentMarkdownContext) => string | null | undefined;
-export type AgentMarkdownSerializerMap = Record<string, AgentMarkdownSerializer>;
-export interface AgentMarkdownSerializerRegistrationOptions {
-    override?: boolean;
-}
-export interface AgentMarkdownComponent {
-    render: AgentMarkdownSerializer;
-}
-export type AgentMarkdownComponentMap = Record<string, AgentMarkdownComponent>;
-export declare const getMarkdownProp: (node: MarkdownNode, name: string) => string;
-export declare const renderMarkdownChildren: (node: MarkdownNode, ctx: AgentMarkdownContext) => string;
-export declare const blockquoteMarkdown: (value: string) => string;
-export declare const linkMarkdown: (label: string, href: string) => string;
-export declare const imageMarkdown: (alt: string, src: string) => string;
-export declare const jsonFenceMarkdown: (value: unknown) => string;
-export declare const xmlComponentMarkdown: (name: string, props?: Record<string, unknown>, children?: string) => string;
+import type { AgentMarkdown, AgentMarkdownComponent, AgentMarkdownComponentMap, AgentMarkdownMeta, AgentMarkdownRegistry, AgentMarkdownSerializer, AgentMarkdownSerializerMap, AgentMarkdownSerializerRegistrationOptions } from '../../features/agent/agent-markdown';
+export * from '../../features/agent/agent-markdown';
+export { renderAgentMarkdownBody } from '../../features/agent/walker';
+/** The current app's serializer registry the walker resolves tags against. */
+export declare const getAgentMarkdownRegistry: () => AgentMarkdownRegistry;
 export declare const registerAgentMarkdownSerializer: (name: string, serializer: AgentMarkdownSerializer, options?: AgentMarkdownSerializerRegistrationOptions) => void;
 export declare const registerAgentMarkdownSerializers: (entries: AgentMarkdownSerializerMap, options?: AgentMarkdownSerializerRegistrationOptions) => void;
-export declare const defineAgentMarkdownComponent: (component: AgentMarkdownComponent) => AgentMarkdownComponent;
 export declare const registerAgentMarkdownComponent: (name: string, component: AgentMarkdownComponent, options?: AgentMarkdownSerializerRegistrationOptions) => void;
 export declare const registerAgentMarkdownComponents: (entries: AgentMarkdownComponentMap, options?: AgentMarkdownSerializerRegistrationOptions) => void;
 export declare const clearAgentMarkdownSerializers: () => void;
-export declare const resolveAgentMarkdownOptions: (collection: ContentCollectionConfig | undefined) => ResolvedAgentMarkdownOptions | null;
 export declare function resolveContentMarkdown(event: H3Event, collection: string, routeOrPath?: string, options?: {
     locale?: string;
 }): Promise<AgentMarkdown | null>;