@escape-game-over/atlas 0.1.86 → 0.1.88

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@escape-game-over/atlas",
-    "version": "0.1.86",
+    "version": "0.1.88",
     "type": "module",
     "description": "Typed, data-driven machinery for static multi-locale, multi-deployment Astro sites.",
     "private": false,
@@ -38,9 +38,10 @@
         "node": ">=24.0.0"
     },
     "scripts": {
-        "test": "npm run test:types && npm run test:unit && npm run test:examples",
+        "test": "npm run test:types && npm run test:unit && npm run test:astro && npm run test:examples",
         "test:types": "tsc --noEmit && astro check --root checks/astro",
         "test:unit": "vitest run --coverage",
+        "test:astro": "vitest run --config vitest.astro.config.ts",
         "test:watch": "vitest",
         "test:examples": "npm run test --workspaces",
         "lint": "biome check .",
@@ -61,7 +62,7 @@
         "@biomejs/biome": "2.6.5",
         "@types/node": "26.6.6",
         "@vitest/coverage-istanbul": "5.1.0",
-        "astro": "7.4.5",
+        "astro": "7.4.7",
         "typescript": "6.0.3",
         "vitest": "5.1.0"
     }

package/src/astro/Document.astro

@@ -27,11 +27,13 @@
  * </Document>
  * ```
  */
+
 import { Font } from "astro:assets";
 import type { HTMLAttributes } from "astro/types";
 import type { Fonts } from "../fonts.ts";
 import { iconLinks } from "../meta/index.ts";
 import type { PageMeta } from "../site/index.ts";
+import { recordConsentBanner } from "./consent-pages.ts";
 import MetaTags from "./MetaTags.astro";
 import RememberCampaign from "./RememberCampaign.astro";
 import RememberLocale from "./RememberLocale.astro";
@@ -62,6 +64,13 @@ const {
     rememberLocale = true,
 } = Astro.props;
 
+// Before the slots render, so a component in the page can tell: `GoogleMap`
+// refuses to load on sight where nobody can be asked.
+recordConsentBanner(
+    Astro.request,
+    meta.consentVendors.length > 0 && Astro.slots.has("consent")
+);
+
 if (meta.consentVendors.length > 0 && !Astro.slots.has("consent")) {
     throw new Error(
         `${meta.consentVendors.join(", ")} ${meta.consentVendors.length === 1 ? "needs" : "need"} permission, but this page has no consent banner. Pass one to Document: <ConsentBanner slot="consent" …>.`

package/src/astro/GoogleMap.astro

@@ -2,7 +2,19 @@
 /**
  * A Google map of `places`, loaded only when asked for. Until then the element
  * shows its children: a picture and a button, say. With `load="click"` (the
- * default) a click anywhere on them loads it; with `"visible"`, scrolling near.
+ * default) a click anywhere on them loads it, and that click is the reader
+ * asking for Google, so say so on the button. With `"visible"`, scrolling near
+ * loads it, but only once the reader has granted marketing consent: Google
+ * sets its cookies either way, and nobody asked for the map. A page using
+ * `"visible"` without a consent banner fails the build.
+ *
+ * The check trusts that a filled `consent` slot shows a banner. Astro counts the
+ * slot as filled whenever an element names it, so one that renders nothing —
+ * `{shown && <div slot="consent">}`, an empty element, a component of your own
+ * that renders nothing — passes it with no banner on the page. Put the banner
+ * in the slot unconditionally: `ConsentBanner` already renders nothing on a
+ * site that needs no permission. Until a reader grants marketing, the map's
+ * children stay, so they should read sensibly on their own.
  *
  * `mapId` is required: markers are `AdvancedMarkerElement`, which needs one,
  * and its colours are set on the Map ID in the Cloud console. `colorScheme`
@@ -26,6 +38,7 @@ import type { HTMLAttributes } from "astro/types";
 import { type MapPlace, mapFrame } from "../map.ts";
 import type { NonEmpty } from "../types.ts";
 import AtlasElement from "./AtlasElement.astro";
+import { showsConsentBanner } from "./consent-pages.ts";
 import { type GoogleMapConfig, googleMap } from "./google-map.ts";
 
 type Props = HTMLAttributes<"div"> & {
@@ -45,6 +58,12 @@ const {
     ...attrs
 } = Astro.props;
 
+if (load === "visible" && showsConsentBanner(Astro.request) !== true) {
+    throw new Error(
+        `${Astro.url.pathname}: GoogleMap with load="visible" waits for marketing consent, but this page shows no consent banner to ask for it. Use load="click", where the reader's click is the asking, or give the page a banner: <ConsentBanner slot="consent" …> in Document, with a vendor that needs it.`
+    );
+}
+
 const config: GoogleMapConfig = {
     apiKey,
     mapId,

package/src/astro/consent-pages.ts

@@ -0,0 +1,24 @@
+/**
+ * Which pages of a build show a consent banner, for a component that must not
+ * render without one.
+ *
+ * `Document` records it from the page's `meta` before it renders its slots, so
+ * anything in the page's body can ask. Keyed by the page's request: each page
+ * of a static build renders with its own, and a `WeakMap` lets them go.
+ *
+ * Server-only, like `Document`.
+ */
+const pages = new WeakMap<Request, boolean>();
+
+/** What `Document` records: whether this page shows a consent banner. */
+export function recordConsentBanner(request: Request, shown: boolean): void {
+    pages.set(request, shown);
+}
+
+/**
+ * Whether this page shows a consent banner. `undefined` when no `Document` has
+ * rendered for it, which a caller should treat as no.
+ */
+export function showsConsentBanner(request: Request): boolean | undefined {
+    return pages.get(request);
+}

package/src/astro/google-map.ts

@@ -1,6 +1,7 @@
 /// <reference types="google.maps" />
 import type { MapFrame } from "../map.ts";
 import { appendScript } from "./append-script.ts";
+import { whenGranted } from "./consent-gate.ts";
 import { reportDevError } from "./dev-log.ts";
 import { element } from "./element.ts";
 import { triggered } from "./load-script.ts";
@@ -122,10 +123,24 @@ export const googleMap = element("atlas-google-map", ({ root, signal }) => {
         draw(root, config).catch((error) => reportDevError("GoogleMap", error));
     };
 
-    triggered(
-        config.load === "click"
-            ? { on: "click", element: root }
-            : { on: "visible", element: root },
+    if (config.load === "click") {
+        triggered({ on: "click", element: root }, signal).then(show);
+        return;
+    }
+
+    // On sight, but never before marketing is granted: the build makes sure
+    // there is a banner to grant it. Once drawn, a withdrawn grant leaves the
+    // map be — Google has already set what it sets.
+    let asked = false;
+    whenGranted(
+        "marketing",
+        {
+            grant: () => {
+                if (asked) return;
+                asked = true;
+                triggered({ on: "visible", element: root }, signal).then(show);
+            },
+        },
         signal
-    ).then(show);
+    );
 });

