@lupinum/ginko-content 0.1.0

package/dist/runtime/app/composables/web-socket.js

@@ -0,0 +1,65 @@
+import { useRuntimeConfig, refreshNuxtData } from "#imports";
+const logger = {
+  log: (...args) => console.log("[Content]", ...args),
+  warn: (...args) => console.warn("[Content]", ...args)
+};
+let ws;
+export function useContentWebSocket() {
+  if (!window.WebSocket) {
+    logger.warn("Could not enable hot reload, your browser does not support WebSocket.");
+    return;
+  }
+  const onMessage = (message) => {
+    try {
+      const data = JSON.parse(message.data);
+      if (!data) {
+        return;
+      }
+      refreshNuxtData();
+    } catch {
+    }
+  };
+  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;
+    }
+    if (ws) {
+      try {
+        ws.close();
+      } catch {
+      }
+      ws = void 0;
+    }
+    const wsURL = `${useRuntimeConfig().public.content.wsUrl}ws`;
+    logger.log(`WS connect to ${wsURL}`);
+    ws = new WebSocket(wsURL);
+    ws.onopen = onOpen;
+    ws.onmessage = onMessage;
+    ws.onerror = onError;
+    ws.onclose = onClose;
+  };
+  connect();
+  return {
+    connect
+  };
+}

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

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

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

@@ -0,0 +1,14 @@
+<script setup>
+import { setResponseStatus, useContentPage } from "#imports";
+const { page } = await useContentPage("pages", {
+  notFound: false
+});
+if (import.meta.server && !page.value) {
+  setResponseStatus(404, "Document not found");
+}
+</script>
+
+<template>
+  <ContentRenderer v-if="page" :value="page" />
+  <p v-else>Document not found.</p>
+</template>

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

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

package/dist/runtime/app/plugins/markdown-components

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

package/dist/runtime/app/plugins/markdown-components.d.ts

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

package/dist/runtime/app/plugins/markdown-components.js

@@ -0,0 +1,19 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const plugins = useRuntimeConfig().public.content?.markdown?.plugins || [];
+  const names = new Set(plugins.map((plugin) => plugin.name));
+  if (names.has("math")) {
+    const { Math } = await import(
+      /* @vite-ignore */
+      ["@comark/vue", "plugins/math"].join("/")
+    );
+    nuxtApp.vueApp.component("Math", Math);
+  }
+  if (names.has("mermaid")) {
+    const { Mermaid } = await import(
+      /* @vite-ignore */
+      ["@comark/vue", "plugins/mermaid"].join("/")
+    );
+    nuxtApp.vueApp.component("Mermaid", Mermaid);
+  }
+});

package/dist/runtime/app/plugins/ws

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

package/dist/runtime/app/plugins/ws.d.ts

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

package/dist/runtime/app/plugins/ws.js

@@ -0,0 +1,7 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+export default defineNuxtPlugin(() => {
+  const publicConfig = useRuntimeConfig().public;
+  if (import.meta.client && publicConfig.content.wsUrl) {
+    import("../composables/web-socket.js").then(({ useContentWebSocket }) => useContentWebSocket());
+  }
+});

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

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

package/dist/runtime/app.vue

@@ -0,0 +1,3 @@
+<template>
+  <NuxtPage />
+</template>

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

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

package/dist/runtime/markdown/plugins

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

package/dist/runtime/markdown/plugins.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedMarkdownPlugin } from '../../types/content';
+export { resolveMarkdownPlugins } from '../../parsers/markdown-plugins';
+export declare function resolveMarkdownRendererComponents(plugins: ResolvedMarkdownPlugin[]): Record<string, unknown>;

package/dist/runtime/markdown/plugins.js

@@ -0,0 +1,39 @@
+import { defineAsyncComponent } from "vue";
+export { resolveMarkdownPlugins } from "../../parsers/markdown-plugins";
+const builtinMarkdownPlugins = {
+  math: {
+    componentName: "Math",
+    component: defineAsyncComponent(async () => {
+      const mod = await import(
+        /* @vite-ignore */
+        ["@comark/vue", "plugins/math"].join("/")
+      );
+      return mod.Math;
+    })
+  },
+  mermaid: {
+    componentName: "Mermaid",
+    component: defineAsyncComponent(async () => {
+      const mod = await import(
+        /* @vite-ignore */
+        ["@comark/vue", "plugins/mermaid"].join("/")
+      );
+      return mod.Mermaid;
+    })
+  }
+};
+const builtinMarkdownComponents = {
+  ProseImg: defineAsyncComponent(async () => await import("../app/components/Prose/ProseImg.vue"))
+};
+export function resolveMarkdownRendererComponents(plugins) {
+  const components = {
+    ...builtinMarkdownComponents
+  };
+  for (const plugin of plugins) {
+    const builtin = builtinMarkdownPlugins[plugin.name];
+    if (builtin?.componentName && builtin.component) {
+      components[plugin.name] = builtin.component;
+    }
+  }
+  return components;
+}

