@escape-game-over/atlas 0.1.117 → 0.1.119

package/README.md

@@ -130,8 +130,8 @@ export const baseRoutes   = atlas.routes({...})
 export const messages = atlas.catalog(baseMessages, { locales: [...], override: {...} })
 export const { project, redirects } = atlas.project(messages, baseRoutes, {...})
 
-// 4. the API the pages use: the deployment's catalog, the routes, the deployment
-export const site = atlas.site(messages, baseRoutes, project)
+// 4. the API the pages use, from the deployment and what it was checked against
+export const site = atlas.site(project)
 ```
 
 A site that publishes one language under several regions writes the words once:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@escape-game-over/atlas",
-    "version": "0.1.117",
+    "version": "0.1.119",
     "type": "module",
     "description": "Typed, data-driven machinery for static multi-locale, multi-deployment Astro sites.",
     "private": false,

package/src/index.ts

@@ -9,7 +9,7 @@
  * export const defaultRoutes = atlas.routes({...})                            // routes.ts
  * export const messages = atlas.catalog(defaultMessages, {...})             // projects/<name>/messages.ts
  * export const { project, redirects } = atlas.project(messages, defaultRoutes, {...}) // projects/<name>/project.ts
- * export const site = atlas.site(messages, defaultRoutes, project)            // site.ts
+ * export const site = atlas.site(project)            // site.ts
  * ```
  */
 

package/src/project.ts

@@ -157,6 +157,12 @@ export type ProjectRouteId<
     P extends { readonly overrideRoutes: unknown },
 > = EnabledRouteIdFor<Routes, P["overrideRoutes"]> & StringKeys<Routes>;
 
+/** What a project was built from, which the site is built from too. */
+export interface ProjectSources<Cat, Routes> {
+    readonly catalog: Cat;
+    readonly routes: Routes;
+}
+
 /**
  * What `atlas.project()` hands back: the project, and its redirects.
  *
@@ -170,11 +176,17 @@ export type ProjectRouteId<
  * resolves, and writes to `_redirects` with the rules the route table implies.
  */
 export interface DefinedProject<
+    Cat,
     Routes extends EnabledFlagSource,
     T extends ProjectInput<string, Routes>,
     Published extends string,
 > {
-    readonly project: T;
+    /**
+     * The project, carrying the catalog and the routes it was checked
+     * against: `atlas.site(project)` reads them from here, so a site cannot
+     * be handed a catalog its project was not checked against.
+     */
+    readonly project: T & ProjectSources<Cat, Routes>;
     /** Rules for this project's old URLs, checked against what it builds. */
     readonly redirects: <
         const Rules extends readonly RedirectRule<
@@ -200,7 +212,7 @@ export function bindRedirects<
     _routes: Routes,
     _project: T,
     _catalog: ProjectCatalog<unknown, Published, unknown, unknown>
-): DefinedProject<Routes, T, Published>["redirects"] {
+): DefinedProject<unknown, Routes, T, Published>["redirects"] {
     return (rules) => rules as never;
 }
 
@@ -303,29 +315,6 @@ type ClockCheck<T, Published extends string> = T extends {
       }
     : unknown;
 
-/**
- * The catalog each project was built with, so the site can check it is given
- * the same one. Weak, so a project nothing holds any more is not kept alive.
- */
-const builtWith = new WeakMap<object, object>();
-
-/**
- * Throws if a site is given a catalog other than the one its project was built
- * with: the project's locale checks were made against that one. A project
- * assembled by hand, which `defineProject` never saw, has nothing to compare.
- */
-export function checkProjectCatalog(
-    project: { readonly siteName: string },
-    catalog: object
-): void {
-    const own = builtWith.get(project);
-    if (own !== undefined && own !== catalog) {
-        throw new Error(
-            `Project "${project.siteName}" was built with a different catalog than the one passed to atlas.site(): pass the catalog its project.ts uses.`
-        );
-    }
-}
-
 export function defineProject<
     const C extends SiteConfigShape,
     const Cat extends ProjectCatalog<
@@ -385,6 +374,5 @@ export function defineProject<
             `Project "${project.siteName}": formats.prices.locale names ${priceLocale}, which this project does not publish.`
         );
     }
