@escape-game-over/atlas 0.1.115 → 0.1.116

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,35 @@ 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 { 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";

package/src/jsonld/article.ts

@@ -2,7 +2,7 @@ import type { IsoDate } from "../types.ts";
 import type { HttpsUrl } from "../url.ts";
 import { warn } from "../warn.ts";
 import type { BusinessId, OrganizationId } from "./ids.ts";
-import { type JsonLdNode, oneOrMany } from "./node.ts";
+import { type JsonLdNode, listed, oneOrMany, reference } from "./node.ts";
 
 export interface ArticleInput {
     /**
@@ -137,29 +137,19 @@ export function article(item: ArticleInput): JsonLdNode {
     return {
         "@type": item.kind ?? "Article",
         headline: item.headline,
-        ...(item.description === undefined
-            ? {}
-            : { description: item.description }),
+        description: item.description,
         // Not `url`: an article is a thing, and this is the page it is *on*.
         mainEntityOfPage: item.url,
         datePublished: item.datePublished,
-        ...(item.dateModified === undefined
-            ? {}
-            : { dateModified: item.dateModified }),
+        dateModified: item.dateModified,
         // Passed through in the shape it arrived in, bar a list of one — which
         // is `schemaType`'s rule applied to a second field: writing `[x]` is
         // fine, emitting it reads as a bug.
-        ...(item.image === undefined ? {} : { image: oneOrMany(item.image) }),
-        ...(item.author === undefined
-            ? {}
-            : { author: { "@id": item.author } }),
-        ...(item.publisher === undefined
-            ? {}
-            : { publisher: { "@id": item.publisher } }),
+        image: item.image === undefined ? undefined : oneOrMany(item.image),
+        author: reference(item.author),
+        publisher: reference(item.publisher),
         // An empty list is not a set of no keywords, it is a field saying
         // nothing — so it is left out, as every optional here is.
-        ...(item.tags === undefined || item.tags.length === 0
-            ? {}
-            : { keywords: item.tags }),
+        keywords: listed(item.tags),
     };
 }

package/src/jsonld/business.ts

@@ -10,7 +10,13 @@ import type { ImageAsset } from "../image.ts";
 import type { NonEmpty } from "../types.ts";
 import { absoluteUrl, type HttpsUrl } from "../url.ts";
 import { businessId, type OrganizationId } from "./ids.ts";
-import { alternateName, type JsonLdNode, schemaType } from "./node.ts";
+import {
+    alternateName,
+    type JsonLdNode,
+    listed,
+    reference,
+    schemaType,
+} from "./node.ts";
 import { geoCoordinates, openingHours, postalAddress } from "./place.ts";
 
 export interface LocalBusinessInput {
@@ -173,34 +179,27 @@ export function localBusiness(business: LocalBusinessInput): JsonLdNode {
         "@type": schemaType(business.type ?? "LocalBusiness"),
         "@id": businessId(business.url, business.location),
         name: business.name,
-        ...alternateName(business.name, business.alternateName),
+        alternateName: alternateName(business.name, business.alternateName),
         url: business.url,
         address: postalAddress(business.address),
-        ...(business.geo === undefined
-            ? {}
-            : { geo: geoCoordinates(business.geo) }),
-        ...(business.priceRange === undefined
-            ? {}
-            : { priceRange: business.priceRange }),
-        ...(business.image === undefined || business.image.length === 0
-            ? {}
-            : {
-                  image: business.image.map((photo) =>
-                      absoluteUrl(business.url, photo.src, "venue photo")
-                  ),
-              }),
-        ...(business.telephone === undefined
-            ? {}
-            : { telephone: e164(business.telephone) }),
-        ...(business.email === undefined ? {} : { email: business.email }),
-        ...(business.hours === undefined
-            ? {}
-            : { openingHoursSpecification: openingHours(business.hours) }),
-        ...(business.sameAs === undefined ? {} : { sameAs: business.sameAs }),
-        ...(business.parentOrganization === undefined
-            ? {}
-            : {
-                  parentOrganization: { "@id": business.parentOrganization },
-              }),
+        geo:
+            business.geo === undefined
+                ? undefined
+                : geoCoordinates(business.geo),
+        priceRange: business.priceRange,
+        image: listed(business.image)?.map((photo) =>
+            absoluteUrl(business.url, photo.src, "venue photo")
+        ),
+        telephone:
+            business.telephone === undefined
+                ? undefined
+                : e164(business.telephone),
+        email: business.email,
+        openingHoursSpecification:
+            business.hours === undefined
+                ? undefined
+                : openingHours(business.hours),
+        sameAs: business.sameAs,
+        parentOrganization: reference(business.parentOrganization),
     };
 }

package/src/jsonld/creative-work.ts

@@ -1,7 +1,7 @@
 import type { Quantity } from "../money.ts";
 import type { HttpsUrl } from "../url.ts";
 import type { BusinessId, OrganizationId } from "./ids.ts";
-import { type JsonLdNode, schemaType } from "./node.ts";
+import { type JsonLdNode, listed, reference, schemaType } from "./node.ts";
 import { quantitativeValue } from "./quantity.ts";
 
 /**
@@ -92,19 +92,11 @@ export function creativeWork(work: CreativeWorkInput): JsonLdNode {
         "@type": schemaType(["CreativeWork", ...(work.alsoA ?? [])]),
         name: work.name,
         url: work.url,
-        ...(work.description === undefined
-            ? {}
-            : { description: work.description }),
-        ...(work.image === undefined ? {} : { image: work.image }),
-        ...(work.genre === undefined || work.genre.length === 0
-            ? {}
-            : { genre: work.genre }),
-        ...(work.creator === undefined
-            ? {}
-            : { creator: { "@id": work.creator } }),
-        ...(work.properties === undefined || work.properties.length === 0
-            ? {}
-            : { additionalProperty: work.properties.map(propertyValue) }),
+        description: work.description,
+        image: work.image,
+        genre: listed(work.genre),
+        creator: reference(work.creator),
+        additionalProperty: listed(work.properties)?.map(propertyValue),
     };
 }
 
@@ -114,12 +106,8 @@ function propertyValue(property: CreativeWorkProperty): JsonLdNode {
         name: property.name,
         value: {
             ...quantitativeValue(property.value),
-            ...(property.unitCode === undefined
-                ? {}
-                : { unitCode: property.unitCode }),
-            ...(property.unitText === undefined
-                ? {}
-                : { unitText: property.unitText }),
+            unitCode: property.unitCode,
+            unitText: property.unitText,
         },
     };
 }

package/src/jsonld/node.ts

@@ -7,7 +7,13 @@
 
 import { literal } from "../analytics/tags.ts";
 
-/** A node in the graph. Deliberately loose: `@type` is what a consumer varies. */
+/**
+ * A node in the graph. Deliberately loose: `@type` is what a consumer varies.
+ *
+ * An optional field it lacks is written as `undefined`, never branched around
+ * with a conditional spread: `serializeJsonLd` goes through JSON, which drops
+ * it, so the published node has no such key either way.
+ */
 export interface JsonLdNode {
     readonly "@type": string | readonly string[];
     readonly [key: string]: unknown;
@@ -47,8 +53,8 @@ export function schemaType(
  * engine reads it as *another* name and a repeat of the first one is not that:
  * it widens nothing and is one more string to reconcile. Decided here rather
  * than by the caller — three nodes take the field, the rule is the same on all
- * of them, and a project asked to write `name === alt ? {} : { alt }` at each
- * one is being handed lib's rule to enforce by hand.
+ * of them, and a project asked to write `alt === name ? undefined : alt` at
+ * each one is being handed lib's rule to enforce by hand.
  *
  * Which makes `alternateName: brand.name` safe to pass unconditionally: a venue
  * whose name already *is* the brand's simply emits nothing.
@@ -56,10 +62,34 @@ export function schemaType(
 export function alternateName(
     name: string,
     alternate: string | undefined
-): { readonly alternateName?: string } {
-    return alternate === undefined || alternate === name
-        ? {}
-        : { alternateName: alternate };
+): string | undefined {
+    return alternate === name ? undefined : alternate;
+}
+
+/**
+ * A pointer to a node published elsewhere in the graph, or nothing.
+ *
+ * Every field built from it is optional, and an `undefined` field is dropped
+ * when the graph is serialised: so a node can write `author:
+ * reference(item.author)` without a branch.
+ */
+export function reference<Id extends string>(
+    id: Id | undefined
+): { readonly "@id": Id } | undefined {
+    return id === undefined ? undefined : { "@id": id };
+}
+
+/**
+ * A list, or nothing when it is empty.
+ *
+ * An empty list is not a set of nothing, it is a field saying nothing — a
+ * claim to have been asked and had no answer — so it is left out like any
+ * other absent field.
+ */
+export function listed<T>(
+    list: readonly T[] | undefined
+): readonly T[] | undefined {
+    return list === undefined || list.length === 0 ? undefined : list;
 }
 
 /** The graph, serialised for a `<script type="application/ld+json">`. */