@lupinum/ginko 0.4.0 → 0.5.0

package/dist/nuxt/runtime/server/items.d.ts

@@ -0,0 +1,12 @@
+import { type RequestEvent } from 'nuxt/server';
+import { type BundleItem } from '../../../internal.mjs';
+/** An entry as `getGinkoItems` returns it: `url` is its path in the requested language (collections with a route). */
+export type GinkoServerItem = BundleItem & {
+    url?: string;
+};
+/**
+ * The visible entries of collection `brick` in `locale` (default: the main language), in the collection's order, as
+ * `useGinko(brick).items` has them on a page: drafts and entries past their `visible` date are left out. Throws a 404
+ * for a language the site does not have or a key that is no collection, and a 503 when the platform cannot be reached.
+ */
+export declare function getGinkoItems(event: RequestEvent, brick: string, locale?: string): Promise<GinkoServerItem[]>;

package/dist/nuxt/runtime/server/items.mjs

@@ -0,0 +1,17 @@
+import { createError, useRuntimeConfig } from "nuxt/server";
+import schema from "#ginko/schema";
+import { isVisible, todayIn } from "../../../internal.mjs";
+import { withUrl } from "../shared.mjs";
+import { loadServerBundles } from "./bundles.mjs";
+export async function getGinkoItems(event, brick, locale) {
+  const config = useRuntimeConfig().public.ginko;
+  const code = locale ?? config.mainLocale;
+  const def = schema.bricks[brick];
+  if (!config.locales.includes(code) || def?.kind !== "collection") throw createError({ statusCode: 404, statusMessage: "Not found" });
+  const bundle = (await loadServerBundles(event, config, [code]))[code];
+  const value = bundle?.bricks[brick];
+  if (!bundle || value?.kind !== "collection") return [];
+  const today = todayIn(config.timeZone);
+  const items = value.items.filter((item) => isVisible(def, item.data, today));
+  return def.route ? withUrl(items, bundle.locale, bundle.mainLocale) : items;
+}

package/dist/nuxt/runtime/server/llms-full.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<string>>;
+export default _default;

package/dist/nuxt/runtime/server/llms.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<string>>;
+export default _default;

package/dist/nuxt/runtime/server/markdown-trees.d.ts

@@ -0,0 +1,2 @@
+import type { MarkdownTree } from '../../../internal.mjs';
+export declare const markdownTrees: ReadonlyMap<string, MarkdownTree>;

package/dist/nuxt/runtime/server/markdown.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<string | undefined>>;
+export default _default;

package/dist/nuxt/runtime/server/markdown.mjs