package/dist/runtime/query/public-limits

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

package/dist/runtime/query/public-limits.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_PUBLIC_QUERY_LIMIT = 100;
+export declare const MAX_PUBLIC_QUERY_SKIP = 10000;

package/dist/runtime/query/public-limits.js

@@ -0,0 +1,2 @@
+export const MAX_PUBLIC_QUERY_LIMIT = 100;
+export const MAX_PUBLIC_QUERY_SKIP = 1e4;

package/dist/runtime/query/resolve

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

package/dist/runtime/query/resolve.d.ts

@@ -0,0 +1,5 @@
+import type { ContentQueryCountResponse, ContentQueryFindOneResponse, ContentQueryFindResponse } from '../../types/api';
+type QueryResolvedValue<T> = Array<T> | T | number | undefined;
+type QueryResponseValue<T> = ContentQueryCountResponse | ContentQueryFindResponse<T> | ContentQueryFindOneResponse<T>;
+export declare const resolveQueryResult: <T>(result: QueryResponseValue<T> | T) => QueryResolvedValue<T>;
+export {};

package/dist/runtime/query/resolve.js

@@ -0,0 +1,9 @@
+export const resolveQueryResult = (result) => {
+  if (!result) {
+    return result;
+  }
+  if (typeof result === "object" && "result" in result) {
+    return result.result;
+  }
+  return result;
+};

package/dist/runtime/query/routes

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

package/dist/runtime/query/routes.d.ts

@@ -0,0 +1,33 @@
+import type { ContentCollectionHandle } from '../../types/config';
+export interface CollectionPathOptions {
+    /**
+     * Target locale. Non-default locales are prefixed in public routes.
+     */
+    locale?: string;
+    /**
+     * Relative document slug. Arrays are joined with `/`.
+     */
+    slug?: string | string[];
+    /**
+     * Canonical content path or route remainder. Takes precedence over `slug`.
+     */
+    path?: string;
+    /**
+     * Override the default locale when the collection does not declare one.
+     */
+    defaultLocale?: string;
+    /**
+     * Override the locale list when the collection does not declare one.
+     */
+    locales?: string[];
+    /**
+     * Return the locale-specific route without adding the locale prefix.
+     */
+    canonical?: boolean;
+}
+/**
+ * Build a public route for a route-backed collection from the collection's own
+ * route map. This keeps app code from duplicating `{ en: '/authors', de:
+ * '/autoren' }` in local utilities.
+ */
+export declare const getCollectionPath: (collection: ContentCollectionHandle, options?: CollectionPathOptions) => string;

package/dist/runtime/query/routes.js

@@ -0,0 +1,21 @@
+import { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale } from "../../core/content/path";
+const normalizeSlug = (slug) => {
+  if (Array.isArray(slug)) {
+    return slug.filter(Boolean).join("/");
+  }
+  return slug || "";
+};
+const collectionI18n = (collection) => {
+  return collection.i18n && typeof collection.i18n === "object" ? collection.i18n : void 0;
+};
+const normalizeRemainder = (path) => normalizeContentPath(path.startsWith("/") ? path : `/${path}`);
+export const getCollectionPath = (collection, options = {}) => {
+  const i18n = collectionI18n(collection);
+  const defaultLocale = i18n?.defaultLocale || options.defaultLocale;
+  const locales = i18n?.locales?.length ? i18n.locales : options.locales || (defaultLocale ? [defaultLocale] : []);
+  const locale = options.locale || defaultLocale;
+  const mounts = normalizeRouteMounts(collection.route, locales, defaultLocale);
+  const remainder = normalizeRemainder(options.path ?? normalizeSlug(options.slug) ?? "/");
+  const mounted = mountContentPath(remainder, locale, mounts);
+  return options.canonical ? mounted : prefixPathWithLocale(mounted, locale, defaultLocale);
+};

package/dist/runtime/query/unified

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

