tungsten 0.6.3 → 0.7.1

package/dist/routing/registerRouting.types.test.js

@@ -0,0 +1,120 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { registerRouting } from './registerRouting.js';
+/*
+ * Type tests for registerRouting()'s inference. tsc is the assertion - nothing here runs.
+ *
+ * The case that needs pinning: globalDataFunction now takes the context and the networked store,
+ * so ContextSchema and NetworkedStoreSchema are inferred from TWO argument positions each (their
+ * own, and this callback's parameters). A parameter is a contravariant inference site, so getting
+ * this wrong collapses them to never - the same way BindableSelect's Value did before NoInfer.
+ */
+const routes = {
+  default: {
+    content: null
+  }
+};
+class AppContext {
+  constructor(reqRes) {
+    _defineProperty(this, "reqRes", void 0);
+    _defineProperty(this, "user", {
+      id: 1
+    });
+    this.reqRes = reqRes;
+  }
+}
+// the networked store is serialized to the page, so every member must be JsonValue - holding the
+// reqRes on it makes it fail `NS extends Serializable<NS>` and fall back to its constraint
+class AppStore {
+  constructor(reqRes) {
+    _defineProperty(this, "token", 'abc');
+    void reqRes;
+  }
+}
+// ---- both registered: the callback sees the real classes, not never ----------
+export const both = registerRouting(() => routes, async (reqRes, context, store) => {
+  const id = context.user.id;
+  const token = store.token;
+  return await Promise.resolve({
+    id,
+    token
+  });
+}, AppContext, AppStore);
+// G still infers from the callback's return, uncontaminated by the two new parameters
+const bothData = {
+  id: 1,
+  token: 'a'
+};
+// @ts-expect-error -- and is not widened: `id` is a number
+const bothWrong = {
+  id: 'not a number',
+  token: 'a'
+};
+// ---- context only: the store parameter is undefined, not any -----------------
+export const contextOnly = registerRouting(() => routes, async (reqRes, context) => Promise.resolve({
+  id: context.user.id
+}), AppContext);
+// ---- nothing registered: a one-argument callback still satisfies the type -----
+// the parameters are additive, so an app that ignores them is unaffected
+export const neither = registerRouting(() => routes, async () => Promise.resolve({
+  count: 1
+}));
+// ---- the parameters are checked, not any ------------------------------------
+/* eslint-disable @typescript-eslint/no-unsafe-assignment -- suppressing the type error below
+   leaves the property error-typed, which is the point of the case */
+export const wrongContextUse = registerRouting(() => routes,
+// @ts-expect-error -- `nope` is not on AppContext
+async (reqRes, context) => Promise.resolve({
+  id: context.nope
+}), AppContext);
+export const wrongStoreUse = registerRouting(() => routes,
+// @ts-expect-error -- the store is AppStore, which has no `missing`
+async (reqRes, context, store) => Promise.resolve({
+  t: store.missing
+}), AppContext, AppStore);
+/* eslint-enable @typescript-eslint/no-unsafe-assignment */
+// ---- an annotated callback parameter must not redefine the context ----------
+// the context is whatever class was registered. If the callback's own annotation is allowed to
+// compete as an inference site, a wider annotation silently wins and the registered class is lost
+class Base {
+  constructor() {
+    _defineProperty(this, "a", 1);
+  }
+}
+class Derived extends Base {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "b", 2);
+  }
+}
+export const annotatedWider = registerRouting(() => routes, async (reqRes, context) => Promise.resolve({
+  n: context.a
+}), Derived);
+const stillDerived = annotatedContext;
+void stillDerived;
+// ---- what cannot cross the network -----------------------------------------
+// the store and the global data are both serialized into the page. Checked at the ARGUMENT, so
+// the failure names the offending class or property instead of cascading - see registerRouting.ts
+class StoreHoldingReqRes {
+  constructor(reqRes) {
+    _defineProperty(this, "reqRes", void 0);
+    _defineProperty(this, "token", 'abc');
+    this.reqRes = reqRes;
+  }
+}
+export const storeNotSerializable = registerRouting(() => routes, async () => Promise.resolve({
+  n: 1
+}), AppContext,
+// @ts-expect-error -- on THIS argument, naming the class: "'typeof StoreHoldingReqRes' is not
+// assignable to ... SerializableStore<...>" ... "The types of 'reqRes' are incompatible" ...
+// "Type 'Request' is not assignable to type 'JsonValue'"
+StoreHoldingReqRes);
+export const dataNotSerializable = registerRouting(() => routes,
+// @ts-expect-error -- on the callback, naming the property: "Types of property 'leaked' are
+// incompatible" ... "Type 'Request' is not assignable to type 'JsonValue'"
+async reqRes => Promise.resolve({
+  leaked: reqRes
+}), AppContext, AppStore);
+void bothData;
+void bothWrong;