@@ -28,7 +28,7 @@ export default defineEventHandler(async (event) => {
   event.res.headers.set("content-type", "text/markdown; charset=utf-8");
   if (!match) {
     setResponseStatus(event, 404);
-    return markdownNotFound(bundle, path, { origin: config.url });
+    return markdownNotFound(bundle, path, { origin: config.url, schema });
   }
   event.res.headers.set("x-ginko-rev", `${bundle.schemaRev}.${bundle.contentRev}`);
   return entryMarkdown(match.item, match.brick, { schema, trees: markdownTrees });

package/dist/nuxt/runtime/server/platform-md.d.mts

@@ -0,0 +1,3 @@
+import { type MarkdownTree } from '../../../internal.mjs';
+declare const _default: import("nuxt/server").EventHandler<Promise<MarkdownTree>>;
+export default _default;

package/dist/nuxt/runtime/server/platform-md.d.ts

@@ -0,0 +1,3 @@
+import { type MarkdownTree } from '../../../internal.mjs';
+declare const _default: import("nuxt/server").EventHandler<Promise<MarkdownTree>>;
+export default _default;

package/dist/nuxt/runtime/server/platform-md.mjs

@@ -0,0 +1,71 @@
+import { createError, defineEventHandler, getRequestURL, useRuntimeConfig } from "nuxt/server";
+import schema from "#ginko/schema";
+import { platformMarkdownRef, withMarkdownRefs } from "../../../internal.mjs";
+import { fetchBundle, PlatformError } from "../fetch.mjs";
+const PATH = /^\/__ginko\/platform\/([^/]+)\/(\d+\.\d+)\/md\//;
+const copies = /* @__PURE__ */ new Map();
+const flights = /* @__PURE__ */ new Map();
+const ahead = /* @__PURE__ */ new Map();
+const AHEAD_MS = 1e4;
+const newer = (a, b) => {
+  const [as = 0, ac = 0] = a.split(".").map(Number);
+  const [bs = 0, bc = 0] = b.split(".").map(Number);
+  return as !== bs ? as > bs : ac > bc;
+};
+const stale = (error) => error instanceof PlatformError && error.platformStatus === 409;
+function covering(locale, rev) {
+  const copy = copies.get(locale);
+  return copy && !newer(rev, copy.rev) ? copy : void 0;
+}
+function isAhead(locale, rev) {
+  const known = ahead.get(locale);
+  return !!known && known.until > Date.now() && !newer(known.rev, rev);
+}
+function flightFor(config, locale, rev) {
+  const running = flights.get(locale);
+  if (running) return running;
+  const siteToken = useRuntimeConfig().ginkoRevalidateToken;
+  const copy = fetchBundle(config, locale, rev, siteToken).then((bundle) => {
+    const actual = `${bundle.schemaRev}.${bundle.contentRev}`;
+    const trees = /* @__PURE__ */ new Map();
+    withMarkdownRefs(bundle, schema, trees, (brick, id, field) => platformMarkdownRef(locale, actual, brick, id, field));
+    const fresh = { rev: actual, trees };
+    const current = copies.get(locale);
+    if (!current || newer(actual, current.rev)) copies.set(locale, fresh);
+    return fresh;
+  }, (error) => {
+    if (stale(error)) ahead.set(locale, { rev, until: Date.now() + AHEAD_MS });
+    throw error;
+  }).finally(() => flights.delete(locale));
+  flights.set(locale, copy);
+  return copy;
+}
+async function copyFor(config, locale, rev) {
+  for (let round = 0; round < 2; round++) {
+    const copy = covering(locale, rev);
+    if (copy) return copy;
+    if (isAhead(locale, rev)) return void 0;
+    try {
+      await flightFor(config, locale, rev);
+    } catch (error) {
+      if (!stale(error)) throw error;
+    }
+  }
+  return covering(locale, rev);
+}
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig().public.ginko;
+  const path = getRequestURL(event).pathname;
+  const [, locale = "", rev = ""] = PATH.exec(path) ?? [];
+  if (!config.locales.includes(locale)) throw createError({ statusCode: 404, statusMessage: "Text not found" });
+  let copy;
+  try {
+    copy = await copyFor(config, locale, rev);
+  } catch (error) {
+    if (error instanceof PlatformError) throw createError({ statusCode: error.statusCode, statusMessage: error.message, cause: error.cause });
+    throw error;
+  }
+  const tree = copy?.trees.get(path.replace(PATH, `/__ginko/platform/${locale}/${copy.rev}/md/`));
+  if (!tree) throw createError({ statusCode: 404, statusMessage: "Text not found" });
+  return tree;
+});

package/dist/nuxt/runtime/server/redirects.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<string | undefined>;
+export default _default;

package/dist/nuxt/runtime/server/robots.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<string>;
+export default _default;

package/dist/nuxt/runtime/server/search.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<import("../../../search").SearchIndexJson>;
+export default _default;

package/dist/nuxt/runtime/server/site-config.d.ts

@@ -0,0 +1,14 @@
+import { getRequestHost } from 'nuxt/server';
+type SiteConfigInit = {
+    event: Parameters<typeof getRequestHost>[0];
+    siteConfig: {
+        push: (input: Record<string, unknown>) => void;
+    };
+};
+type ServerApp = {
+    hooks: {
+        hook: (name: 'site-config:init', fn: (ctx: SiteConfigInit) => void) => void;
+    };
+};
+declare const _default: (app: ServerApp) => void;
+export default _default;

