@escape-game-over/atlas 0.1.115 → 0.1.117

package/src/astro/vendors.ts

@@ -0,0 +1,64 @@
+import type {
+    CONSENT_UPDATE_GLOBAL,
+    GOOGLE_EVENT_GLOBAL,
+    GoogleEventSink,
+} from "../analytics/google.ts";
+import type { Axon } from "./axon-pixel.ts";
+import type { Clarity } from "./clarity.ts";
+import type { ConsentChoices } from "./consent.ts";
+import type { Fbq } from "./meta-pixel.ts";
+import type { Snaptr } from "./snap-pixel.ts";
+import type { Ttq } from "./tiktok-pixel.ts";
+
+/** The callback the Maps API calls once it has loaded: `?callback=` names it. */
+export const GOOGLE_MAPS_CALLBACK = "__atlasGoogleMaps";
+
+/**
+ * Every global Atlas's scripts read or define: the vendors' own, and the ones
+ * Atlas's head script leaves for its modules.
+ *
+ * Each is optional, since a vendor's snippet defines it only once it runs,
+ * and a blocker can stop that. A file reads them through `vendors()` rather
+ * than casting `window` at each site.
+ *
+ * Not a `declare global`: that would put `window.fbq` in every app's types,
+ * on sites without Meta too. These stay Atlas's.
+ */
+interface Vendors {
+    fbq?: Fbq;
+    _fbq?: Fbq;
+    ttq?: Ttq;
+    TiktokAnalyticsObject?: string;
+    snaptr?: Snaptr;
+    axon?: Axon;
+    clarity?: Clarity;
+    _dcq?: unknown[][];
+    _dcs?: { account?: string };
+    umami?: { track(event: string, data?: object): void };
+    EscapeNavigator?: {
+        __pendingConsent?: { analytics: boolean; ads: boolean };
+        setConsent?: (consent: { analytics: boolean; ads: boolean }) => void;
+    };
+    // Its script builds selectors by appending to the one it is given, so the
+    // calendar is named by its id, not handed over as an element.
+    GetBookingCalendra?: (
+        selector: string,
+        settings: Record<string, unknown>
+    ) => void;
+    [GOOGLE_MAPS_CALLBACK]?: () => void;
+}
+
+/** Atlas's head script's, under the names it is emitted with. */
+type HeadGlobals = {
+    [Name in typeof CONSENT_UPDATE_GLOBAL]?: (choices: ConsentChoices) => void;
+} & {
+    [Name in typeof GOOGLE_EVENT_GLOBAL]?: GoogleEventSink;
+};
+
+/**
+ * `window`, typed with the globals above. A function, not a constant, so a
+ * module that imports it touches `window` only when it runs in a browser.
+ */
+export function vendors(): Window & Vendors & HeadGlobals {
+    return window;
+}

package/src/config.ts

@@ -173,15 +173,6 @@ export function defineSiteConfig<
     return config;
 }
 
-/**
- * What a project may restate about a locale.
- *
- * Only the label: writing direction is a fact about the script a language is
- * written in, not a choice a deployment makes, so it is derived from the tag.
- * The label is the one part that is a matter of taste.
- */
-export type LocaleMetaOverride = Pick<LocaleMeta, "label">;
-
 /**
  * Editor-facing error for a locale this site does not declare at all.
  *
@@ -199,27 +190,27 @@ export interface LocaleNotEnabled<L extends string> {
 }
 
 /**
- * Applies a project's overrides and derives the tag fields from the key.
+ * Each published locale's label, the project's where it gives one, with the
+ * tag fields derived from its key.
  *
  * The locale key is the language tag, and `ogLocale` is that tag with `-`
  * swapped for `_` — Open Graph writes `en_US` where BCP 47 writes `en-US`.
  * `dir` comes from the tag's script, so `ar-EG` and `az-Arab-IR` are
  * right-to-left and `az-AZ` is not.
  */