package/dist/routing/registrationTypes.d.ts

@@ -0,0 +1,11 @@
+import type { ReqRes } from '../ReqRes.js';
+import type { RoutesWithSettings } from './Routes.js';
+import type { RoutesArray } from './routesArray.js';
+export declare const $routing: unique symbol;
+export type Fixed<T> = {
+    [$routing]: T;
+};
+export type RoutesFunctionGeneric<G extends object, C, NS, Rs extends RoutesWithSettings<G> | RoutesArray<G>> = (reqRes: ReqRes | null, context: C, networkedData: NS) => Rs;
+export type ContextInitializer<ContextSchema> = new (reqRes: ReqRes | null) => ContextSchema;
+export type NetworkedStoreInitializer<StoreSchema> = new (reqRes: ReqRes | null, context?: unknown) => StoreSchema;
+//# sourceMappingURL=registrationTypes.d.ts.map

package/dist/routing/registrationTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrationTypes.d.ts","sourceRoot":"","sources":["../../src/routing/registrationTypes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAoBnD,MAAM,CAAC,OAAO,CAAC,MAAM,QAAQ,EAAE,OAAO,MAAM,CAAA;AAI5C,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;IAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;CAAE,CAAA;AAExC,MAAM,MAAM,qBAAqB,CAC7B,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,kBAAkB,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,IAC1E,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,aAAa,EAAE,EAAE,KAAK,EAAE,CAAA;AAEhE,MAAM,MAAM,kBAAkB,CAAC,aAAa,IAAI,KAC5C,MAAM,EAAE,MAAM,GAAG,IAAI,KACpB,aAAa,CAAA;AAIlB,MAAM,MAAM,yBAAyB,CAAC,WAAW,IAAI,KACjD,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,OAAO,CAAC,EAAE,OAAO,KAChB,WAAW,CAAA"}

package/dist/routing/registrationTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/resolveAppRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { Mode } from '../Mode.js';
+import type { RoutesLocation } from '../FrameworkConfig.js';
+import type { AppRoutes } from './AppRoutes.js';
+export declare function resolveAppRoutes(module: Record<string, unknown>, routesLocation: RoutesLocation, mode: Mode): AppRoutes<any>;
+//# sourceMappingURL=resolveAppRoutes.d.ts.map

package/dist/routing/resolveAppRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveAppRoutes.d.ts","sourceRoot":"","sources":["../../src/routing/resolveAppRoutes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAQ/C,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,cAAc,EAAE,cAAc,EAC9B,IAAI,EAAE,IAAI,GACX,SAAS,CAAC,GAAG,CAAC,CAgChB"}

package/dist/routing/resolveAppRoutes.js

@@ -0,0 +1,25 @@
+import { TungstenError } from '../TungstenError.js';
+import { routesLocationParts } from '../routesLocationParts.js';
+import { registeredRouting } from './routingRegistry.js';
+// routes come from registerRouting() or from routesLocation's named export. The module has already
+// been imported by the caller, which is what runs the registerRouting() call
+export function resolveAppRoutes(module, routesLocation, mode) {
+  const {
+    routesFile,
+    routeExport
+  } = routesLocationParts(routesLocation);
+  const registered = registeredRouting.value;
+  const isExported = routeExport !== undefined && routeExport in module;
+  // both systems in one app is almost always a mistake, so say so while it is cheap to fix
+  if (registered !== undefined && isExported && mode === 'dev') {
+    throw new TungstenError(`Routes are set twice: registerRouting() was called, and routes file ${routesFile}` + ` exports ${routeExport} (config.routesLocation). Use one or the other - drop the` + ` export name from routesLocation to keep registerRouting().`);
+  }
+  if (registered !== undefined) return registered;
+  if (isExported) {
+    return module[routeExport]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+  }
+  if (routeExport === undefined) {
+    throw new TungstenError(`No routes. config.routesLocation names the file ${routesFile} without an export name,` + ` so routes must come from registerRouting(), but ${routesFile} did not call it.`);
+  }
+  throw new TungstenError(`Could not find an export named ${routeExport} in routes file ${routesFile},` + ` and registerRouting() was not called.` + ` These settings are set in config.routesLocation.`);
+}