package/dist/nuxt/runtime/server/sitemap-source.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<import("./sitemap-xml.mjs").SitemapUrl[]>>;
+export default _default;

package/dist/nuxt/runtime/server/sitemap-xml.d.ts

@@ -0,0 +1,24 @@
+import { type LocaleConfig } from '@lupinum/ginko-i18n/core';
+import { type Bundle, type Locale, type Schema } from '../../../internal.mjs';
+/** One `<url>`, in the shape @nuxtjs/sitemap reads from a source. All URLs are absolute. */
+export interface SitemapUrl {
+    loc: string;
+    /** ISO 8601 time of the entry's last change (`updatedAt`); static pages have none. */
+    lastmod?: string;
+    /** hreflang alternates, `x-default` included; only for pages with more than one locale. */
+    alternatives?: {
+        hreflang: string;
+        href: string;
+    }[];
+    images?: {
+        loc: string;
+    }[];
+}
+/**
+ * `bundles` must hold every locale of the site for routed entries; `today` is the site's date
+ * (todayIn of its time zone), so the visibility rule matches the pages. `locales` is ginko-i18n's
+ * config: hreflang uses its languages and `x-default`, exactly as the page head does.
+ */
+export declare function sitemapUrls(site: Schema, bundles: Partial<Record<Locale, Bundle>>, today: string, locales: Pick<LocaleConfig, 'locales' | 'defaultLocale'>): SitemapUrl[];
+/** The sitemap document of `sitemapUrls`. */
+export declare function sitemapXml(site: Schema, bundles: Partial<Record<Locale, Bundle>>, today: string, locales: Pick<LocaleConfig, 'locales' | 'defaultLocale'>): string;

package/dist/nuxt/runtime/server/sitemap.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<string>>;
+export default _default;

package/dist/nuxt/runtime/shared.d.mts

@@ -1,4 +1,4 @@
-import { type Locale, type SiteInput } from '../../internal.mjs';
+import { type Locale, type SiteInput, type StoredHolidays } from '../../internal.mjs';
 export interface GinkoPublicConfig {
     site: string;
     name: string;
@@ -7,6 +7,10 @@ export interface GinkoPublicConfig {
     locales: Locale[];
     mainLocale: Locale;
     timeZone: string;
+    /** `country` of the site config (ISO 3166-1), or '' when unset. */
+    country: string;
+    /** The stored holiday calendar (`AT`, `DE`, `SG`, `none`, `custom`), or '' when the config sets neither `calendar` nor `country`. */
+    holidays: StoredHolidays | '';
     /** `seo` of the site config (`useGinkoSeo` defaults). */
     seo: NonNullable<SiteInput['seo']>;
     /** `agents` of the site config (llms.txt, Markdown routes). */
@@ -27,9 +31,12 @@ export declare function agentRequest(path: string): {
     page: string;
     asMarkdown: boolean;
 } | undefined;
-/** The items of a routed brick, each with `url`: its address in `locale`. */
+/**
+ * The items of a routed brick, each with `url`: its address in `locale`. An entry without a page there (listed under
+ * `untranslated: 'fallback'`) links to its page in the main language `main`.
+ */
 export declare function withUrl<T extends {
     urls?: Partial<Record<string, string>>;
-}>(items: T[], locale: Locale): (T & {
+}>(items: T[], locale: Locale, main: Locale): (T & {
     url?: string;
 })[];

package/dist/nuxt/runtime/shared.mjs

@@ -4,6 +4,6 @@ export function agentRequest(path) {
   const page = markdownRequestPath(path);
   return page === void 0 ? { page: path, asMarkdown: false } : { page, asMarkdown: true };
 }
-export function withUrl(items, locale) {
-  return items.map((item) => ({ ...item, url: item.urls?.[locale] }));
+export function withUrl(items, locale, main) {
+  return items.map((item) => ({ ...item, url: item.urls?.[locale] ?? item.urls?.[main] }));
 }