@lupinum/ginko 0.4.0 → 0.6.0

package/dist/shared/{ginko.Bwan3BB-.d.mts → ginko.B_pACpVU.d.ts}

@@ -1,11 +1,11 @@
-import { L as Locale, C as Currency, M as MarkdownTree, S as Schema, F as Fields, J as Json } from './ginko.D-fNojn9.mjs';
+import { L as Locale, C as Currency, M as MarkdownTree, S as Schema, F as Fields, J as Json } from './ginko.DrkUeYFP.js';
 
 /** 3: text fields carry comark trees; collection items carry `updatedAt` and, for file entries, `source`. Other formats are refused. */
 declare const BUNDLE_FORMAT = 3;
 interface BundleItem {
     id: string;
     data: Record<string, unknown>;
-    /** Leaves delivered in the main language because the requested translation is missing or outdated. */
+    /** Leaves delivered in the main language because the requested translation is missing. */
     fallback: string[];
     /** Only for collections with `route`, only visible entries, only locales where the entry exists. */
     urls?: Partial<Record<Locale, string>>;

package/dist/shared/ginko.BaFweQcB.d.mts

@@ -0,0 +1,91 @@
+import './ginko.DkIc0ZZk.mjs';
+import { af as Money, F as Fields } from './ginko.DrkUeYFP.mjs';
+import './ginko.o1yIKlgj.mjs';
+import { a as BundleItem, B as Bundle } from './ginko.6cI8KXZP.mjs';
+
+/** http(s), mailto, tel, a same-site path or fragment, or a `$` route link. Everything else (javascript:, data:, //host) is unsafe. */
+declare function isSafeHref(href: string): boolean;
+/** The link or image URL when it is safe (see `isSafeHref`), else undefined: for `href`/`src` from content. */
+declare function safeHref(href: string | undefined): string | undefined;
+
+/**
+ * Money is stored as an integer count of the currency's minor units (cents for EUR, whole yen for JPY).
+ * `minorDigits` says how many decimals one unit has: 2 for EUR, 0 for JPY, 3 for KWD.
+ */
+declare function minorDigits(currency: string): number;
+/** Options of `formatMoney`. */
+interface FormatMoneyOptions {
+    /** A whole amount without its minor units: `€390` instead of `€390.00`; `€12.50` stays as it is. Default false. */
+    wholeWithoutMinor?: boolean;
+}
+/**
+ * The amount in the notation of `language`, a BCP 47 tag such as `de-AT` (use `useI18n().language`, not the URL
+ * code): `12,50 €` in de, `€ 12,50` in de-AT, `€12.50` in en, `¥1,250` for JPY.
+ * Every space is a no-break space: Node and browsers ship different ICU data (one uses a plain
+ * space), so a server-rendered price would otherwise differ from the hydrated one, and a price never breaks in two.
+ */
+declare function formatMoney(money: Money, language: string, options?: FormatMoneyOptions): string;
+
+type Data = Record<string, unknown>;
+/** What a condition compares a value with: one element of a list value, money by `amount`, a daterange by its start date. */
+type Comparable<V> = V extends readonly (infer E)[] ? E : V extends Money ? Pick<Money, 'amount'> : V extends {
+    from: string;
+} ? string : V;
+/**
+ * A test on one field. `eq`/`ne`: equal or not (for a list value: one element is). `gt`, `gte`, `lt`, `lte`: compare.
+ * `in`: equal to one of these. `contains`: a text contains this text (case-insensitive), a list contains this element.
+ */
+interface Condition<V = unknown> {
+    eq?: Comparable<V> | null;
+    ne?: Comparable<V> | null;
+    gt?: Comparable<V>;
+    gte?: Comparable<V>;
+    lt?: Comparable<V>;
+    lte?: Comparable<V>;
+    in?: readonly Comparable<V>[];
+    contains?: Comparable<V>;
+}
+/** A sort order: the text `'price desc, name'` (`asc` is the default) or `{ field, dir? }` like a brick's `order`. */
+type QueryOrder<D = Data> = string | {
+    field: keyof D & string;
+    dir?: 'asc' | 'desc';
+};
+/** `D` is the data of the brick's entries; `useGinkoQuery` sets it, so field names and values are checked. */
+interface Query<D = Data> {
+    /** Per field a value (equal to it) or a `Condition`; every field must match. */
+    where?: {
+        [K in keyof D]?: Comparable<D[K]> | null | Condition<D[K]>;
+    };
+    /** Default: the bundle's item order. */
+    order?: QueryOrder<D>;
+    /** At least 1; without it, every matching entry. */
+    limit?: number;
+    /** 1-based. */
+    page?: number;
+    fields?: (keyof D & string)[];
+    facets?: (keyof D & string)[];
+    include?: (keyof D & string)[];
+}
+interface QueryResult {
+    items: BundleItem[];
+    total: number;
+    page: number;
+    pages: number;
+    facets?: Record<string, Record<string, number>>;
+}
+/** What `query` reads of the schema: the fields of each brick (a full `Schema` fits). */
+interface QuerySchema {
+    bricks: Record<string, {
+        fields: Fields;
+    }>;
+}
+/** Filter, order, page, project and enrich the items of one collection brick. Pure; throws on a field the brick does not have. */
+declare function query(bundle: Bundle, brick: string, q?: Query, schema?: QuerySchema): QueryResult;
+/** The items before and after `id` in the given (or default) order. Both are missing for an unknown id. */
+declare function neighbors(bundle: Bundle, brick: string, id: string, order?: QueryOrder): {
+    prev?: BundleItem;
+    next?: BundleItem;
+};
+
+export { formatMoney as f, isSafeHref as i, minorDigits as m, neighbors as n, query as q, safeHref as s };
+export type { Condition as C, FormatMoneyOptions as F, Query as Q, QueryOrder as a, QueryResult as b, QuerySchema as c };

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

@@ -0,0 +1,91 @@
+import './ginko.CLzVaDi4.js';
+import { af as Money, F as Fields } from './ginko.DrkUeYFP.js';
+import './ginko.CjWB8N7f.js';
+import { a as BundleItem, B as Bundle } from './ginko.B_pACpVU.js';
+
+/** http(s), mailto, tel, a same-site path or fragment, or a `$` route link. Everything else (javascript:, data:, //host) is unsafe. */
+declare function isSafeHref(href: string): boolean;
+/** The link or image URL when it is safe (see `isSafeHref`), else undefined: for `href`/`src` from content. */
+declare function safeHref(href: string | undefined): string | undefined;
+
+/**
+ * Money is stored as an integer count of the currency's minor units (cents for EUR, whole yen for JPY).
+ * `minorDigits` says how many decimals one unit has: 2 for EUR, 0 for JPY, 3 for KWD.
+ */
+declare function minorDigits(currency: string): number;
+/** Options of `formatMoney`. */
+interface FormatMoneyOptions {
+    /** A whole amount without its minor units: `€390` instead of `€390.00`; `€12.50` stays as it is. Default false. */
+    wholeWithoutMinor?: boolean;
+}
+/**
+ * The amount in the notation of `language`, a BCP 47 tag such as `de-AT` (use `useI18n().language`, not the URL
+ * code): `12,50 €` in de, `€ 12,50` in de-AT, `€12.50` in en, `¥1,250` for JPY.
+ * Every space is a no-break space: Node and browsers ship different ICU data (one uses a plain
+ * space), so a server-rendered price would otherwise differ from the hydrated one, and a price never breaks in two.
+ */
+declare function formatMoney(money: Money, language: string, options?: FormatMoneyOptions): string;
+
+type Data = Record<string, unknown>;
+/** What a condition compares a value with: one element of a list value, money by `amount`, a daterange by its start date. */
+type Comparable<V> = V extends readonly (infer E)[] ? E : V extends Money ? Pick<Money, 'amount'> : V extends {
+    from: string;
+} ? string : V;
+/**
+ * A test on one field. `eq`/`ne`: equal or not (for a list value: one element is). `gt`, `gte`, `lt`, `lte`: compare.
+ * `in`: equal to one of these. `contains`: a text contains this text (case-insensitive), a list contains this element.
+ */
+interface Condition<V = unknown> {
+    eq?: Comparable<V> | null;
+    ne?: Comparable<V> | null;
+    gt?: Comparable<V>;
+    gte?: Comparable<V>;
+    lt?: Comparable<V>;
+    lte?: Comparable<V>;
+    in?: readonly Comparable<V>[];
+    contains?: Comparable<V>;
+}
+/** A sort order: the text `'price desc, name'` (`asc` is the default) or `{ field, dir? }` like a brick's `order`. */
+type QueryOrder<D = Data> = string | {
+    field: keyof D & string;
+    dir?: 'asc' | 'desc';
+};
+/** `D` is the data of the brick's entries; `useGinkoQuery` sets it, so field names and values are checked. */
+interface Query<D = Data> {
+    /** Per field a value (equal to it) or a `Condition`; every field must match. */
+    where?: {
+        [K in keyof D]?: Comparable<D[K]> | null | Condition<D[K]>;
+    };
+    /** Default: the bundle's item order. */
+    order?: QueryOrder<D>;
+    /** At least 1; without it, every matching entry. */
+    limit?: number;
+    /** 1-based. */
+    page?: number;
+    fields?: (keyof D & string)[];
+    facets?: (keyof D & string)[];
+    include?: (keyof D & string)[];
+}
+interface QueryResult {
+    items: BundleItem[];
+    total: number;
+    page: number;
+    pages: number;
+    facets?: Record<string, Record<string, number>>;
+}
+/** What `query` reads of the schema: the fields of each brick (a full `Schema` fits). */
+interface QuerySchema {
+    bricks: Record<string, {
+        fields: Fields;
+    }>;
+}
+/** Filter, order, page, project and enrich the items of one collection brick. Pure; throws on a field the brick does not have. */
+declare function query(bundle: Bundle, brick: string, q?: Query, schema?: QuerySchema): QueryResult;
+/** The items before and after `id` in the given (or default) order. Both are missing for an unknown id. */
+declare function neighbors(bundle: Bundle, brick: string, id: string, order?: QueryOrder): {
+    prev?: BundleItem;
+    next?: BundleItem;
+};
+
+export { formatMoney as f, isSafeHref as i, minorDigits as m, neighbors as n, query as q, safeHref as s };
+export type { Condition as C, FormatMoneyOptions as F, Query as Q, QueryOrder as a, QueryResult as b, QuerySchema as c };

package/dist/shared/ginko.C-oz8wwI.mjs

@@ -0,0 +1,95 @@
+function defineSite(site) {
+  return site;
+}
+function withoutFiles(site) {
+  const bricks = Object.fromEntries(Object.entries(site.bricks).map(([key, { source: _, ...brick }]) => [key, brick]));
+  return { ...site, bricks };
+}
+function siteForContent(site, content) {
+  if (!content) return site;
+  if (content === "platform") {
+    const bricks = Object.fromEntries(Object.entries(site.bricks).map(([key, brick]) => {
+      const copy = { ...brick };
+      delete copy.source;
+      return [key, copy];
+    }));
+    return { ...site, bricks };
+  }
+  throw new Error(`GINKO_CONTENT must be "platform" or unset, not "${content}".`);
+}
+function single(input) {
+  return { kind: "single", ...input, tasks: input.tasks };
+}
+function collection(input) {
+  return { kind: "collection", ...input, tasks: input.tasks };
+}
+
+function todayIn(timeZone, now = /* @__PURE__ */ new Date()) {
+  const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(now);
+  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+const readers = /* @__PURE__ */ new Map();
+function zoneOffset(timeZone, ms) {
+  let reader = readers.get(timeZone);
+  if (!reader) readers.set(timeZone, reader = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }));
+  const parts = reader.formatToParts(ms);
+  const get = (t) => Number(parts.find((p) => p.type === t)?.value ?? 0);
+  const local = Date.UTC(get("year"), get("month") - 1, get("day"), get("hour"), get("minute"), get("second"));
+  return local - Math.floor(ms / 1e3) * 1e3;
+}
+function zonedDateTime(date, time, timeZone) {
+  const naive = Date.parse(`${date}T${time}:00Z`);
+  const minutes = Math.round(zoneOffset(timeZone, naive - zoneOffset(timeZone, naive)) / 6e4);
+  const sign = minutes < 0 ? "-" : "+";
+  const abs = Math.abs(minutes);
+  return `${date}T${time}:00${sign}${String(Math.floor(abs / 60)).padStart(2, "0")}:${String(abs % 60).padStart(2, "0")}`;
+}
+function addDays(date, days) {
+  const d = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + days);
+  return d.toISOString().slice(0, 10);
+}
+const DEFAULT_WEEK = { firstDay: 1, weekend: [6, 7] };
+function weekInfoOf(language, firstDayOfWeek) {
+  let info = DEFAULT_WEEK;
+  try {
+    const locale = new Intl.Locale(language);
+    const found = locale.getWeekInfo?.() ?? locale.weekInfo;
+    if (found?.firstDay && Array.isArray(found.weekend)) info = { firstDay: found.firstDay, weekend: [...found.weekend] };
+  } catch {
+  }
+  return { firstDay: firstDayOfWeek ?? info.firstDay, weekend: info.weekend };
+}
+const isoDay = (date) => (/* @__PURE__ */ new Date(`${date}T00:00:00Z`)).getUTCDay() || 7;
+const placeInWeek = (day, week) => (day - week.firstDay + 7) % 7;
+function startOfWeek(date, week) {
+  return addDays(date, -placeInWeek(isoDay(date), week));
+}
+function workWeekOf(date, week) {
+  const lastWorkday = Math.max(-1, ...[1, 2, 3, 4, 5, 6, 7].filter((d) => !week.weekend.includes(d)).map((d) => placeInWeek(d, week)));
+  const own = startOfWeek(date, week);
+  return placeInWeek(isoDay(date), week) > lastWorkday ? addDays(own, 7) : own;
+}
+function firstDayShown(weekStart, week) {
+  for (let day = addDays(weekStart, -6); day < weekStart; day = addDays(day, 1)) if (workWeekOf(day, week) === weekStart) return day;
+  return weekStart;
+}
+function resolveToken(token, timeZone, week, now = /* @__PURE__ */ new Date()) {
+  const today = todayIn(timeZone, now);
+  if (token === "@today") return today;
+  if (token === "@workWeek") return workWeekOf(today, week);
+  if (token === "@nextWorkWeek") return addDays(workWeekOf(today, week), 7);
+  return void 0;
+}
+
+export { DEFAULT_WEEK as D, startOfWeek as a, addDays as b, collection as c, defineSite as d, weekInfoOf as e, firstDayShown as f, siteForContent as g, withoutFiles as h, zoneOffset as i, resolveToken as r, single as s, todayIn as t, workWeekOf as w, zonedDateTime as z };

