@escape-game-over/atlas 0.1.116 → 0.1.118

package/src/astro/snap-pixel.ts

@@ -1,22 +1,19 @@
 import { appendScript } from "./append-script.ts";
 import type { ConsentGated } from "./consent-gate.ts";
+import { vendors } from "./vendors.ts";
 
 /** Snap's `snaptr`: a queue until `scevent.min.js` arrives and replays it. */
-interface Snaptr {
+export interface Snaptr {
     (...args: unknown[]): void;
     handleRequest?: (...args: unknown[]) => void;
     queue: unknown[];
 }
 
-interface PixelWindow {
-    snaptr?: Snaptr;
-}
-
 const SCRIPT = "https://sc-static.net/scevent.min.js";
 
 /** Snap's own base code, as it defines `snaptr` before the script loads. */
 function defineSnaptr(): Snaptr {
-    const global = window as unknown as PixelWindow;
+    const global = vendors();
     if (global.snaptr !== undefined) return global.snaptr;
     // `arguments` is the list of whatever a call passed, which every regular
     // `function` gets without declaring it (an arrow function does not). The

package/src/astro/tiktok-event.ts

@@ -1,5 +1,6 @@
 import type { CurrencyCode } from "../currency.ts";
 import type { DeclaredEvent, EventDataArgs } from "./event-data.ts";
+import { vendors } from "./vendors.ts";
 
 /** TikTok's standard events, by their current names (May 2025 onwards). */
 export type TikTokStandardEvent =
@@ -63,9 +64,6 @@ type TikTokEventArgs<E extends TikTokEventName> = E extends TikTokStandardEvent
     : EventDataArgs<TikTokCustomEvents[E & keyof TikTokCustomEvents]>;
 
 /** What `tiktok-pixel.ts` defines once marketing is granted. */
-interface TikTokWindow {
-    ttq?: { track(event: string, data?: object): void };
-}
 
 /**
  * Records an event with TikTok's pixel — a lead sent, a booking made. Declared
@@ -80,7 +78,7 @@ export function tiktokEvent<E extends TikTokEventName>(
     event: E,
     ...[data]: TikTokEventArgs<E>
 ): void {
-    const ttq = (window as unknown as TikTokWindow).ttq;
+    const ttq = vendors().ttq;
     if (data === undefined) ttq?.track(event);
     else ttq?.track(event, data);
 }

package/src/astro/tiktok-pixel.ts

@@ -1,8 +1,15 @@
 import { appendScript } from "./append-script.ts";
 import type { ConsentGated } from "./consent-gate.ts";
+import { vendors } from "./vendors.ts";
+
+/** What a page calls on `ttq`: each queues, until `events.js` takes over. */
+type TtqMethods = Record<
+    (typeof METHODS)[number],
+    (...args: unknown[]) => void
+>;
 
 /** TikTok's `ttq`: a queue of calls until `events.js` arrives and replays it. */
-interface Ttq extends Array<unknown> {
+export interface Ttq extends Array<unknown>, TtqMethods {
     methods: readonly string[];
     setAndDefer(target: unknown[], method: string): void;
     instance(id: string): unknown[];
@@ -10,12 +17,6 @@ interface Ttq extends Array<unknown> {
     _i: Record<string, unknown[] & { _u?: string }>;
     _t: Record<string, number>;
     _o: Record<string, object>;
-    [method: string]: unknown;
-}
-
-interface PixelWindow {
-    ttq?: Ttq;
-    TiktokAnalyticsObject?: string;
 }
 
 const SCRIPT = "https://analytics.tiktok.com/i18n/pixel/events.js";
@@ -39,42 +40,73 @@ const METHODS = [
     "grantConsent",
 ] as const;
 
+/**
+ * Each method, queuing its call on `target`. Written out rather than looped
+ * over `METHODS`, so the type sees every one: the return type rejects a name
+ * missing here, or one `METHODS` lacks.
+ */
+function deferTo(target: unknown[]): TtqMethods {
+    const defer =
+        (method: string) =>
+        (...args: unknown[]) => {
+            target.push([method, ...args]);
+        };
+    return {
+        page: defer("page"),
+        track: defer("track"),
+        identify: defer("identify"),
+        instances: defer("instances"),
+        debug: defer("debug"),
+        on: defer("on"),
+        off: defer("off"),
+        once: defer("once"),
+        ready: defer("ready"),
+        alias: defer("alias"),
+        group: defer("group"),
+        enableCookie: defer("enableCookie"),
+        disableCookie: defer("disableCookie"),
+        holdConsent: defer("holdConsent"),
+        revokeConsent: defer("revokeConsent"),
+        grantConsent: defer("grantConsent"),
+    };
+}
+
 /** TikTok's own base code, as it defines `ttq` before the script loads. */
 function defineTtq(): Ttq {
-    const global = window as unknown as PixelWindow;
+    const global = vendors();
     if (global.ttq !== undefined) return global.ttq;
     global.TiktokAnalyticsObject = "ttq";
-    const ttq = [] as unknown as Ttq;
-    ttq.methods = METHODS;
-    ttq.setAndDefer = (target, method) => {
-        (target as unknown as Record<string, unknown>)[method] = (
-            ...args: unknown[]
-        ) => target.push([method, ...args]);
-    };
-    for (const method of METHODS) ttq.setAndDefer(ttq, method);
-    ttq.instance = (id) => {
-        const queue = ttq._i?.[id] ?? [];
-        for (const method of METHODS) ttq.setAndDefer(queue, method);
-        return queue;
-    };
-    ttq.load = (id, options = {}) => {
-        ttq._i ??= {};
-        ttq._i[id] = Object.assign([], { _u: SCRIPT });
-        ttq._t ??= {};
-        ttq._t[id] = Date.now();
-        ttq._o ??= {};
-        ttq._o[id] = options;
-        appendScript(
-            `${SCRIPT}?${new URLSearchParams({ sdkid: id, lib: "ttq" })}`
-        );
-    };
+    const queue: unknown[] = [];
+    const ttq: Ttq = Object.assign(queue, deferTo(queue), {
+        methods: METHODS,
+        // TikTok's script calls this itself, with any name, so it stays as
+        // loose as the snippet's.
+        setAndDefer: (target: unknown[], method: string) => {
+            Object.assign(target, {
+                [method]: (...args: unknown[]) =>
+                    target.push([method, ...args]),
+            });
+        },
+        instance: (id: string) => {
+            const instance = ttq._i[id] ?? [];
+            return Object.assign(instance, deferTo(instance));
+        },
+        load: (id: string, options: object = {}) => {
+            ttq._i[id] = Object.assign([], { _u: SCRIPT });
+            ttq._t[id] = Date.now();
+            ttq._o[id] = options;
+            appendScript(
+                `${SCRIPT}?${new URLSearchParams({ sdkid: id, lib: "ttq" })}`
+            );
+        },
+        _i: {},
+        _t: {},
+        _o: {},
+    });
     global.ttq = ttq;
     return ttq;
 }
 
-const call = (ttq: Ttq, method: (typeof METHODS)[number], ...args: unknown[]) =>
-    (ttq[method] as (...args: unknown[]) => void)(...args);
-
 /** The pixel: loaded on the first grant, paused and resumed by later answers. */
 export function tiktokPixel(pixelIds: readonly string[]): ConsentGated {
     let loaded = false;
@@ -83,15 +115,14 @@ export function tiktokPixel(pixelIds: readonly string[]): ConsentGated {
             const ttq = defineTtq();
             // Also lifts the hold of TikTok's Cookie Consent Mode, where a
             // pixel has it on in Events Manager.
-            call(ttq, "grantConsent");
+            ttq.grantConsent();
             if (loaded) return;
             loaded = true;
             for (const id of pixelIds) ttq.load(id);
-            call(ttq, "page");
+            ttq.page();
         },
         revoke: () => {
-            const ttq = (window as unknown as PixelWindow).ttq;
-            if (ttq !== undefined) call(ttq, "revokeConsent");
+            vendors().ttq?.revokeConsent();
         },
     };
 }

package/src/astro/umami-event.ts

@@ -1,4 +1,5 @@
 import type { DeclaredEvent, EventDataArgs } from "./event-data.ts";
+import { vendors } from "./vendors.ts";
 
 /**
  * The project's Umami events, each with the data it carries, `undefined` for
@@ -34,10 +35,5 @@ export function umamiEvent<E extends DeclaredEvent<UmamiEvents>>(
     // Flat string values; anything else in a declaration fails here.
     ...[data]: EventDataArgs<UmamiEvents[E] & Readonly<Record<string, string>>>
 ): void {
-    const umami = (
-        window as unknown as {
-            umami?: { track(event: string, data?: object): void };
-        }
-    ).umami;
-    umami?.track(name, data);
+    vendors().umami?.track(name, data);
 }

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/index.ts

@@ -188,12 +188,7 @@ export type {
     RedirectTarget,
     SitePath,
 } from "./redirects.ts";
-export {
-    enableRoutes,
-    familyGuard,
-    familyMemberSlugs,
-    type RouteIdsOf,
-} from "./routes/family.ts";
+export type { RouteFamily, RouteIdsOf } from "./routes/family.ts";
 export { defineSite } from "./site/define.ts";
 export type {
     Crumb,

package/src/routes/family.ts

@@ -43,15 +43,16 @@ type MemberId<M> = M extends string
  * The route ids a family produced.
  *
  * ```ts
- * const challengeRoutes = routeFamily(config, "challenges", challenges);
- * export type ChallengeRouteId = RouteIdsOf<typeof challengeRoutes>;
+ * const challenges = atlas.family("challenges", CHALLENGES);
+ * export type ChallengeRouteId = RouteIdsOf<typeof challenges>;
  * ```
  *
  * Reading them back off the family means the prefix is written once, in the
  * call. Spelling the ids out as `` `challenges-${string}` `` would be a second
  * copy of it, free to drift the day the URL changes.
  */
-export type RouteIdsOf<Family> = StringKeys<Family>;
+export type RouteIdsOf<Family extends { readonly routes: unknown }> =
+    StringKeys<Family["routes"]>;
 
 /**
  * A URL prefix as a route-id prefix: `"news/posts"` -> `"news-posts"`.
@@ -349,3 +350,138 @@ export function familyGuard<
     return <T extends string>(id: T): id is T & StringKeys<Family> =>
         Object.hasOwn(family, id);
 }
+
+/** A family's translated prefix, as `slugs` joins it. */
+type PrefixByOf<Options> = Options extends {
+    readonly prefixByLocale: infer P extends ByLocale;
+}
+    ? P
+    : Record<never, never>;
+
+/**
+ * A family, and what a project does with it: spread its `routes` into the
+ * table, and ask the family — not a string — anything about its members.
+ *
+ * Every helper is bound to the prefix the family was made with, so the prefix
+ * is written once: a project cannot enable `"challenge"` members of a
+ * `"challenges"` family, or build a member's path under the wrong prefix.
+ */
+export interface RouteFamily<
+    Prefix extends string,
+    Member extends string,
+    Routes,
+    PrefixBy extends ByLocale,
+> {
+    /** The member routes, to spread into `atlas.routes`. */
+    readonly routes: Routes;
+
+    /**
+     * Whether a route id is one of this family's, as a type guard. See
+     * {@link familyGuard} for why it is generic in the input.
+     */
+    is<T extends string>(id: T): id is T & StringKeys<Routes>;
+
+    /** A member's route id: `routeIdOf("blue-room")` is `"rooms-blue-room"`. */
+    routeIdOf(member: Member): StringKeys<Routes>;
+
+    /** The member a route id of this family is the page of. */
+    memberOf(routeId: StringKeys<Routes>): Member;
+
+    /**
+     * One override for many members, for a project's `overrideRoutes`: by
+     * default, `{ enabled: true }`. Keys stay literal; see {@link enableRoutes}.
+     *
+     * Takes any id, not only the family's members, so a helper generic over a
+     * venue's rooms can pass them through. A member the family lacks is still
+     * an error: on the `overrideRoutes` line, as a route the table lacks.
+     */
+    enable<
+        const Picked extends readonly (string | { readonly id: string })[],
+        const Override extends { readonly enabled?: boolean } = {
+            readonly enabled: true;
+        },
+    >(
+        members: Picked,
+        override?: Override
+    ): {
+        readonly [M in Picked[number] as `${Dashed<Prefix>}-${MemberId<M> &
+            string}`]: Override;
+    };
+
+    /**
+     * A member's paths at a segment of a project's own, in every locale,
+     * under the family's prefix and its translations. See
+     * {@link familyMemberSlugs}.
+     */
+    slugs<
+        const Segment extends string,
+        const SegmentBy extends ByLocale = Record<never, never>,
+    >(
+        segment: Segment,
+        segmentByLocale?: SegmentBy
+    ): FamilyMemberSlugs<Prefix, Segment, PrefixBy, SegmentBy>;
+}
+
+/** Builds a {@link RouteFamily}: what `atlas.family` returns. */
+export function createFamily<
+    const C extends SiteConfigShape,
+    const Prefix extends string,
+    const Members extends readonly FamilyMemberInput<LocalesOf<C>>[],
+    const Options extends FamilyOptions<LocalesOf<C>> = Record<string, never>,
+>(
+    config: C,
+    prefix: Prefix,
+    members: Members,
+    options?: Options
+): RouteFamily<
+    Prefix,
+    MemberId<Members[number]> & string,
+    ReturnType<typeof routeFamily<C, Prefix, Members, Options>>,
+    PrefixByOf<Options>
+> {
+    const routes = routeFamily(config, prefix, members, options);
+    const enable = enableRoutes(prefix);
+    const ids = members.map((member) =>
+        typeof member === "string" ? member : member.id
+    );
+    const routeId = (member: string) =>
+        `${prefix.replaceAll("/", "-")}-${member}`;
+    const byRouteId = new Map(ids.map((member) => [routeId(member), member]));
+
+    return {
+        routes,
+        is: familyGuard(routes),
+        routeIdOf: (member) => {
+            if (!ids.includes(member)) {
+                throw new Error(
+                    `"${member}" is not a member of the "${prefix}" family.`
+                );
+            }
+            return routeId(member) as never;
+        },
+        memberOf: (id) => {
+            const member = byRouteId.get(id);
+            if (member === undefined) {
+                throw new Error(
+                    `"${id}" is not a route of the "${prefix}" family.`
+                );
+            }
+            return member as never;
+        },
+        enable: (picked, override) => enable(picked, override),
+        slugs: (segment, segmentByLocale) => {
+            // The join `familyMemberSlugs` makes, with the family's own prefix
+            // translations rather than a copy of them.
+            const slugByLocale = joinByLocale(
+                prefix,
+                segment,
+                options?.prefixByLocale,
+                segmentByLocale
+            );
+            return {
+                slug: `${prefix}/${segment}`,
+                ...(slugByLocale === undefined ? {} : { slugByLocale }),
+            } as never;
+        },
+    };
+}

package/src/site/define.ts

@@ -40,9 +40,9 @@ import {
     type ValidateSlugDepth,
 } from "../routes/define.ts";
 import {
+    createFamily,
     type FamilyMemberInput,
     type FamilyOptions,
-    routeFamily,
 } from "../routes/family.ts";
 import { createSite } from "./create.ts";
 
@@ -56,7 +56,7 @@ import { createSite } from "./create.ts";
  *
  * // config/routes.ts, messages.ts, projects/<name>/project.ts, site.ts
  * const rooms = atlas.family("rooms", ROOMS, { enabled: true });
- * export const defaultRoutes = atlas.routes({ ...rooms, home: {…} });
+ * export const defaultRoutes = atlas.routes({ ...rooms.routes, home: {…} });
  * export const defaultMessages = atlas.messages({…});
  * export const messages = atlas.catalog(defaultMessages, { locales: […], override: {…} });
  * export const { project, redirects } = atlas.project(messages, defaultRoutes, {…});
@@ -76,17 +76,21 @@ export function defineSite<
     return {
         config,
 
-        /** A route per member, under one prefix: `rooms/red-room` for `rooms`. */
+        /**
+         * A route per member, under one prefix: `rooms/red-room` for `rooms`.
+         * Spread its `routes` into `routes()`; ask it the rest.
+         */
         family<
             const Prefix extends string,
             const Members extends readonly FamilyMemberInput<L>[],
             const Options extends FamilyOptions<L> = Record<string, never>,
-        >(
-            prefix: Prefix,
-            members: Members,
-            options?: Options
-        ): ReturnType<typeof routeFamily<C, Prefix, Members, Options>> {
-            return routeFamily(config, prefix, members, options);
+        >(prefix: Prefix, members: Members, options?: Options) {
+            return createFamily<C, Prefix, Members, Options>(
+                config,
+                prefix,
+                members,
+                options
+            );
         },
 
         /** The route table every project starts from. */

package/src/warn.ts

@@ -43,12 +43,12 @@ const RESET = `${ESC}[0m`;
  * `process` and simply gets colour, which is what a browser console renders
  * anyway.
  */
-const env = () =>
-    (
-        globalThis as {
-            process?: { env?: Readonly<Record<string, string | undefined>> };
-        }
-    ).process?.env;
+const env = () => {
+    const host: typeof globalThis & {
+        process?: { env?: Readonly<Record<string, string | undefined>> };
+    } = globalThis;
+    return host.process?.env;
+};
 
 // Functions, not values worked out at import: a browser bundle that imports
 // anything near this file would otherwise run the reads on every page.

package/src/analytics/axon-pixel.ts

@@ -1,24 +0,0 @@
-import { invalidId, UUID, type Uuid } from "./ids.ts";
-
-/**
- * AppLovin's Axon pixel. Marketing: it loads only once a visitor grants that.
- *
- * @see https://support.applovin.com/en/growth/promoting-your-websites/axon-pixel-integration/axon-pixel-native-js
- * @see https://support.applovin.com/en/growth/promoting-your-websites/axon-pixel-integration/events-and-objects
- */
-export interface AxonPixelSettings {
-    /** From the Axon dashboard: a UUID. */
-    readonly eventKey: Uuid;
-}
-
-/** Fails the build on a key that is not an event key: it would report nowhere. */
-export function checkAxonPixel(
-    axon: AxonPixelSettings | undefined,
-    at: string
-): void {
-    if (axon === undefined || UUID.test(axon.eventKey)) return;
-    invalidId(
-        at,
-        `Axon event key "${axon.eventKey}" is not a UUID, so it would report nowhere. Copy it from the Axon dashboard.`
-    );
-}

package/src/analytics/clarity.ts

@@ -1,29 +0,0 @@
-import { CLARITY_PROJECT_ID, invalidId } from "./ids.ts";
-
-/**
- * Microsoft Clarity. It has a cookieless mode, so like Google it loads for
- * every visitor: without consent it records each page view on its own and sets
- * no cookie, and the visitor's answer switches its cookies on or off.
- *
- * @see https://learn.microsoft.com/en-us/clarity/setup-and-installation/clarity-setup
- * @see https://learn.microsoft.com/en-us/clarity/setup-and-installation/consent-mode
- * @see https://learn.microsoft.com/en-us/clarity/setup-and-installation/clarity-consent-api-v2
- */
-export interface ClaritySettings {
-    /** From the Clarity project's settings: 10 lowercase letters and digits. */
-    readonly projectId: string;
-}
-
-/** Fails the build on an id that is not a project id: it would report nowhere. */
-export function checkClarity(
-    clarity: ClaritySettings | undefined,
-    at: string
-): void {
-    if (clarity === undefined || CLARITY_PROJECT_ID.test(clarity.projectId)) {
-        return;
-    }
-    invalidId(
-        at,
-        `Clarity project id "${clarity.projectId}" is not 10 lowercase letters and digits, so it would report nowhere. Copy it from the Clarity project's settings.`
-    );
-}

package/src/analytics/drip.ts

@@ -1,20 +0,0 @@
-import { DRIP_ACCOUNT_ID, invalidId, type NumericId } from "./ids.ts";
-
-/**
- * Drip's site tracking. Marketing: it loads only once a visitor grants that.
- *
- * @see https://help.drip.com/hc/en-us/articles/4424702539789-Install-Your-JavaScript-Snippet
- */
-export interface DripSettings {
-    /** From Drip's Site Setup: digits, the `_dcs.account` of its snippet. */
-    readonly accountId: NumericId;
-}
-
-/** Fails the build on an id that is not an account id: it would report nowhere. */
-export function checkDrip(drip: DripSettings | undefined, at: string): void {
-    if (drip === undefined || DRIP_ACCOUNT_ID.test(drip.accountId)) return;
-    invalidId(
-        at,
-        `Drip account id "${drip.accountId}" is not all digits, so it would report nowhere. Copy it from Drip's Site Setup.`
-    );
-}

package/src/analytics/meta-pixel.ts

@@ -1,29 +0,0 @@
-import type { NonEmpty } from "../types.ts";
-import { invalidId, META_PIXEL_ID, type NumericId } from "./ids.ts";
-
-/**
- * Meta's pixel. Marketing: it loads only once a visitor grants that.
- *
- * @see https://developers.facebook.com/docs/meta-pixel/get-started
- * @see https://developers.facebook.com/docs/meta-pixel/reference
- * @see https://developers.facebook.com/docs/meta-pixel/implementation/gdpr
- */
-export interface MetaPixelSettings {
-    /** From Events Manager: 15 or 16 digits. Several share one script. */
-    readonly pixelIds: NonEmpty<NumericId>;
-}
-
-/** Fails the build on an id that is not a pixel id: it would report nowhere. */
-export function checkMetaPixel(
-    meta: MetaPixelSettings | undefined,
-    at: string
-): void {
-    for (const id of meta?.pixelIds ?? []) {
-        if (!META_PIXEL_ID.test(id)) {
-            invalidId(
-                at,
-                `Meta pixel id "${id}" is not 15 or 16 digits, so it would report nowhere. Copy it from Events Manager.`
-            );
-        }
-    }
-}

package/src/analytics/snap-pixel.ts

@@ -1,28 +0,0 @@
-import type { NonEmpty } from "../types.ts";
-import { invalidId, UUID, type Uuid } from "./ids.ts";
-
-/**
- * Snapchat's pixel. Marketing: it loads only once a visitor grants that.
- *
- * @see https://businesshelp.snapchat.com/s/article/pixel-direct-implementation
- * @see https://forbusiness.snapchat.com/en-US/blog/the-snap-pixel-how-it-works-and-how-to-install-it
- */
-export interface SnapPixelSettings {
-    /** From Snap's Events Manager: a UUID. */
-    readonly pixelIds: NonEmpty<Uuid>;
-}
-
-/** Fails the build on an id that is not a pixel id: it would report nowhere. */
-export function checkSnapPixel(
-    snapchat: SnapPixelSettings | undefined,
-    at: string
-): void {
-    for (const id of snapchat?.pixelIds ?? []) {
-        if (!UUID.test(id)) {
-            invalidId(
-                at,
-                `Snap pixel id "${id}" is not a UUID, so it would report nowhere. Copy it from Snap's Events Manager.`
-            );
-        }
-    }
-}