package/dist/runtime/query/unified.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Layer 1 of the unified query API (ADR-0016).
+ *
+ * Context-explicit async functions: `one`, `many`, `resolveOne`, `variants`, `tree`, `neighbors`.
+ * Each accepts a typed collection handle (from `defineCollection`) plus an
+ * options object. Locale is type-required when the handle declares i18n.
+ *
+ * Implementation strategy: compile the public `by` / `where` options to an
+ * internal `ContentQueryBuilderParams` payload via `compileQueryParams`, then
+ * dispatch through the explicit `ContentQueryContext` transport provided by
+ * the client or server entrypoint.
+ *
+ * Documents are post-processed by `localizePageResult` to attach `path`,
+ * `locale`, `localePaths`, and `variants` — the route metadata that powers
+ * locale switching with zero extra round trips.
+ */
+import type { ParsedContent } from '../../types/content';
+import type { ContentCollectionHandle } from '../../types/config';
+import type { BacklinkSource, BacklinksOptions, BacklinksResult, ContentTreeItem, DocumentFromHandle, ManyOptions, LocalizedDoc, NeighborsOptions, NeighborsResult, OneOptions, PopulateSpec, PopulateFromOptions, PopulatedDocument, PaginationOptions, PaginationResult, ResolveOneOptions, ResolveOneResult, TreeOptions, ContentVariant, ContentQueryBuilderParams, VariantsOptions } from '../../types/query';
+import type { ContentQueryResponse } from '../../types/api';
+export interface RuntimeContentConfig {
+    locales?: string[];
+    defaultLocale?: string;
+    collections?: Record<string, {
+        i18n?: boolean | {
+            locales?: string[];
+            defaultLocale?: string;
+        };
+        route?: string | Record<string, string>;
+    }>;
+}
+export type ContentQueryEndpoint = 'query' | 'navigation';
+export interface ContentQueryContext {
+    runtime: RuntimeContentConfig;
+    transport: <T>(endpoint: ContentQueryEndpoint, params: ContentQueryBuilderParams) => Promise<ContentQueryResponse<T> | T | T[] | null>;
+}
+export declare const navigationSelectFields: (fields?: ReadonlyArray<string> | undefined) => string[];
+/**
+ * Resolve exactly one document and return an explanation of how it matched.
+ */
+export declare function resolveOne<const H extends ContentCollectionHandle | string, O extends ResolveOneOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, options: O): Promise<ResolveOneResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+/**
+ * Ergonomic doc-only view over `resolveOne`.
+ */
+export declare function one<const H extends ContentCollectionHandle | string, O extends OneOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, options: O): Promise<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>> | null>;
+/**
+ * Resolve a list of documents matching the filter. Always returns an array.
+ */
+export declare function many<const H extends ContentCollectionHandle | string, O extends ManyOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, options?: O): Promise<Array<LocalizedDoc<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>>;
+/**
+ * Resolve one page of documents and preserve the query envelope metadata.
+ */
+export declare function paginate<const H extends ContentCollectionHandle | string, O extends PaginationOptions<H, PopulateSpec | undefined>>(context: ContentQueryContext, handle: H, options: O): Promise<PaginationResult<PopulatedDocument<DocumentFromHandle<H>, PopulateFromOptions<O>>>>;
+/**
+ * Resolve documents in source collections that reference one target document.
+ */
+export declare function backlinks<const Target extends ContentCollectionHandle | string, const Source extends BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined>(context: ContentQueryContext, targetHandle: Target, options: BacklinksOptions<Target, Source, P>): Promise<BacklinksResult<Source, P>>;
+/**
+ * Enumerate every locale variant of one document. Identifies the document by
+ * either its stable `ref:` or its canonical/localized `path`.
+ *
+ * Each entry carries a `translated: boolean` flag — `true` when that locale
+ * has its own variant on disk, `false` when the resolver fell back to another
+ * locale's path. `fallback` names the source locale when `translated` is false.
+ */
+export declare function variants<H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: VariantsOptions<H>): Promise<Array<ContentVariant<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>>;
+/**
+ * Resolve the navigation tree for a collection. The shape mirrors
+ * the provider navigation query but is a thin builder over the same transport.
+ *
+ * Locale fallback is on-by-default: every doc appears in the tree even when
+ * it has no variant in the requested locale (the resolver substitutes the
+ * fallback locale's path). This matches legacy navigation semantics —
+ * sidebars are inherently lossy when filtered too strictly.
+ */
+export declare function tree<H extends ContentCollectionHandle | string, Fields extends ReadonlyArray<string> | undefined = undefined>(context: ContentQueryContext, handle: H, options?: Omit<TreeOptions<H>, 'fields'> & {
+    fields?: Fields;
+}): Promise<ContentTreeItem<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent, Fields>[]>;
+/**
+ * Return the previous/next navigation entries surrounding a document.
+ */
+export declare function neighbors<H extends ContentCollectionHandle | string>(context: ContentQueryContext, handle: H, options: NeighborsOptions<H>): Promise<NeighborsResult<H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & ParsedContent : ParsedContent>>;