package/src/index.ts

@@ -215,14 +215,17 @@ export {
 export {
     type AudiencePrice,
     type AudienceTier,
+    amountAt,
     assertAudiences,
     assertPriceTiers,
     type CurrencyCode,
+    formatPrice,
     formatQuantities,
     type Price,
     type PriceTier,
     type Quantity,
     type QuantityRange,
+    quantitiesOf,
     type TieredPrice,
     tierRange,
 } from "./money.ts";

package/src/money.ts

@@ -480,3 +480,43 @@ export function assertPriceTiers(price: TieredPrice, at: string): void {
         );
     }
 }
+
+/**
+ * What one unit costs at `quantity`: the amount of the band that covers it, or
+ * `undefined` where the table has no band for it — a group too small, too
+ * large, or in a hole between bands.
+ *
+ * The first band that covers it wins. `assertPriceTiers` refuses overlapping
+ * bands, so in a table that passed it there is only ever one.
+ */
+export function amountAt(
+    price: TieredPrice,
+    quantity: number
+): number | undefined {
+    for (const tier of price.tiers) {
+        const band = tierRange(tier);
+        if (quantity >= band.min && quantity <= band.max) {
+            return tier.amountPerUnit;
+        }
+    }
+    return undefined;
+}
+
+/**
+ * A price as a reader in `locale` writes it: the currency's symbol and that
+ * language's separators, and no decimals on a whole amount — "£25", not
+ * "£25.00", while "€12.50" keeps its cents.
+ *
+ * Whole amounts drop the decimals because that is how a price list reads; a
+ * table of "25.00, 22.00, 20.00" says nothing "25, 22, 20" does not. An amount
+ * with cents shows two, so a price is never rounded on the way to the page.
+ */
+export function formatPrice(price: Price, locale: string): string {
+    const whole = Number.isInteger(price.amount);
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: price.currency,
+        minimumFractionDigits: whole ? 0 : 2,
+        maximumFractionDigits: whole ? 0 : 2,
+    }).format(price.amount);
+}