package/dist/routing/routesArray.d.ts

@@ -0,0 +1,23 @@
+import type { ErrorRouteType } from './ErrorRouteType.js';
+import type { Routes, RoutesWithSettings } from './Routes.js';
+import type { Endpoint, Path } from './RouteTypes.js';
+export type RouteEntry<G extends object | undefined = object> = (Endpoint<any, any, G> & {
+    path: Path | 'default' | '404';
+}) | (ErrorRouteType & {
+    path: 'error';
+});
+export type RoutesArray<G extends object | undefined = object> = readonly RouteEntry<G>[];
+export declare function routesFromArray(entries: RoutesArray<any>, dev: boolean): Routes<any>;
+export declare const toRoutes: <Rs extends object>(routes: Rs | RoutesArray<any>, dev: boolean) => Rs | RoutesWithSettings<any>;
+export type KeyedRoutes<Rs> = Rs extends RoutesArray<any> ? {
+    [Entry in Rs[number] as Entry['path']]: Omit<Entry, 'path'>;
+} : Rs;
+type IsOnePath<P extends PropertyKey> = Record<never, never> extends Record<P, 1> ? false : true;
+type DuplicatePath<T, Seen = never> = T extends readonly [infer H, ...infer Rest] ? H extends {
+    path: infer P extends PropertyKey;
+} ? IsOnePath<P> extends false ? DuplicatePath<Rest, Seen> : P extends Seen ? P : DuplicatePath<Rest, Seen | P> : DuplicatePath<Rest, Seen> : never;
+type ReturnedRoutes<R> = R extends (...args: never[]) => infer Rs ? Rs : R;
+type GivenTwice<P extends string> = `The routes give the path '${P}' twice. Each path can have one route.`;
+export type NoDuplicatePaths<R> = [DuplicatePath<ReturnedRoutes<R>>] extends [never] ? unknown : GivenTwice<DuplicatePath<ReturnedRoutes<R>> & string>;
+export {};
+//# sourceMappingURL=routesArray.d.ts.map

package/dist/routing/routesArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routesArray.d.ts","sourceRoot":"","sources":["../../src/routing/routesArray.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAOrD,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,SAAS,GAAG,MAAM,IACtD,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG;IAAE,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,KAAK,CAAA;CAAE,CAAC,GAC5D,CAAC,cAAc,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAE1C,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,GAAG,SAAS,GAAG,MAAM,IAAI,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,CAAA;AAIzF,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAYpF;AAGD,eAAO,MAAM,QAAQ,GAAI,EAAE,SAAS,MAAM,EACtC,QAAQ,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,EAAE,KAAK,OAAO,KAC5C,EAAE,GAAG,kBAAkB,CAAC,GAAG,CACmC,CAAA;AAQjE,MAAM,MAAM,WAAW,CAAC,EAAE,IAAI,EAAE,SAAS,WAAW,CAAC,GAAG,CAAC,GACnD;KAAG,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;CAAE,GAC/D,EAAE,CAAA;AAMR,KAAK,SAAS,CAAC,CAAC,SAAS,WAAW,IAAI,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAA;AAChG,KAAK,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,IAAI,CAAC,GAC3E,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC,SAAS,WAAW,CAAA;CAAE,GAC3C,SAAS,CAAC,CAAC,CAAC,SAAS,KAAK,GACtB,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,GACzB,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,CAAC,GACtD,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,GAC7B,KAAK,CAAA;AACX,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAE1E,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,IAC1B,6BAA6B,CAAC,wCAAwC,CAAA;AAG5E,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAC9E,OAAO,GACP,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAA"}

package/dist/routing/routesArray.js

