@lupinum/ginko 0.4.0 → 0.6.0

package/dist/shared/ginko.CjWB8N7f.d.ts

@@ -0,0 +1,128 @@
+import { B as Bundle } from './ginko.B_pACpVU.js';
+import { L as Locale } from './ginko.DrkUeYFP.js';
+
+interface NavNode {
+    title: string;
+    path: string;
+    id?: string;
+    brick?: string;
+    children: NavNode[];
+}
+/**
+ * Navigation tree of the collections `bricks` in `locale`, built from item URLs. An item is a child of the
+ * node at its nearest existing path prefix, else a root node. A string `parent` field (item id) overrides that.
+ * Siblings keep the item order of the bundle (bricks in the given order).
+ */
+declare function navTree(bundle: Bundle, bricks: string[], locale: Locale): NavNode[];
+/** Nodes from the root down to the node at `path`; empty when the path is not in the tree. */
+declare function breadcrumbs(tree: NavNode[], path: string): NavNode[];
+
+interface SeoImage {
+    url: string;
+    width?: number;
+    height?: number;
+    alt?: string;
+}
+interface SeoInput {
+    siteName: string;
+    /** `%s` is replaced by the page title; default '%s · <siteName>'. A page without title gets siteName alone. */
+    titleTemplate?: string;
+    title?: string;
+    description?: string;
+    image?: SeoImage;
+    type?: 'website' | 'article';
+    noindex?: boolean;
+}
+interface SeoHead {
+    title: string;
+    meta: (({
+        name: string;
+    } | {
+        property: string;
+    }) & {
+        content: string;
+    })[];
+}
+declare function seoHead(input: SeoInput): SeoHead;
+/** True when a request for `host` (with port, as in the Host header) is not for the site's own address: preview deployments, staging, localhost. Those must never be indexed. */
+declare function isPreviewHost(host: string | undefined, siteUrl: string): boolean;
+declare function robotsTxt(options: {
+    sitemap?: string;
+    noindex?: boolean;
+    disallow?: string[];
+}): string;
+declare function websiteLd(o: {
+    name: string;
+    url: string;
+    lang: string;
+}): Record<string, unknown>;
+/**
+ * `node` with the site's `country` (ISO 3166 code) where a builder left it out: `addressCountry` of every PostalAddress,
+ * and where remote applicants of a remote JobPosting must live. The Nuxt module applies it to a page's JSON-LD, so
+ * `siteJsonLd` and `jobJsonLd` need no `country` (an explicit one wins). An empty `country` changes nothing.
+ */
+declare function withCountry<T>(node: T, country: string): T;
+/** The schema.org types `organizationLd` writes. A page whose JSON-LD has a node of one of them is the site's organisation node. */
+declare const ORGANIZATION_TYPES: readonly ["Organization", "LocalBusiness", "NGO"];
+interface OrganizationLdInput {
+    name: string;
+    url: string;
+    /** `Organization` (default), `LocalBusiness` for a shop or practice, `NGO` for a nonprofit. */
+    type?: (typeof ORGANIZATION_TYPES)[number];
+    legalName?: string;
+    /** Absolute URL of the logo. */
+    logo?: string;
+    email?: string;
+    telephone?: string;
+    address?: {
+        street?: string;
+        postalCode?: string;
+        city?: string;
+        country?: string;
+    };
+    vatID?: string;
+    /** Absolute URLs of the organisation's profiles elsewhere. */
+    sameAs?: string[];
+}
+declare function organizationLd(o: OrganizationLdInput): Record<string, unknown>;
+/**
+ * A schema.org BreadcrumbList from the first step (usually the home page) to the page itself. Each step has a `title`
+ * and a `path` of the site, as the nodes of `useGinkoBreadcrumbs` do; `siteUrl` (`useGinkoSite().url`) makes the
+ * paths absolute.
+ */
+declare function breadcrumbJsonLd(steps: readonly Pick<NavNode, 'title' | 'path'>[], siteUrl: string): Record<string, unknown>;
+interface ArticleLdInput {
+    /** `Article` (default) or `BlogPosting` for a post of a blog. */
+    type?: 'Article' | 'BlogPosting';
+    title: string;
+    url: string;
+    description?: string;
+    image?: string;
+    published?: string;
+    modified?: string;
+    /** One author by name, or a list of authors with an optional website each. */
+    author?: string | readonly {
+        name: string;
+        url?: string;
+    }[];
+    keywords?: readonly string[];
+    lang: string;
+}
+declare function articleLd(o: ArticleLdInput): Record<string, unknown>;
+declare function faqLd(pairs: {
+    question: string;
+    answer: string;
+}[]): Record<string, unknown>;
+/**
+ * Headers every response of a Ginko site carries. Only the platform may frame `/__ginko` (the preview); nothing
+ * else is framed. `nosniff` stops a browser from reading user text (`.md`, `llms.txt`, JSON) as HTML, and the
+ * referrer policy keeps full URLs from leaving the site.
+ */
+declare function siteHeaders(input: {
+    preview: boolean;
+    platformOrigin: string;
+    noindex: boolean;
+}): Record<string, string>;
+
+export { ORGANIZATION_TYPES as a, articleLd as d, breadcrumbJsonLd as e, breadcrumbs as f, faqLd as g, siteHeaders as h, isPreviewHost as i, withCountry as j, navTree as n, organizationLd as o, robotsTxt as r, seoHead as s, websiteLd as w };
+export type { ArticleLdInput as A, NavNode as N, OrganizationLdInput as O, SeoHead as S, SeoImage as b, SeoInput as c };

package/dist/shared/ginko.D1PeQ3ds.mjs

@@ -0,0 +1,36 @@
+const MB = 1024 * 1024;
+const UPLOAD_TYPES = {
+  "image/jpeg": { label: "JPEG", kind: "image", limit: 20 * MB },
+  "image/png": { label: "PNG", kind: "image", limit: 20 * MB },
+  "image/webp": { label: "WebP", kind: "image", limit: 20 * MB },
+  "application/pdf": { label: "PDF", kind: "file", limit: 10 * MB }
+};
+function acceptOf(kind) {
+  return typesOf(kind).join(",");
+}
+function limitOf(kind) {
+  return Math.max(...typesOf(kind).map((type) => UPLOAD_TYPES[type].limit));
+}
+function formatMb(bytes) {
+  return `${roundedMb(bytes)}`.replace(".", ",");
+}
+function roundedMb(bytes) {
+  return Math.round(bytes / MB * 10) / 10;
+}
+function typesOf(kind) {
+  return Object.keys(UPLOAD_TYPES).filter((type) => UPLOAD_TYPES[type].kind === kind);
+}
+
+const CALENDAR_NAMES = ["AT", "DE", "SG", "none"];
+const STORED_HOLIDAYS = [...CALENDAR_NAMES, "custom"];
+const COUNTRY_CALENDARS = { AT: "AT", DE: "DE", SG: "SG" };
+function calendarOfCountry(country) {
+  return Object.hasOwn(COUNTRY_CALENDARS, country) ? COUNTRY_CALENDARS[country] : void 0;
+}
+function holidaysOf(site) {
+  if (site.calendar !== void 0) return typeof site.calendar === "function" ? "custom" : site.calendar;
+  if (site.country !== void 0) return calendarOfCountry(site.country) ?? "none";
+  return void 0;
+}
+
+export { CALENDAR_NAMES as C, STORED_HOLIDAYS as S, UPLOAD_TYPES as U, acceptOf as a, calendarOfCountry as c, formatMb as f, holidaysOf as h, limitOf as l, roundedMb as r };