-export function mergeLocaleMeta<L extends string>(
+export function resolveLocaleMeta<L extends string>(
     base: Readonly<Record<L, LocaleMeta>>,
-    overrides: Readonly<Partial<Record<L, LocaleMetaOverride>>> | undefined,
-    locales: readonly L[]
+    locales: readonly L[],
+    labels: Readonly<Partial<Record<L, string>>>
 ): Readonly<Record<L, ResolvedLocaleMeta>> {
     const merged: Record<string, ResolvedLocaleMeta> = {};
     for (const locale of locales) {
-        const defaults = base[locale];
-        if (defaults === undefined) {
+        const meta = base[locale];
+        if (meta === undefined) {
             throw new Error(`No locale metadata for "${locale}".`);
         }
-        const meta = { ...defaults, ...overrides?.[locale] };
         merged[locale] = {
-            label: meta.label,
+            label: labels[locale] ?? meta.label,
             dir: writingDirection(locale),
             htmlLang: locale,
             ogLocale: locale.replace(/-/g, "_"),

package/src/content/rich.ts

@@ -61,8 +61,8 @@ export type Span =
     /**
      * A link, in the three shapes a destination actually comes in.
      *
-     * **A union rather than an optional `url` and an `external` flag**, for the
-     * reason `PageKind` is one: those two fields could disagree, and `external:
+     * **A union rather than an optional `url` and an `external` flag**: those
+     * two fields could disagree, and `external:
      * true` with no absolute URL is a state that means nothing and would still
      * type-check. Here the discriminant *is* the answer — a consumer that needs
      * an absolute URL narrows on `to` and gets one, or is told plainly that this
@@ -297,16 +297,15 @@ export function createRichText<
 ): RichTextFor<Catalog, RouteId, Links, Values> {
     const { catalog, locale, link, origin, links, values } = options;
 
-    return <K extends StringKeys<Catalog>>(
-        ...args: RichArgsOf<Catalog, K, RouteId, Links, Values>
+    // Untyped inside: the return type is what callers see, keys and params
+    // checked. Placeholder values and link targets are both strings once here —
+    // the distinction they are worth making is entirely a compile-time one.
+    return (
+        key: string,
+        params?: Readonly<Record<string, string>>
     ): RichText => {
-        // The conditional tuple cannot be destructured directly; the runtime
-        // shape is always `[key]` or `[key, params]`. As in `createTranslate`.
-        // Placeholder values and link targets are both strings once here — the
-        // distinction they are worth making is entirely a compile-time one.
-        const [key, params] = args as [K, Readonly<Record<string, string>>?];
-        const at = `Message "${String(key)}" (${locale})`;
-        const template = lookupTemplate(catalog, locale, String(key));
+        const at = `Message "${key}" (${locale})`;
+        const template = lookupTemplate(catalog, locale, key);
 
         return parseMarks(template, at).map((span) =>
             resolve(span, at, params, { links, values }, link, origin)
@@ -379,7 +378,7 @@ function fill(
  * The destination a slot was filled with.
  *
  * `Object.hasOwn` rather than reading the index straight, for the reason
- * `createRawTranslate` uses it: `__proto__` is a legal slot name by `SLOT`, so
+ * `createTranslate` uses it: `__proto__` is a legal slot name by `SLOT`, so
  * a plain object would answer with `Object.prototype` — not `undefined`, and so
  * not caught below.
  *
@@ -620,12 +619,10 @@ export function createPlainText<
 ): PlainTextFor<Catalog, Values> {
     const { catalog, locale, values } = options;
 
-    return <K extends StringKeys<Catalog>>(
-        ...args: TranslateArgsOf<Catalog, K, Values>
-    ): string => {
-        const [key, params] = args as [K, Readonly<Record<string, string>>?];
-        const at = `Message "${String(key)}" (${locale})`;
-        const template = lookupTemplate(catalog, locale, String(key));
+    // Untyped inside, as `rich()`: the return type is what callers see.
+    return (key: string, params?: Readonly<Record<string, string>>): string => {
+        const at = `Message "${key}" (${locale})`;
+        const template = lookupTemplate(catalog, locale, key);
 
         return collapse(
             parseMarks(template, at).map((span) =>

package/src/i18n/catalog.ts

@@ -29,6 +29,8 @@ export interface ProjectCatalog<Base, Published extends string, Override, Add> {
     readonly override: Override;
     /** Messages only this project has. */
     readonly add: Add;
+    /** The project's names for its languages, where the site's do not fit. */
+    readonly labels: Readonly<Partial<Record<Published, string>>>;
 }
 
 /**
@@ -99,7 +101,8 @@ export type OverrideChecks<Base, Published extends string, O> = NoExcessKeys<
  *  - `override` keys exist in the base catalog, keep its `{placeholders}` and
  *    `[marks]`, and are written only for published locales;
  *  - `add` keys are new to the base catalog, written for exactly the published
- *    locales, with the same `{placeholders}` and `[marks]` in each.
+ *    locales, with the same `{placeholders}` and `[marks]` in each;
+ *  - `labels` are for published locales.
  */
 export function defineCatalog<
     const C extends SiteConfigShape,
@@ -119,6 +122,13 @@ export function defineCatalog<
         readonly override: Override &
             ValidateOverrideCatalog<Override, Base, LocalesOf<C>>;
         readonly add?: Add & ValidateAdditions<Add, Base, Published>;
+        /**
+         * A language's name in the language switcher, replacing the site's
+         * label for that locale on this project only. `NoInfer`, so a label
+         * cannot widen the published locales: a locale written here that
+         * `locales` lacks is an error on its own line.
+         */
+        readonly labels?: Readonly<Partial<Record<NoInfer<Published>, string>>>;
     }
 ): ProjectCatalog<Base, Published, Override, Add> {
     // Checked at runtime as well as in the type: an Astro config is evaluated
@@ -144,10 +154,19 @@ export function defineCatalog<
             );
         }
     }