package/dist/shared/{ginko.BDF3bW0C.d.ts → ginko.CLzVaDi4.d.ts}

@@ -1,5 +1,5 @@
-import { b as Msg, S as Schema, F as Fields, J as Json, L as Locale, C as Currency, B as Brick, a as ComponentRegistry, R as RetiredRule, c as Label, d as BrickSource, T as Task, V as Visibility, e as CollectionBrick, f as SingleBrick } from './ginko.D-fNojn9.js';
-import { B as Bundle } from './ginko.BBkZW2nW.js';
+import { a as Msg, S as Schema, F as Fields, J as Json, L as Locale, C as Currency, H as HolidaysOption, B as Brick, b as ComponentRegistry, R as RetiredRule, c as Label, d as BrickSource, T as Task, V as Visibility, e as CollectionStatus, f as CollectionBrick, g as SingleStatus, h as SingleBrick } from './ginko.DrkUeYFP.js';
+import { B as Bundle } from './ginko.B_pACpVU.js';
 
 interface Redirect {
     from: string;
@@ -59,10 +59,12 @@ type Pages = Pick<Schema, 'pages' | 'bricks'>;
 /**
  * The bundle with `$…` links turned into paths and `::snippet` components replaced by their text.
  * `$page.<key>` is a page of `schema.pages`; `$<brick>.<slug-or-id>` is an entry's URL; a `#anchor` is kept.
+ * `main` is the main-language bundle (from `buildBundle`, links unresolved): an entry left out of this locale because
+ * it is not translated (`untranslated: 'hide'`) is found there, and the link goes to its main-language page.
  * What cannot be resolved stays as it is and gets `data-broken: true`. A snippet is the `body` of the entry
  * `snippets/<name>` of the collection `snippets`; a snippet inside a snippet stays as it is. No mutation.
  */
-declare function resolveRouteLinks(bundle: Bundle, schema: Pages): Bundle;
+declare function resolveRouteLinks(bundle: Bundle, schema: Pages, main?: Bundle): Bundle;
 /**
  * Link check over bundles (one per locale) before any HTML exists. Errors: route links and snippets that
  * `resolveRouteLinks` could not resolve, and `/…` paths that match no entry URL, no page and no public file.
@@ -117,6 +119,16 @@ interface SiteInput {
      */
     firstDayOfWeek?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
     currency: Currency;
+    /**
+     * The country of the site (ISO 3166-1 alpha-2, e.g. `AT`). It picks the public-holiday calendar (`calendar`) and is
+     * the default `addressCountry` of JSON-LD. A country Ginko has no calendar for keeps no public holidays (`ginko check` warns).
+     */
+    country?: string;
+    /**
+     * Which public holidays count for opening hours: `AT`, `DE` (nationwide only), `SG`, `none`, or your own function
+     * `(year) => Holiday[]`. Default: the calendar of `country`. Stored in the schema as `holidays` (a function as `custom`).
+     */
+    calendar?: HolidaysOption;
     /**
      * Static pages by key: `{ menu: { de: '/speisekarte', en: '/en/menu' } }`. A plain path is the page in
      * the main locale only. The home page is the page whose main-locale path is `/`. The sitemap pairs a page's locales by key.
@@ -136,6 +148,7 @@ interface SiteInput {
         image?: string;
         /** The brand colour, `#rrggbb` or `#rgb`: the background of generated share cards (nuxt-og-image). */
         color?: string;
+        /** The home page's Organization JSON-LD. A page with its own (`siteJsonLd` of `@lupinum/ginko/basics`) gets none from here. */
         organization?: {
             logo?: string;
             sameAs?: string[];
@@ -170,12 +183,40 @@ type RetiredInput<S extends SiteInput> = {
 declare function defineSite<const S extends SiteInput>(site: S & {
     retired?: RetiredInput<S>;
 }): S;
+/**
+ * `site` as it runs on the platform: every brick without `source`, so the owner edits it in the Studio. A template
+ * that reads its content from files and this twin must both pass `checkSite`; tools and tests use it to prove that a
+ * files site can move to the platform without changing its bricks.
+ */
+declare function withoutFiles<const S extends SiteInput>(site: S): WithoutFiles<S>;
+/**
+ * The site for the content source `GINKO_CONTENT` names: unset or empty keeps the config as it is, `platform` is
+ * `withoutFiles(site)`. A files site deployed with `GINKO_CONTENT=platform` reads the Studio without a code change
+ * (the hosted template demos); the Nuxt module and the CLI both read it, so the build and `ginko release` agree.
+ */
+declare function siteForContent(site: SiteInput, content: string | undefined): SiteInput;
+/** `S` with no `source` on any brick. */
+type WithoutFiles<S extends SiteInput> = Omit<S, 'bricks'> & {
+    bricks: {
+        [K in keyof S['bricks']]: Omit<S['bricks'][K], 'source'>;
+    };
+};
 /** The names of the fields in `F` whose type is one of `T`. */
 type FieldsOfType<F, T extends string> = {
     [K in keyof F]: F[K] extends {
         type: T;
     } ? K : never;
 }[keyof F] & string;
+/**
+ * A planned change of one field (`planned`): from the date in the date field `from` on, `next` replaces `field`. `next`
+ * and `from` are optional and set together; every edit task that changes `field` lists them too. Field names only:
+ * a factory with generic fields could not name its date field otherwise, so `ginko check` reports the other rules.
+ */
+type Planned<F> = {
+    field: keyof F & string;
+    next: keyof F & string;
+    from: keyof F & string;
+};
 /** A collection's detail page per locale: a path with `[slug]` where the entry's slug goes, e.g. `/blog/[slug]`. */
 type RouteTemplate = `/${string}[slug]${string}`;
 declare function single<const F extends Fields>(input: {
@@ -185,6 +226,8 @@ declare function single<const F extends Fields>(input: {
     fields: F;
     layout?: 'sections' | 'tabs';
     tasks?: readonly Task<F>[];
+    planned?: Planned<F>;
+    status?: SingleStatus;
 }): SingleBrick<F>;
 declare function collection<const F extends Fields, const R extends Record<Locale, RouteTemplate> | undefined = undefined>(input: {
     label: Label;
@@ -193,6 +236,8 @@ declare function collection<const F extends Fields, const R extends Record<Local
     fields: F;
     layout?: 'sections' | 'tabs';
     tasks?: readonly Task<F>[];
+    /** A planned change of one field: from the date in `from` on, `next` replaces `field`. */
+    planned?: Planned<F>;
     max: number;
     order: 'manual' | {
         field: keyof F & string;
@@ -200,6 +245,10 @@ declare function collection<const F extends Fields, const R extends Record<Local
     };
     route?: R;
     visible?: Visibility<FieldsOfType<F, 'date' | 'daterange'>>;
+    /**
+     * A required translatable field is missing in a language: `'hide'` (default with a `route`) leaves the entry out
+     * there; `'fallback'` (default without) shows the main language and links to the main-language page.
+     */
     untranslated?: 'fallback' | 'hide';
     /** Entries plan weeks of the single brick `brick`; `field` (a date field of this collection) holds the first day of the week (`firstDayOfWeek`). */
     plans?: {
@@ -207,7 +256,9 @@ declare function collection<const F extends Fields, const R extends Record<Local
         field: FieldsOfType<F, 'date'>;
     };
     drafts?: boolean;
+    /** The status line on the Studio's Today page (see `CollectionStatus`). */
+    status?: CollectionStatus<FieldsOfType<F, 'date' | 'daterange'>, keyof F & string>;
 }): CollectionBrick<F, R>;
 
-export { checkLinks as d, collection as e, defineSite as f, entryRedirects as g, externalLinks as h, findRedirect as i, resolveRouteLinks as j, linkTargets as l, matchRedirect as m, redirectProblems as r, single as s };
-export type { CheckLinksOptions as C, ExternalLink as E, LinkConfig as L, Migration as M, Redirect as R, SiteInput as S, LinkIssue as a, MigrationContext as b, RouteTemplate as c };
+export { checkLinks as d, collection as e, defineSite as f, entryRedirects as g, externalLinks as h, findRedirect as i, resolveRouteLinks as j, siteForContent as k, linkTargets as l, matchRedirect as m, redirectProblems as r, single as s, withoutFiles as w };
+export type { CheckLinksOptions as C, ExternalLink as E, LinkConfig as L, Migration as M, RouteTemplate as R, SiteInput as S, WithoutFiles as W, LinkIssue as a, MigrationContext as b, Redirect as c };