@@ -0,0 +1,20 @@
+import { TungstenError } from '../TungstenError.js';
+// the array form as the object form. A path given twice is an error in dev; otherwise the last
+// one wins, as a repeated key does in an object
+export function routesFromArray(entries, dev) {
+  const routes = {};
+  for (const {
+    path,
+    ...endpoint
+  } of entries) {
+    if (dev && Object.hasOwn(routes, path)) {
+      throw new TungstenError(`The routes give the path '${path}' twice. Each path can have one route.`);
+    }
+    routes[path] = endpoint;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- keyed by entry path
+  return routes;
+}
+// the array form carries no RoutesSettings, so they read as unset
+export const toRoutes = (routes, dev) => isRoutesArray(routes) ? routesFromArray(routes, dev) : routes;
+const isRoutesArray = routes => Array.isArray(routes);

package/dist/routing/routesArray.types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routesArray.types.test.d.ts.map

package/dist/routing/routesArray.types.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routesArray.types.test.d.ts","sourceRoot":"","sources":["../../src/routing/routesArray.types.test.ts"],"names":[],"mappings":""}

package/dist/routing/routesArray.types.test.js

@@ -0,0 +1,132 @@
+import { appBuilder } from '../appBuilder.js';
+import { pipeline } from '../pipeline/pipeline.js';
+import { route } from './builder.js';
+/*
+ * Type tests for the array routes form. tsc is the assertion - nothing here runs.
+ */
+const _routes = () => [route({
+  path: '/leads/:id<1+>',
+  content: null
+}), route({
+  path: '/about',
+  content: null
+}), route({
+  path: '404',
+  content: null
+})];
+// the route and path types read the array form as they read the object form
+const leadPath = '/leads/5';
+const aboutPath = '/about';
+// @ts-expect-error -- not a route
+const nopePath = '/nope';
+const routeKeys = ['/leads/:id<1+>', '/about', '404'];
+// @ts-expect-error -- not a route key
+const nopeKey = '/nope';
+void leadPath;
+void aboutPath;
+void nopePath;
+void routeKeys;
+void nopeKey;
+// a plain array works too
+const _array = [route({
+  path: '/a',
+  content: null
+})];
+const arrayPath = '/a';
+void arrayPath;
+// a path starts with / or names a special route
+// @ts-expect-error -- neither
+route({
+  path: 'foo',
+  content: null
+});
+// the error route's content is a function without data, which route() does not take: a plain entry
+appBuilder.routes(() => [route({
+  path: '/e',
+  content: null
+}), {
+  path: 'error',
+  content: () => null
+}]);
+// @ts-expect-error -- and it is typed as the error route
+appBuilder.routes(() => [{
+  path: 'error',
+  content: info => info.nope
+}]);
+// the app builder takes the array form
+appBuilder.routes(() => [route({
+  path: '/b',
+  content: null
+})]);
+appBuilder.routes([route({
+  path: '/c',
+  content: null
+})]);
+// ---- a path given twice, at registration ------------------------------------
+appBuilder.routes(() => [route({
+  path: '/a',
+  content: null
+}), route({
+  path: '/b',
+  content: null
+}), route({
+  path: '404',
+  content: null
+})]);
+// @ts-expect-error -- '/a' twice
+appBuilder.routes(() => [route({
+  path: '/a',
+  content: null
+}), route({
+  path: '/a',
+  content: 'x'
+})]);
+// @ts-expect-error -- given directly, too
+appBuilder.routes([route({
+  path: '/a',
+  content: null
+}), route({
+  path: '/a',
+  content: null
+})]);
+// @ts-expect-error -- and without route()
+appBuilder.routes(() => [{
+  path: '/a',
+  content: null
+}, {
+  path: '/a',
+  content: null
+}]);
+// @ts-expect-error -- and in the pipeline
+pipeline.server('express').routes(() => [route({
+  path: '/a',
+  content: null
+}), route({
+  path: '/a',
+  content: null
+})]);
+appBuilder.routes(() => [route({
+  path: somePath,
+  content: null
+}), route({
+  path: '/a',
+  content: null
+})]);
+// a computed array is not a tuple, so it is left to the check when the routes are read
+const computed = [route({
+  path: '/a',
+  content: null
+}), route({
+  path: '/a',
+  content: null
+})];
+appBuilder.routes(() => computed);
+// the object form is untouched
+appBuilder.routes(() => ({
+  '/a': {
+    content: null
+  },
+  '404': {
+    content: null
+  }
+}));

package/dist/routing/routingBuilder.d.ts

@@ -0,0 +1,34 @@
+import type { ReqRes, ReqResOrNull } from '../ReqRes.js';
+import type { RoutesWithSettings } from './Routes.js';
+import type { ContextClasses } from '../context/registerContext.js';
+import type { Routing, RoutesFunctionGeneric, Serializable } from './registerRouting.js';
+import type { Fixed } from './registrationTypes.js';
+type NetworkedStoreClass<C, ND> = (new (reqRes: ReqResOrNull, context: C) => ND) & (new (reqRes: ReqResOrNull, context: C) => Serializable<NoInfer<ND>>);
+type GetGlobalData<C, ND, G extends object> = ((reqRes: ReqRes | null, context: C, networkedData: ND) => Promise<G>) & ((reqRes: ReqRes | null, context: C, networkedData: ND) => Promise<Serializable<NoInfer<G>>>);
+type RoutesMethod<C, ND, G extends object> = {
+    routes: <Rs extends RoutesWithSettings<G>>(getRoutes: RoutesFunctionGeneric<G, C, ND, Rs>) => Routing<Rs, G, C, ND>;
+};
+type GlobalDataMethod<C, ND> = {
+    globalData: <G extends object>(getGlobalData: GetGlobalData<C, ND, G>) => RoutesStage<C, ND, G>;
+};
+type NetworkedDataMethod<C> = {
+    networkedData: <ND extends object>(networkedDataInitializer: NetworkedStoreClass<C, ND>) => GlobalDataStage<C, ND>;
+};
+type RoutesStage<C, ND, G extends object> = RoutesMethod<C, ND, G> & Fixed<{
+    context: C;
+    networkedStore: ND;
+    globalData: G;
+}>;
+type GlobalDataStage<C, ND> = RoutesMethod<C, ND, object> & GlobalDataMethod<C, ND> & Fixed<{
+    context: C;
+    networkedStore: ND;
+}>;
+type NetworkedDataStage<C> = RoutesMethod<C, undefined, object> & GlobalDataMethod<C, undefined> & NetworkedDataMethod<C> & Fixed<{
+    context: C;
+}>;
+type ContextStage = RoutesMethod<undefined, undefined, object> & GlobalDataMethod<undefined, undefined> & NetworkedDataMethod<undefined> & {
+    context: <C extends object>(contextInitializer: (new (reqRes: ReqResOrNull) => C) | ContextClasses) => NetworkedDataStage<C>;
+};
+export declare const register: ContextStage;
+export {};
+//# sourceMappingURL=routingBuilder.d.ts.map

package/dist/routing/routingBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routingBuilder.d.ts","sourceRoot":"","sources":["../../src/routing/routingBuilder.ts"],"names":[],"mappings":"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"}

package/dist/routing/routingBuilder.js

@@ -0,0 +1,32 @@
+import { registeredRouting, registeredNetworkedStore } from './routingRegistry.js';
+import { contextRegistration } from '../context/registerContext.js';
+import { globalDataFunc } from './registerGlobalData.js';
+function makeStages(pending) {
+  return {
+    context: contextInitializer => makeStages({
+      ...pending,
+      context: contextInitializer
+    }),
+    networkedData: networkedDataInitializer => makeStages({
+      ...pending,
+      networkedStore: networkedDataInitializer
+    }),
+    globalData: getGlobalData => makeStages({
+      ...pending,
+      globalData: getGlobalData
+    }),
+    routes: getRoutes => {
+      registeredRouting.value = getRoutes;
+      if (pending.globalData !== undefined) globalDataFunc.value = pending.globalData;
+      if (pending.context !== undefined) contextRegistration.value = pending.context;
+      if (pending.networkedStore !== undefined) {
+        registeredNetworkedStore.value = pending.networkedStore;
+      }
+      return undefined;
+    }
+    // unchecked: every method hands back this one untyped shape, not the stage it promises, and the
+    // Fixed records exist only in the types
+  };
+}
+// the entry point. Every stage is optional except .routes(), which commits the chain
+export const register = makeStages({});

package/dist/routing/routingBuilder.types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routingBuilder.types.test.d.ts.map

package/dist/routing/routingBuilder.types.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routingBuilder.types.test.d.ts","sourceRoot":"","sources":["../../src/routing/routingBuilder.types.test.ts"],"names":[],"mappings":""}

package/dist/routing/routingBuilder.types.test.js

@@ -0,0 +1,171 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { register } from './routingBuilder.js';
+/*
+ * Type tests for the staged builder. tsc is the assertion - nothing here runs.
+ *
+ * What is being pinned: each stage fixes ONE type parameter from ONE argument, so every later
+ * stage sees a concrete type. The cases below check that the later callbacks really do see the
+ * earlier types, that skipping a stage leaves `undefined` rather than collapsing, and that the
+ * serializable checks land on the argument at fault.
+ */
+const routes = {
+  default: {
+    content: null
+  }
+};
+class AppContext {
+  constructor(reqRes) {
+    _defineProperty(this, "user", {
+      id: 1
+    });
+    void reqRes;
+  }
+}
+class AppStore {
+  // the store is built after the context, so it may read it
+  constructor(reqRes, context) {
+    _defineProperty(this, "userId", void 0);
+    _defineProperty(this, "token", 'abc');
+    void reqRes;
+    this.userId = context.user.id;
+  }
+}
+// ---- the full chain ---------------------------------------------------------
+const _full = register.context(AppContext).networkedData(AppStore).globalData(async (reqRes, context, networkedData) => {
+  // both earlier stages are concrete here, with no annotation and no cast
+  const id = context.user.id;
+  const token = networkedData.token;
+  return await Promise.resolve({
+    id,
+    token
+  });
+}).routes((reqRes, context, networkedData) => {
+  // and so are they here, alongside the global data's own type
+  const id = context.user.id;
+  const token = networkedData.token;
+  void id;
+  void token;
+  return routes;
+});
+const fullContext = fullC;
+const fullStore = fullNd;
+const fullData = fullG;
+const fullRoutes = fullRs;
+void fullContext;
+void fullStore;
+void fullData;
+void fullRoutes;
+// the cases above would pass just as well if the parameters were silently `any`, so each one is
+// probed for a member that does not exist. Without these, "the later stages see the types" can
+// mean only that we have stopped checking
+/* eslint-disable @typescript-eslint/no-unsafe-assignment -- suppressing the type error leaves the
+   property error-typed, which is exactly what these cases are for */
+register.context(AppContext).networkedData(AppStore)
+// @ts-expect-error -- `nope` is not on AppContext, so the context is not any
+.globalData(async (reqRes, context) => Promise.resolve({
+  x: context.nope
+})).routes(() => routes);
+register.context(AppContext).networkedData(AppStore)
+// @ts-expect-error -- `nope` is not on AppStore, so the store is not any
+.globalData(async (reqRes, context, networkedData) => Promise.resolve({
+  x: networkedData.nope
+})).routes(() => routes);
+/* eslint-enable @typescript-eslint/no-unsafe-assignment */
+register.context(AppContext).routes((reqRes, context) => {
+  // @ts-expect-error -- and the same inside the routes callback
+  void context.nope;
+  return routes;
+});
+// ---- reading a type off an unfinished chain ---------------------------------
+// an app augments Context from the stage after .context(): read off the finished routing, a
+// callback in the chain that names the augmented type would be part of its own definition
+const withContext = register.context(AppContext);
+const stageContext = stageC;
+const withStore = withContext.networkedData(AppStore);
+const stageStore = stageNd;
+const stageStoreContext = stageStoreC;
+void stageContext;
+void stageStore;
+void stageStoreContext;
+const _staged = withStore.globalData(async (reqRes, context, networkedData) => Promise.resolve({
+  id: context.user.id,
+  token: networkedData.token
+})).routes(() => routes);
+const stagedData = stagedG;
+void stagedData;
+// ---- skipping stages --------------------------------------------------------
+const _noneAtAll = register.routes(() => routes);
+const skippedContext = noneC;
+void skippedContext;
+const _contextOnly = register.context(AppContext).routes((reqRes, context) => {
+  const id = context.user.id;
+  void id;
+  return routes;
+});
+const keptContext = contextOnlyC;
+void keptContext;
+const _dataOnly = register.globalData(async () => Promise.resolve({
+  n: 1
+})).routes(() => routes);
+const keptData = dataOnlyG;
+void keptData;
+// ---- a stage cannot be taken twice, or out of order -------------------------
+// @ts-expect-error -- .context is gone once taken
+register.context(AppContext).context(AppContext);
+// @ts-expect-error -- .context cannot follow .globalData
+register.globalData(async () => Promise.resolve({})).context(AppContext);
+// @ts-expect-error -- .networkedData cannot follow .globalData
+register.globalData(async () => Promise.resolve({})).networkedData(AppStore);
+// ---- what cannot cross the network ------------------------------------------
+class StoreHoldingReqRes {
+  constructor(reqRes) {
+    _defineProperty(this, "reqRes", void 0);
+    _defineProperty(this, "token", 'abc');
+    this.reqRes = reqRes;
+  }
+}
+register.context(AppContext)
+// @ts-expect-error -- on THIS argument: "Type 'Request' is not assignable to type 'JsonValue'"
+.networkedData(StoreHoldingReqRes).routes(() => routes);
+register
+// @ts-expect-error -- on THIS callback: "Types of property 'leaked' are incompatible"
+.globalData(async reqRes => Promise.resolve({
+  leaked: reqRes
+})).routes(() => routes);
+// ---- the routes are checked against the global data -------------------------
+// Rs is constrained by RoutesWithSettings<G>, with G already concrete by this point
+register.globalData(async () => Promise.resolve({
+  n: 1
+}))
+// @ts-expect-error -- routes must have a `default` or a `404`
+.routes(() => ({
+  '/somewhere': {
+    content: null
+  }
+}));
+// G reaches a route's content function, which is the point of fixing it first: by the time
+// .routes() is called G is a concrete type, not a parameter still being inferred elsewhere
+register.globalData(async () => Promise.resolve({
+  n: 1
+})).routes(() => ({
+  default: {
+    content: (routeData, routeParams, props, globalData) => {
+      const n = globalData.n;
+      void n;
+      return null;
+    }
+  }
+}));
+register.globalData(async () => Promise.resolve({
+  n: 1
+})).routes(() => ({
+  default: {
+    content: (routeData, routeParams, props, globalData) => {
+      // @ts-expect-error -- and it is checked: `nope` is not on the global data
+      void globalData.nope;
+      return null;
+    }
+  }
+}));

package/dist/routing/routingRegistry.d.ts

@@ -0,0 +1,19 @@
+import type { AppRoutes } from './AppRoutes.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { BrandedContext, BrandedNetworkedData } from '../Brands.js';
+import type { Context } from '../context/registerContext.js';
+import type { Serializable } from './Serializable.js';
+import type { Fixed } from './registrationTypes.js';
+export interface NetworkedData {
+}
+export declare const registeredRouting: {
+    value: AppRoutes<any> | undefined;
+};
+export declare const registeredNetworkedStore: {
+    value: (new (reqRes: ReqRes | null, context: BrandedContext) => object) | undefined;
+};
+export declare function registerNetworkedData<ND extends object>(store: (new (reqRes: ReqRes | null, context: Context) => ND) & (new (reqRes: ReqRes | null, context: Context) => Serializable<NoInfer<ND>>)): Fixed<{
+    networkedStore: ND;
+}>;
+export declare function createNetworkedData(reqRes: ReqRes | null, context: BrandedContext): BrandedNetworkedData;
+//# sourceMappingURL=routingRegistry.d.ts.map

package/dist/routing/routingRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routingRegistry.d.ts","sourceRoot":"","sources":["../../src/routing/routingRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAmB,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACzF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAMnD,MAAM,WAAW,aAAa;CAAG;AAIjC,eAAO,MAAM,iBAAiB,EAAE;IAAE,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,SAAS,CAAA;CAAyB,CAAA;AAG5F,eAAO,MAAM,wBAAwB,EAAE;IACnC,KAAK,EAAE,CAAC,KAAK,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,cAAc,KAAK,MAAM,CAAC,GAAG,SAAS,CAAA;CAC/D,CAAA;AAKxB,wBAAgB,qBAAqB,CAAC,EAAE,SAAS,MAAM,EACnD,KAAK,EAAE,CAAC,KAAK,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,OAAO,KAAK,EAAE,CAAC,GAEtD,CAAC,KAAK,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,OAAO,KAAK,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,GACnF,KAAK,CAAC;IAAE,cAAc,EAAE,EAAE,CAAA;CAAE,CAAC,CAI/B;AAQD,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,cAAc,GAC/C,oBAAoB,CAKtB"}