+    const labels = own.labels ?? {};
+    for (const locale of Object.keys(labels)) {
+        if (!own.locales.some((published) => published === locale)) {
+            throw new Error(
+                `labels: "${locale}" is not among this catalog's locales, so its label would never be shown.`
+            );
+        }
+    }
     return {
         base,
         locales: own.locales,
         override: own.override,
         add: add as Add,
+        labels,
     };
 }

package/src/i18n/define.ts

@@ -54,11 +54,6 @@ export type OverrideCatalog<L extends string> = Readonly<
     Record<string, OverrideEntry<L>>
 >;
 
-/** The locale union a catalog covers, read back off its own entries. */
-export type LocalesOfCatalog<Catalog> = StringKeys<
-    Catalog[StringKeys<Catalog>]
->;
-
 type SelfConsistent<E, K> = [MismatchedLocales<E, EntryTokens<E>>] extends [
     never,
 ]

package/src/i18n/translate.ts

@@ -78,13 +78,7 @@ export type MergedCatalog<L extends string> = Readonly<
     Record<string, Readonly<Record<L, string>>>
 >;
 
-/** Untyped translation lookup, wrapped below in a key-aware signature. */
-export type RawTranslate = (
-    key: string,
-    params?: Readonly<Record<string, string>>
-) => string;
-
-export interface RawTranslateOptions<L extends string> {
+export interface TranslateOptions<L extends string> {
     readonly catalog: MergedCatalog<L>;
     readonly locale: L;
     /**
@@ -120,7 +114,11 @@ export function lookupTemplate<L extends string>(
 }
 
 /**
- * Builds the runtime half of `t()`.
+ * Builds `t()`.
+ *
+ * Untyped: `site.translate` declares the key-aware `TranslateFor` as what it
+ * returns, and this function fits that type with no cast. The key and params
+ * checks live in the type; what fails at runtime fails here.
  *
  * Every failure here is a build-time failure by design: a static site should not
  * ship a page with a literal `{name}` in the markup, so a missing message or an
@@ -132,9 +130,9 @@ export function lookupTemplate<L extends string>(
  * failure wearing different brackets. `rich()` reads those, and `plain()` gives
  * back the sentence without them.
  */
-export function createRawTranslate<L extends string>(
-    options: RawTranslateOptions<L>
-): RawTranslate {
+export function createTranslate<L extends string>(
+    options: TranslateOptions<L>
+): (key: string, params?: Readonly<Record<string, string>>) => string {
     const { catalog, locale, values } = options;
 
     return (key, params) => {
@@ -211,40 +209,3 @@ export type TranslateFor<Catalog, Bound extends string = never> = <
 >(
     ...args: TranslateArgsOf<Catalog, K, Bound>
 ) => string;
-
-/**
- * Builds the typed `t()` factory for one catalog type.
- *
- * Curried for the usual reason — `Catalog` must be supplied explicitly while the
- * locale stays inferred, and TypeScript has no partial type-argument inference.
- * `Catalog` is the *base* catalog's type (it carries the literal strings the
- * placeholders are read from); the value passed in is the merged runtime
- * catalog, which only needs to be indexable by key and locale.
- */
-export function createTranslateFactory<Catalog, L extends string>() {
-    return function createTranslate<Bound extends string = never>(
-        catalog: MergedCatalog<L>,
-        locale: L,
-        values?: Readonly<Record<Bound, string>>
-    ): TranslateFor<Catalog, Bound> {
-        const raw = createRawTranslate({
-            catalog,
-            locale,
-            ...(values === undefined ? {} : { values }),
-        });
-
-        function t<K extends StringKeys<Catalog>>(
-            ...args: TranslateArgsOf<Catalog, K, Bound>
-        ): string {
-            // The conditional tuple cannot be destructured directly; the runtime
-            // shape is always `[key]` or `[key, params]`.
-            const [key, params] = args as [
-                K,
-                Readonly<Record<string, string>>?,
-            ];
-            return raw(key, params);
-        }
-
-        return t;
-    };
-}

package/src/index.ts

@@ -18,19 +18,14 @@ export {
     CONSENT_CATEGORIES,
     CONSENT_MONTHS,
     type ConsentCategory,
-    type ConsentChoice,
-    type ConsentChoices,
 } from "./analytics/consent-storage.ts";
 export {
     type AnalyticsSettings,
-    type AnalyticsTags,
     type AxonPixelSettings,
     type ClaritySettings,
-    CONSENT_UPDATE_GLOBAL,
     type ConsentDefaults,
     type ConsentState,
     consentRequired,
-    consentVendors,
     type DripSettings,
     type GoogleSettings,
     type GoogleTagId,
@@ -45,74 +40,36 @@ export {
     type Uuid,
 } from "./analytics/index.ts";
 export {
-    type AtlasStoredId,
-    compareStoredItems,
-    type Lifetime,
     STORAGE_VENDOR_NAMES,
-    type StorageVendor,
     type StoredId,
     type StoredItem,
     type StoredItemsOptions,
     storedItems,
-    withPurposes,
 } from "./analytics/storage.ts";
-export {
-    checkEscapeNavigator,
-    ESCAPE_NAVIGATOR_LOADER,
-    type EscapeNavigatorVars,
-    type EscapeNavigatorWidget,
-    escapeNavigatorLanguage,
-} from "./booking/escape-navigator.ts";
-export {
-    checkEscapeAll,
-    ESCAPEALL_LANGUAGES,
-    type EscapeAllLanguage,
-    type EscapeAllVars,
-    type EscapeAllWidget,
-    escapeAllAssets,
-    escapeAllLanguage,
-} from "./booking/escapeall.ts";
-export {
-    checkFourEscape,
-    FOUR_ESCAPE_LANGUAGES,
-    FOUR_ESCAPE_SCRIPT,
-    FOUR_ESCAPE_STYLESHEET,
-    type FourEscapeLanguage,
-    type FourEscapeVars,
-    type FourEscapeWidget,
-    fourEscapeLanguage,
-    fourEscapeSettings,
-    fourEscapeStyle,
-} from "./booking/four-escape.ts";
+export type { EscapeNavigatorWidget } from "./booking/escape-navigator.ts";
 export type {
-    BookingVendor,
-    BookingVendorVars,
-    BookingWidget,
-    BookingWidgetVars,
-} from "./booking/widget.ts";
+    EscapeAllLanguage,
+    EscapeAllWidget,
+} from "./booking/escapeall.ts";
 export type {
-    LanguageTag,
-    LocaleMeta,
-    LocalesOf,
-    ResolvedLocaleMeta,
-    RoutingConfig,
-    SiteConfigShape,
-} from "./config.ts";
+    FourEscapeLanguage,
+    FourEscapeVars,
+    FourEscapeWidget,
+} from "./booking/four-escape.ts";
+export type { BookingVendor, BookingWidget } from "./booking/widget.ts";
+export type { LanguageTag, LocaleMeta, LocalesOf } from "./config.ts";
 export {
     type AddressFormatOptions,
     type AddressLineOptions,
     addressLine,
     addressLines,
-    assertCoordinates,
     type CallingCode,
     type Coordinates,
     type CountryCode,
     type E164,
     type EmailAddress,
     e164,
-    e164Of,
     formatPhone,
-    isEmailAddress,
     type MailtoUrl,
     mailtoHref,
     type PhoneNumber,
@@ -132,44 +89,26 @@ export {
 // them has a second `rich()` that is not bound to the site's route table — so
 // a slot filled with a route id resolves against nothing there. `site.rich(locale)` is
 // the only way in, and `Span` is what a renderer switches on.
-export {
-    html,
-    type LinkTarget,
-    type MessageBindings,
-    type PlainTextFor,
-    plain,
-    type RichText,
-    type RichTextFor,
-    type Span,
-} from "./content/index.ts";
-export {
-    COUNTRY_CODES,
-    countriesFor,
-    type NamedCountry,
-} from "./countries.ts";
+export { html, plain, type RichText, type Span } from "./content/index.ts";
+export { countriesFor, type NamedCountry } from "./countries.ts";
 // `quantitiesOf`, `quantityRange` and `isContiguous` are deliberately not here.
 // They are how lib decides between "2–6" and "2, 4, 6", and a consumer holding
 // them writes that decision a second time — which is how `llms.txt` came to
 // advertise a range for a room that skips sizes. `formatQuantities` answers it
 // for prose and `quantitiesFor` for structured data; both read the same tiers.
 export type { CurrencyCode } from "./currency.ts";
-export type { GeneratedFile } from "./file.ts";
 export type { PublicFilePath, PublicFileRegistry } from "./files.ts";
 export type { Font, Fonts } from "./fonts.ts";
 export {
-    assertHours,
     type DayHours,
     type FormattedHours,
     formatHours,
-    formatTime,
-    groupHours,
     type HourCycle,
     type HoursFormat,
     type HoursGroup,
     type HoursSentenceFormat,
     hoursSentence,
     type OpenStatus,
-    openStatus,
     type TimeFormat,
     type TimeOfDay,
     type TimeRange,
@@ -177,42 +116,18 @@ export {
     type Weekday,
     type WeeklyHours,
 } from "./hours.ts";
-export type {
-    CatalogKey,
-    MessagesOf,
-    ProjectCatalog,
-    PublishedOf,
-} from "./i18n/catalog.ts";
-export type {
-    BaseCatalog,
-    CatalogCovers,
-    MessageOverrides,
-    OverrideCatalog,
-} from "./i18n/define.ts";
-export type {
-    EntryPlaceholders,
-    Placeholders,
-} from "./i18n/placeholders.ts";
-export type {
-    MessageParamsOf,
-    TranslateArgsOf,
-    TranslateFor,
-} from "./i18n/translate.ts";
+export type { CatalogKey } from "./i18n/catalog.ts";
+export type { CatalogCovers, MessageOverrides } from "./i18n/define.ts";
+export type { MessageParamsOf } from "./i18n/translate.ts";
 export type { ImageAsset } from "./image.ts";
 export {
-    type ArticleInput,
-    article,
-    type BreadcrumbStep,
     type BusinessId,
-    breadcrumbList,
     businessId,
-    type CatalogEntry,
     type CreativeWorkInput,
     type CreativeWorkProperty,
     creativeWork,
     type FaqEntry,
     faqPage,
-    geoCoordinates,
     type JsonLdNode,
     type LocalBusinessInput,
     localBusiness,
@@ -220,45 +135,30 @@ export {
     type OrganizationId,
     type OrganizationInput,
     offerCatalog,
-    openingHours,
     organization,
     organizationId,
     type ProductInput,
-    postalAddress,
     product,
     quantitativeValue,
     quantitiesFor,
     type ServiceArea,
     type ServiceId,
     type ServiceInput,
-    serializeJsonLd,
     service,
-    serviceId,
     type VideoInput,
     type VideoSource,
     videoObject,
     type WebsiteId,
     type WebsiteInput,
     website,
-    websiteId,
 } from "./jsonld/index.ts";
-export {
-    buildLlms,
-    type LlmsConfig,
-    type LlmsItem,
-    type LlmsSection,
-} from "./llms.ts";
+export type { LlmsSection } from "./llms.ts";
 export { googleMapsUrl, type MapPlace, type MapsTarget } from "./map.ts";
 export {
     type ArticleContent,
-    buildMeta,
-    buildNotFoundMeta,
     fitDescription,
     fitTitle,
     type MetaContent,
-    type MetaTag,
-    type OpenGraphType,
-    type PageKind,
     type RobotsPolicy,
     type ShareImage,
     type SiteVerification,
@@ -267,8 +167,6 @@ export {
     type AudiencePrice,
     type AudienceTier,
     amountAt,
-    assertAudiences,
-    assertPriceTiers,
     formatQuantities,
     type Price,
     type PriceTier,
@@ -284,70 +182,30 @@ export {
     type PriceFormat,
 } from "./price-format.ts";
 export type {
-    DefinedProject,
-    ProjectInput,
-    ProjectRouteId,
-} from "./project.ts";
-export {
-    buildCloudflareRedirects,
-    buildRedirects,
-    type CloudflareRedirectsOptions,
-    type ExternalUrl,
-    type ProjectRedirects,
-    type RedirectKind,
-    type RedirectRule,
-    type RedirectStatus,
-    type RedirectTarget,
-    type ResolvedRedirect,
-    type SitePath,
-    type ValidateRedirectTargets,
+    ProjectRedirects,
+    RedirectKind,
+    RedirectRule,
+    RedirectTarget,
+    SitePath,
 } from "./redirects.ts";
-export type { RobotsConfig, RobotsGroup } from "./robots.ts";
-export type {
-    ChangeFreq,
-    EnabledRouteIdFor,
-    RouteData,
-    RouteOverride,
-    RouteOverrides,
-    RouteRegistry,
-    RouteSitemap,
-} from "./routes/define.ts";
-export {
-    enableRoutes,
-    type FamilyMember,
-    type FamilyMemberInput,
-    type FamilyMemberSlugs,
-    type FamilyOptions,
-    familyGuard,
-    familyMemberSlugs,
-    type RouteIdsOf,
-} from "./routes/family.ts";
-export type { RouteEntry } from "./routes/resolve.ts";
+export type { RouteFamily, RouteIdsOf } from "./routes/family.ts";
 export { defineSite } from "./site/define.ts";
 export type {
-    Alternate,
     Crumb,
     LinkOptions,
     LlmsOptions,
-    LocaleLink,
     PageContent,
     PageMeta,
     PageProps,
     PerRoute,
-    Site,
-    StaticPath,
 } from "./site/index.ts";
-export type { Sitemap, SitemapConfig } from "./sitemap.ts";
-export { TIME_ZONES, type TimeZone } from "./time-zones.ts";
-export type { IsoDate, Letter, NonEmpty, StringKeys } from "./types.ts";
+export type { TimeZone } from "./time-zones.ts";
+export type { IsoDate, NonEmpty, StringKeys } from "./types.ts";
 export {
     absoluteUrl,
-    type Hash,
     type HttpsUrl,
-    isHash,
     isHttpsUrl,
     isUrlPath,
     joinUrl,
-    normalizeOrigin,
     type UrlPath,
 } from "./url.ts";