@webround/core 0.1.8 → 0.3.0

package/dist/seo.d.ts

@@ -0,0 +1,167 @@
+import { type WrLocalized } from './localized.js';
+import { type WrLangConfig, type WrRoutesFile } from './routing.js';
+import type { WrPageConfig } from './types.js';
+/** The key under which a page's JSON holds its SEO data (an element id never starts with an underscore). */
+export declare const WR_SEO_KEY = "_seo";
+/** What is the same for the whole site (`config/seo.json`). */
+export interface WrSeoSite {
+    /** Public address of the site, no path: `https://www.example.com`. Without it nothing absolute (canonical, hreflang, sitemaps) can be said. */
+    siteUrl?: string;
+    /** The name of the site: it can be written per language (`{ default, en }`), like every text. */
+    siteName?: WrLocalized;
+    /** How a page title is shown, `%s` being the title: `%s | Acme`. Per language when it must be (`{ default, en }`). */
+    titleTemplate?: WrLocalized;
+    /** The icon of the site in the browser tab and in search results: a path in the site or a full address (png, svg, ico…). */
+    favicon?: string;
+    /** Picture shown when a page is shared and says none of its own (a path in the site or a full address); per language for a picture with words on it. */
+    image?: WrLocalized;
+    /** Structured data (JSON-LD) of every page: the organisation, the website… A list of objects, or one list per language. */
+    jsonLd?: WrSeoJsonLd;
+    /** The accounts shown when a page is shared on X/Twitter (a page can say its own). */
+    twitter?: {
+        site?: string;
+        creator?: string;
+    };
+    /** Sitemaps the site does not write itself and the index must point to (e.g. the shop's `sitemap-products.xml`): file names or addresses. */
+    extraSitemaps?: string[];
+    /** The code Google Search Console gives to prove the site is yours (the `content` of its `google-site-verification` tag): only the code, never the tag. It goes in `index.html` (vite-plugins/head.ts), not in the tags of `wrSeoTags`: a crawler looks for it before any script runs. */
+    searchConsole?: string;
+}
+/** What one page says (under `_seo` in its JSON). Text can be translated like every other text. */
+export interface WrSeoPage {
+    title?: WrLocalized;
+    description?: WrLocalized;
+    /** The picture shown when the page is shared (a path in the site or a full address); per language for a picture with words on it. */
+    image?: WrLocalized;
+    /** Keep the page out of search engines (and out of the sitemap). */
+    noindex?: boolean;
+    /** The page this one is a copy of, if it is not itself (a path in the site or a full address). */
+    canonical?: string;
+    /** The robots directives, in full (`noindex, follow`, `max-snippet:-1`…): when set they replace what `noindex` would say. */
+    robots?: string;
+    /** What social networks show, when it must not be the page's own title, description and picture. */
+    og?: WrSeoOpenGraph;
+    twitter?: {
+        card?: 'summary' | 'summary_large_image';
+        site?: string;
+        creator?: string;
+    };
+    /** Any other `<meta>` the page needs (`name` or `property`, and its content). */
+    meta?: WrSeoMeta[];
+    /** Structured data (JSON-LD) of this page, added to the site's. */
+    jsonLd?: WrSeoJsonLd;
+}
+/**
+ * The verification code of Google Search Console from whatever was pasted: the code itself, or the whole `<meta name="google-site-verification" content="…">` tag Google
+ * shows (the way it is given). Null when it is neither: nothing else ends up in a page's head through here.
+ */
+export declare function wrSearchConsoleCode(input: string | undefined | null): string | null;
+export interface WrSeoOpenGraph {
+    title?: WrLocalized;
+    description?: WrLocalized;
+    image?: WrLocalized;
+    type?: string;
+}
+export interface WrSeoMeta {
+    name?: string;
+    property?: string;
+    content: WrLocalized;
+}
+/** One JSON-LD object (`{ "@type": "Organization", … }`). */
+export type WrJsonLd = Record<string, unknown>;
+/** JSON-LD of a page or of the site: a list of objects, or `{ default: […], en: […] }` when it is written per language. */
+export type WrSeoJsonLd = WrJsonLd[] | Record<string, WrJsonLd[]>;
+export declare const WR_ROBOTS_FILE = "robots.txt";
+export declare const WR_SITEMAP_INDEX_FILE = "sitemap-index.xml";
+export declare const WR_SITEMAP_PAGES_FILE = "sitemap-pages.xml";
+/** A page's SEO data out of its JSON (an empty object when it says nothing). */
+export declare function wrSeoPageOf(config: WrPageConfig | undefined): WrSeoPage;
+/** The site's address without a trailing slash, or undefined when it is not an http(s) address. */
+export declare function wrSiteUrlOf(site: WrSeoSite | undefined): string | undefined;
+/** The JSON-LD objects for a language: the list as it is, or the language's list (the default one's when it has none). */
+export declare function wrSeoJsonLdOf(value: unknown, lang: string): WrJsonLd[];
+/** What is wrong with a JSON-LD value (empty when it is fine): it is written by hand, in the panel or in VS Code, and a broken one is silently ignored by search engines. */
+export declare function wrJsonLdProblems(value: unknown): string[];
+/** A JSON-LD object as the text of a `<script type="application/ld+json">`: `@context` is schema.org unless said, and nothing in it can end the script. */
+export declare function wrJsonLdText(item: WrJsonLd): string;
+export interface WrSeoTag {
+    tag: 'meta' | 'link';
+    attrs: Record<string, string>;
+}
+export interface WrSeoHead {
+    title?: string;
+    tags: WrSeoTag[];
+    /** The texts of the `<script type="application/ld+json">` the page has: the site's, then the page's. */
+    jsonLd: string[];
+}
+export interface WrSeoContext {
+    site?: WrSeoSite;
+    page?: WrSeoPage;
+    /** The page's path without a language prefix: `/`, `/about`. */
+    path: string;
+    /** The language shown: `default`, or a code. */
+    lang: string;
+    langs?: WrLangConfig;
+}
+/** The text of the tab: the page's title in the template, or the site's name when the page has none. */
+export declare function wrSeoTitle({ site, page, lang }: Pick<WrSeoContext, 'site' | 'page' | 'lang'>): string | undefined;
+/** Everything a page puts in `<head>` for search engines and social networks: ONE function, whoever renders or injects it. */
+export declare function wrSeoTags(context: WrSeoContext): WrSeoHead;
+/** A page of the site as a sitemap sees it: its address in every language. */
+export interface WrSeoEntry {
+    pageName: string;
+    path: string;
+    noindex: boolean;
+    urls: {
+        lang: string;
+        url: string;
+    }[];
+}
+/**
+ * The pages a sitemap can list: those with a fixed address (a `[slug]` route is a family of pages the shop's own sitemap tells about).
+ * Pages marked noindex are kept in the list (the checks and the editor show them) and left out by `wrSitemapPagesXml`.
+ */
+export declare function wrSeoEntries(input: {
+    routes: WrRoutesFile;
+    pages: Record<string, WrPageConfig | undefined>;
+    langs?: WrLangConfig;
+    site?: WrSeoSite;
+}): WrSeoEntry[];
+/** A page in a language that a build prerenders for crawlers, and the file of `dist/` its HTML is written to. */
+export interface WrSnapshotTarget {
+    pageName: string;
+    lang: string;
+    /** The address: `/`, `/about`, `/en`, `/en/about`. */
+    path: string;
+    file: string;
+}
+/**
+ * Where the prerendered HTML of an address goes in `dist/`: the home of a language is `<lang>/index.html` (the default language has no prefix:
+ * its home is `index.html`), any other address is `<address>.html` (`/en/about` → `en/about.html`, `/about` → `about.html`).
+ */
+export declare function wrSnapshotFile(path: string, langs?: WrLangConfig): string;
+/**
+ * The pages a build prerenders: every page with a fixed address, in every language, but those marked noindex (a crawler is told to leave them
+ * alone). The same list the sitemap is made from (`wrSeoEntries`), so there is no second list of pages.
+ */
+export declare function wrSnapshotTargets(input: {
+    routes: WrRoutesFile;
+    pages: Record<string, WrPageConfig | undefined>;
+    langs?: WrLangConfig;
+}): WrSnapshotTarget[];
+/** The sitemap of the site's own pages: one `<url>` per language version, each with all its alternates. */
+export declare function wrSitemapPagesXml(entries: readonly WrSeoEntry[], langs?: WrLangConfig): string;
+/** The index of the sitemaps: the site's own, and whichever others the site says exist (e.g. the shop's, written by the server). */
+export declare function wrSitemapIndexXml(siteUrl: string, files: readonly string[]): string;
+export declare function wrRobotsTxt(siteUrl: string): string;
+/**
+ * The files a site has for search engines, by name (relative to `public/`): robots.txt, the index and the sitemap of the site's pages.
+ * `null` while the site does not know its public address: there is nothing true to write.
+ */
+export declare function wrSeoFiles(input: {
+    routes: WrRoutesFile;
+    pages: Record<string, WrPageConfig | undefined>;
+    langs?: WrLangConfig;
+    site?: WrSeoSite;
+}): Record<string, string> | null;
+//# sourceMappingURL=seo.d.ts.map