-    builtWith.set(project, catalog);
     return project;
 }

package/src/routes/family.ts

@@ -390,14 +390,22 @@ export interface RouteFamily<
     /**
      * 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.
+     *
+     * The members' own list sits beside `Picked` for the editor: it offers
+     * the members from it, which it would not from a constraint that also
+     * admits any string, since it completes a generic from what it inferred.
      */
     enable<
-        const Picked extends readonly (Member | { readonly id: Member })[],
+        const Picked extends readonly (string | { readonly id: string })[],
         const Override extends { readonly enabled?: boolean } = {
             readonly enabled: true;
         },
     >(
-        members: Picked,
+        members: Picked | readonly (Member | { readonly id: Member })[],
         override?: Override
     ): {
         readonly [M in Picked[number] as `${Dashed<Prefix>}-${MemberId<M> &
@@ -464,7 +472,8 @@ export function createFamily<
             }
             return member as never;
         },
-        enable: (picked, override) => enable(picked, override),
+        // The keys come from `Picked`; the members' own list is for the editor.
+        enable: (picked, override) => enable(picked, override) as never,
         slugs: (segment, segmentByLocale) => {
             // The join `familyMemberSlugs` makes, with the family's own prefix
             // translations rather than a copy of them.

package/src/site/create.ts

@@ -30,11 +30,7 @@ import {
     resolveShareImage,
 } from "../meta/index.ts";
 import type { PriceDecimals } from "../price-format.ts";
-import {
-    checkProjectCatalog,
-    type ProjectInput,
-    type ProjectRouteId,
-} from "../project.ts";
+import type { ProjectInput, ProjectRouteId } from "../project.ts";
 import {
     buildRedirects,
     type RedirectRule,
@@ -135,7 +131,6 @@ export function createSite<
         config_.defaultRouting.prefixDefaultLocale;
 
     // Checks that types cannot express, run once at build time.
-    checkProjectCatalog(project, catalog);
     if (locales.length === 0) {
         throw new Error("A project must publish at least one locale.");
     }

package/src/site/define.ts

@@ -60,7 +60,7 @@ import { createSite } from "./create.ts";
  * export const defaultMessages = atlas.messages({…});
  * export const messages = atlas.catalog(defaultMessages, { locales: […], override: {…} });
  * export const { project, redirects } = atlas.project(messages, defaultRoutes, {…});
- * export const site = atlas.site(messages, defaultRoutes, project);
+ * export const site = atlas.site(project);
  * ```
  *
  * Every check each step makes is the same one it makes as a function: a typo'd
@@ -152,7 +152,7 @@ export function defineSite<
             catalog: Cat,
             routes: Routes,
             project: T & ProjectOverrideChecks<PublishedOf<Cat>, Routes, T>
-        ): DefinedProject<Routes, T, PublishedOf<Cat>> {
+        ): DefinedProject<Cat, Routes, T, PublishedOf<Cat>> {
             const defined = defineProject(
                 config,
                 catalog,
@@ -160,12 +160,15 @@ export function defineSite<
                 project as never
             ) as T;
             return {
-                project: defined,
+                project: { ...defined, catalog, routes },
                 redirects: bindRedirects(routes, defined, catalog),
             };
         },
 
-        /** The API every page reads, wired for one project and its catalog. */
+        /**
+         * The API every page reads, wired for one project: built from the
+         * catalog and routes the project was checked against, which it carries.
+         */
         site<
             const Cat extends ProjectCatalog<
                 BaseCatalog<L>,
@@ -177,11 +180,16 @@ export function defineSite<
             const Routes extends RouteRegistry<L>,
             const P extends ProjectInput<L, Routes>,
         >(
-            catalog: Cat & { readonly locales: readonly Published[] },
-            routes: Routes,
-            project: P
+            project: P & {
+                // `Published` is inferred from the locales themselves, as
+                // `createSite` explains.
+                readonly catalog: Cat & {
+                    readonly locales: readonly Published[];
+                };
+                readonly routes: Routes;
+            }
         ): ReturnType<typeof createSite<C, Cat, Published, Routes, P>> {
-            return createSite(config, catalog, routes, project);
+            return createSite(config, project.catalog, project.routes, project);
         },
     };
 }