package/dist/seo.js

@@ -0,0 +1,221 @@
+// What a search engine and a social network read from a page. ONE place says what the data is (`WrSeoSite`, `WrSeoPage`), ONE function
+// turns it into tags (`wrSeoTags`: the page renders it, and whoever injects metadata into a static snapshot calls the same one) and ONE
+// function turns the whole site into its files (`wrSeoFiles`: robots.txt and the sitemaps). Pure: no React, no Node, no I/O.
+// `.js` on purpose: the operations and the dev server run this in Node, which wants the extension (the bundlers resolve it to the .ts)
+import { wrLocalized } from './localized.js';
+import { wrBuildLangPath, wrRoutePattern } from './routing.js';
+/** The key under which a page's JSON holds its SEO data (an element id never starts with an underscore). */
+export const WR_SEO_KEY = '_seo';
+/**
+ * The verification code of Google Search Console from whatever was pasted: the code itself, or the whole `<meta name="google-site-verification" content="…">` tag Google
+ * shows (the way it is given). Null when it is neither: nothing else ends up in a page's head through here.
+ */
+export function wrSearchConsoleCode(input) {
+    const text = (input ?? '').trim();
+    const tag = /^<meta\s+[^>]*\bname\s*=\s*["']google-site-verification["'][^>]*\bcontent\s*=\s*["']([^"']*)["'][^>]*\/?>$/i.exec(text)
+        ?? /^<meta\s+[^>]*\bcontent\s*=\s*["']([^"']*)["'][^>]*\bname\s*=\s*["']google-site-verification["'][^>]*\/?>$/i.exec(text);
+    const code = (tag ? tag[1] : text).trim();
+    return /^[A-Za-z0-9_-]{10,200}$/.test(code) ? code : null;
+}
+export const WR_ROBOTS_FILE = 'robots.txt';
+export const WR_SITEMAP_INDEX_FILE = 'sitemap-index.xml';
+export const WR_SITEMAP_PAGES_FILE = 'sitemap-pages.xml';
+/** A page's SEO data out of its JSON (an empty object when it says nothing). */
+export function wrSeoPageOf(config) {
+    const raw = config?.[WR_SEO_KEY];
+    return raw && typeof raw === 'object' ? raw : {};
+}
+/** The site's address without a trailing slash, or undefined when it is not an http(s) address. */
+export function wrSiteUrlOf(site) {
+    const raw = site?.siteUrl?.trim();
+    if (!raw || !/^https?:\/\/[^\s/]+/i.test(raw))
+        return undefined;
+    return raw.replace(/\/+$/, '');
+}
+const isAbsolute = (value) => /^https?:\/\//i.test(value);
+const absolute = (siteUrl, value) => !value ? undefined : isAbsolute(value) ? value : siteUrl ? `${siteUrl}${value.startsWith('/') ? '' : '/'}${value}` : undefined;
+/** A page's path in a language (`/about`, `/en/about`): the default language has no prefix. `langKey` is `default` or a code. */
+function pathIn(path, langKey, langs) {
+    return langs ? wrBuildLangPath(langKey, path, langs) : path;
+}
+const ICON_TYPES = { png: 'image/png', svg: 'image/svg+xml', ico: 'image/x-icon', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp' };
+/** The `type` of an icon from its extension (a hint to the browser: it picks what it can draw); nothing when it cannot be told. */
+const iconType = (href) => {
+    const type = ICON_TYPES[/\.([a-z0-9]+)(?:[?#].*)?$/i.exec(href)?.[1]?.toLowerCase() ?? ''];
+    return type ? { type } : {};
+};
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** The JSON-LD objects for a language: the list as it is, or the language's list (the default one's when it has none). */
+export function wrSeoJsonLdOf(value, lang) {
+    const list = Array.isArray(value) ? value : isObject(value) ? (value[lang] ?? value.default) : [];
+    return (Array.isArray(list) ? list : []).filter(isObject);
+}
+/** What is wrong with a JSON-LD value (empty when it is fine): it is written by hand, in the panel or in VS Code, and a broken one is silently ignored by search engines. */
+export function wrJsonLdProblems(value) {
+    const problems = [];
+    const lists = Array.isArray(value) ? [['', value]] : isObject(value) ? Object.entries(value) : [];
+    if (value !== undefined && lists.length === 0)
+        return ['JSON-LD must be a list of objects, or one list per language'];
+    for (const [lang, list] of lists) {
+        const where = lang ? ` (${lang})` : '';
+        if (!Array.isArray(list)) {
+            problems.push(`the JSON-LD${where} must be a list of objects`);
+            continue;
+        }
+        list.forEach((item, i) => {
+            if (!isObject(item))
+                problems.push(`JSON-LD item ${i + 1}${where} must be an object`);
+            else if (!('@type' in item) && !('@graph' in item))
+                problems.push(`JSON-LD item ${i + 1}${where} has no "@type"`);
+        });
+    }
+    return problems;
+}
+/** A JSON-LD object as the text of a `<script type="application/ld+json">`: `@context` is schema.org unless said, and nothing in it can end the script. */
+export function wrJsonLdText(item) {
+    return JSON.stringify('@context' in item ? item : { '@context': 'https://schema.org', ...item })
+        .replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+}
+/** The text of the tab: the page's title in the template, or the site's name when the page has none. */
+export function wrSeoTitle({ site, page, lang }) {
+    const own = wrLocalized(page?.title, lang)?.trim();
+    if (!own)
+        return wrLocalized(site?.siteName, lang)?.trim() || undefined;
+    const template = wrLocalized(site?.titleTemplate, lang);
+    return template && template.includes('%s') ? template.replace('%s', own) : own;
+}
+/** Everything a page puts in `<head>` for search engines and social networks: ONE function, whoever renders or injects it. */
+export function wrSeoTags(context) {
+    const { site, page, path, lang, langs } = context;
+    const siteUrl = wrSiteUrlOf(site);
+    const title = wrSeoTitle(context);
+    const description = wrLocalized(page?.description, lang)?.trim();
+    const tags = [];
+    const icon = site?.favicon?.trim();
+    if (icon)
+        tags.push({ tag: 'link', attrs: { rel: 'icon', href: icon, ...iconType(icon) } });
+    const meta = (key, name, content) => { if (content)
+        tags.push({ tag: 'meta', attrs: { [key]: name, content } }); };
+    meta('name', 'description', description);
+    // `robots` says it all when it is set; otherwise `noindex` is `noindex, nofollow`. A page kept out of search engines says nothing that invites them in.
+    const robots = page?.robots?.trim() || (page?.noindex ? 'noindex, nofollow' : undefined);
+    const indexable = !/\bnoindex\b/i.test(robots ?? '');
+    meta('name', 'robots', robots);
+    if (indexable && siteUrl) {
+        const canonical = absolute(siteUrl, page?.canonical) ?? `${siteUrl}${pathIn(path, lang, langs)}`;
+        tags.push({ tag: 'link', attrs: { rel: 'canonical', href: canonical } });
+        if (langs && langs.available.length > 1) {
+            for (const code of langs.available) {
+                const key = code === langs.default ? 'default' : code;
+                tags.push({ tag: 'link', attrs: { rel: 'alternate', hreflang: code, href: `${siteUrl}${pathIn(path, key, langs)}` } });
+            }
+            tags.push({ tag: 'link', attrs: { rel: 'alternate', hreflang: 'x-default', href: `${siteUrl}${pathIn(path, 'default', langs)}` } });
+        }
+    }
+    const og = page?.og;
+    const image = absolute(siteUrl, wrLocalized(og?.image, lang)?.trim() || wrLocalized(page?.image, lang)?.trim() || wrLocalized(site?.image, lang)?.trim());
+    meta('property', 'og:type', og?.type?.trim() || 'website');
+    meta('property', 'og:title', wrLocalized(og?.title, lang)?.trim() || title);
+    meta('property', 'og:description', wrLocalized(og?.description, lang)?.trim() || description);
+    meta('property', 'og:site_name', wrLocalized(site?.siteName, lang)?.trim());
+    meta('property', 'og:image', image);
+    meta('property', 'og:url', siteUrl && indexable ? `${siteUrl}${pathIn(path, lang, langs)}` : undefined);
+    meta('name', 'twitter:card', page?.twitter?.card ?? (image ? 'summary_large_image' : 'summary'));
+    meta('name', 'twitter:site', page?.twitter?.site?.trim() || site?.twitter?.site?.trim());
+    meta('name', 'twitter:creator', page?.twitter?.creator?.trim() || site?.twitter?.creator?.trim());
+    // Whatever else the page needs
+    for (const extra of page?.meta ?? []) {
+        const content = wrLocalized(extra.content, lang)?.trim();
+        if (extra.property?.trim())
+            meta('property', extra.property.trim(), content);
+        else if (extra.name?.trim())
+            meta('name', extra.name.trim(), content);
+    }
+    const jsonLd = [...wrSeoJsonLdOf(site?.jsonLd, lang), ...wrSeoJsonLdOf(page?.jsonLd, lang)].map(wrJsonLdText);
+    return { title, tags, jsonLd };
+}
+/**
+ * The pages a sitemap can list: those with a fixed address (a `[slug]` route is a family of pages the shop's own sitemap tells about).
+ * Pages marked noindex are kept in the list (the checks and the editor show them) and left out by `wrSitemapPagesXml`.
+ */
+export function wrSeoEntries(input) {
+    const { routes, pages, langs, site } = input;
+    const siteUrl = wrSiteUrlOf(site) ?? '';
+    return Object.keys(routes)
+        .filter(name => !/\[[^\]]+\]/.test(name))
+        .map((pageName) => {
+        const path = wrRoutePattern(pageName);
+        const codes = langs && langs.available.length > 0 ? langs.available : [undefined];
+        const urls = codes.map((code) => {
+            const key = code === undefined || code === langs?.default ? 'default' : code;
+            return { lang: code ?? 'default', url: `${siteUrl}${pathIn(path, key, langs)}` };
+        });
+        const own = wrSeoPageOf(pages[pageName]);
+        return { pageName, path, noindex: own.noindex === true || /\bnoindex\b/i.test(own.robots ?? ''), urls };
+    });
+}
+/**
+ * Where the prerendered HTML of an address goes in `dist/`: the home of a language is `<lang>/index.html` (the default language has no prefix:
+ * its home is `index.html`), any other address is `<address>.html` (`/en/about` → `en/about.html`, `/about` → `about.html`).
+ */
+export function wrSnapshotFile(path, langs) {
+    const segments = path.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return 'index.html';
+    if (segments.length === 1 && langs?.available.includes(segments[0]))
+        return `${segments[0]}/index.html`;
+    return `${segments.join('/')}.html`;
+}
+/**
+ * The pages a build prerenders: every page with a fixed address, in every language, but those marked noindex (a crawler is told to leave them
+ * alone). The same list the sitemap is made from (`wrSeoEntries`), so there is no second list of pages.
+ */
+export function wrSnapshotTargets(input) {
+    // Without the site's public address the addresses are the paths
+    return wrSeoEntries({ ...input, site: undefined })
+        .filter(entry => !entry.noindex)
+        .flatMap(entry => entry.urls.map(({ lang, url }) => ({ pageName: entry.pageName, lang, path: url, file: wrSnapshotFile(url, input.langs) })));
+}
+const xml = (text) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const XML_HEAD = '<?xml version="1.0" encoding="UTF-8"?>\n';
+/** The sitemap of the site's own pages: one `<url>` per language version, each with all its alternates. */
+export function wrSitemapPagesXml(entries, langs) {
+    const rows = [];
+    for (const entry of entries) {
+        if (entry.noindex)
+            continue;
+        const home = entry.urls.find(u => u.lang === langs?.default) ?? entry.urls[0];
+        const alternates = entry.urls.length > 1
+            ? [...entry.urls.map(u => `    <xhtml:link rel="alternate" hreflang="${xml(u.lang)}" href="${xml(u.url)}"/>`),
+                `    <xhtml:link rel="alternate" hreflang="x-default" href="${xml(home.url)}"/>`]
+            : [];
+        for (const { url } of entry.urls)
+            rows.push(['  <url>', `    <loc>${xml(url)}</loc>`, ...alternates, '  </url>'].join('\n'));
+    }
+    return `${XML_HEAD}<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">\n${rows.join('\n')}\n</urlset>\n`;
+}
+/** The index of the sitemaps: the site's own, and whichever others the site says exist (e.g. the shop's, written by the server). */
+export function wrSitemapIndexXml(siteUrl, files) {
+    const rows = files.map(file => `  <sitemap>\n    <loc>${xml(isAbsolute(file) ? file : `${siteUrl}/${file.replace(/^\/+/, '')}`)}</loc>\n  </sitemap>`);
+    return `${XML_HEAD}<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${rows.join('\n')}\n</sitemapindex>\n`;
+}
+export function wrRobotsTxt(siteUrl) {
+    return `User-agent: *\nAllow: /\n\nSitemap: ${siteUrl}/${WR_SITEMAP_INDEX_FILE}\n`;
+}
+/**
+ * The files a site has for search engines, by name (relative to `public/`): robots.txt, the index and the sitemap of the site's pages.
+ * `null` while the site does not know its public address: there is nothing true to write.
+ */
+export function wrSeoFiles(input) {
+    const siteUrl = wrSiteUrlOf(input.site);
+    if (!siteUrl)
+        return null;
+    const entries = wrSeoEntries(input);
+    const extra = (input.site?.extraSitemaps ?? []).filter(name => typeof name === 'string' && name.trim() && name !== WR_SITEMAP_PAGES_FILE);
+    return {
+        [WR_ROBOTS_FILE]: wrRobotsTxt(siteUrl),
+        [WR_SITEMAP_INDEX_FILE]: wrSitemapIndexXml(siteUrl, [WR_SITEMAP_PAGES_FILE, ...extra]),
+        [WR_SITEMAP_PAGES_FILE]: wrSitemapPagesXml(entries, input.langs),
+    };
+}
+//# sourceMappingURL=seo.js.map

package/dist/site-env.d.ts

@@ -0,0 +1,25 @@
+export interface WrSiteEnv {
+    /** The draft this site is: what the APIs call the store. */
+    draftId?: string;
+    /** The Webround core API, without a trailing slash. */
+    coreApiUrl?: string;
+    /** The store's API (customers, cart, checkout), without a trailing slash. */
+    commerceApiUrl?: string;
+    /** The store's catalog API (products, collections, filters), without a trailing slash. */
+    catalogApiUrl?: string;
+    /** The checkout API (it starts the payment of a cart), without a trailing slash. */
+    checkoutApiUrl?: string;
+}
+/** The names a site's build reads: the contract with whoever starts it (the Worker). */
+export declare const WR_SITE_ENV_VARS: {
+    readonly draftId: "VITE_WR_DRAFT_ID";
+    readonly coreApiUrl: "VITE_WR_CORE_API_URL";
+    readonly commerceApiUrl: "VITE_WR_COMMERCE_API_URL";
+    readonly catalogApiUrl: "VITE_WR_CATALOG_API_URL";
+    readonly checkoutApiUrl: "VITE_WR_CHECKOUT_API_URL";
+};
+/** What is written down, with the empty ones left out and no `/` at the end of a URL. Pure: it reads the object it is given. */
+export declare function wrSiteEnvFrom(env: Record<string, unknown> | undefined): WrSiteEnv;
+/** What this site was built with. `import.meta.env` exists where Vite built the page; anywhere else there is nothing, and so nothing is said. */
+export declare function wrSiteEnv(): WrSiteEnv;
+//# sourceMappingURL=site-env.d.ts.map

package/dist/site-env.js

@@ -0,0 +1,37 @@
+// What a site knows about where it lives: which draft it is and where the Webround APIs are. ONE place reads it, so the form today and
+// the shop and the catalog tomorrow ask the same thing the same way.
+//
+// The values come from the process the site is built or served by (`VITE_WR_*`): the Worker that runs the draft's container sets them, and the
+// site's own `.env` files are not involved (Vite lets the process win only for the same name; every other variable of the owner stays theirs).
+/** The names a site's build reads: the contract with whoever starts it (the Worker). */
+export const WR_SITE_ENV_VARS = {
+    draftId: 'VITE_WR_DRAFT_ID',
+    coreApiUrl: 'VITE_WR_CORE_API_URL',
+    commerceApiUrl: 'VITE_WR_COMMERCE_API_URL',
+    catalogApiUrl: 'VITE_WR_CATALOG_API_URL',
+    checkoutApiUrl: 'VITE_WR_CHECKOUT_API_URL',
+};
+/** What is written down, with the empty ones left out and no `/` at the end of a URL. Pure: it reads the object it is given. */
+export function wrSiteEnvFrom(env) {
+    const text = (name) => {
+        const value = env?.[name];
+        return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+    };
+    const url = (name) => text(name)?.replace(/\/+$/, '') || undefined;
+    const coreApiUrl = url(WR_SITE_ENV_VARS.coreApiUrl);
+    const commerceApiUrl = url(WR_SITE_ENV_VARS.commerceApiUrl);
+    const catalogApiUrl = url(WR_SITE_ENV_VARS.catalogApiUrl);
+    const checkoutApiUrl = url(WR_SITE_ENV_VARS.checkoutApiUrl);
+    return {
+        draftId: text(WR_SITE_ENV_VARS.draftId),
+        ...(coreApiUrl ? { coreApiUrl } : {}),
+        ...(commerceApiUrl ? { commerceApiUrl } : {}),
+        ...(catalogApiUrl ? { catalogApiUrl } : {}),
+        ...(checkoutApiUrl ? { checkoutApiUrl } : {}),
+    };
+}
+/** What this site was built with. `import.meta.env` exists where Vite built the page; anywhere else there is nothing, and so nothing is said. */
+export function wrSiteEnv() {
+    return wrSiteEnvFrom(import.meta.env);
+}
+//# sourceMappingURL=site-env.js.map