@kestack/kabuki 0.0.1 → 0.0.2

package/dist/react/lazy.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, lazy as reactLazy, use } from 'react';
+/** Told of each lazy View a drawing draws; given by the App's `onLazyView`. */
+export const LazyContext = createContext(undefined);
+// 4. Find
+const byActor = new WeakMap();
+/** The lazy View made for `actor`, if one was: to load its code before it is drawn. */
+export const lazyOf = (actor) => byActor.get(actor.definition);
+const KEY = Symbol.for('@kestack/kabuki/lazy-views');
+const byId = () => {
+    const global = globalThis;
+    return (global[KEY] ??= new Map());
+};
+/**
+ * A View of `actor` loaded when first drawn: `load` imports a module whose
+ * default export is the View, made with `View.make`. The Actor is named here
+ * so the View can be found by it, and preloaded, before its code is there.
+ */
+export const lazy = (actor, load, options = {}) => {
+    // 1. Load
+    let view;
+    let loading;
+    const preload = () => (loading ??= load().then((module) => {
+        view = module.default;
+    }, (error) => {
+        loading = undefined;
+        throw error;
+    }));
+    const Loading = reactLazy(() => preload().then(() => ({ default: view })));
+    // 2. Draw
+    const Lazy = ((props) => {
+        // 3. Collect
+        use(LazyContext)?.(self);
+        const Loaded = view;
+        return Loaded ? _jsx(Loaded, { ...props }) : _jsx(Loading, { ...props });
+    });
+    const self = Object.defineProperties(Lazy, {
+        actor: { value: actor, enumerable: true },
+        id: { value: options.id, enumerable: true },
+        preload: { value: preload, enumerable: true },
+        loaded: { get: () => view !== undefined, enumerable: true },
+        displayName: { get: () => `Lazy(${actor.name}View)` },
+    });
+    if (options.id !== undefined)
+        byId().set(options.id, self);
+    byActor.set(actor.definition, self);
+    return self;
+};
+/** Preload every lazy View made with one of these ids; an id no lazy View was made with is skipped. */
+export const preload = async (ids) => {
+    const views = byId();
+    await Promise.all([...ids].flatMap((id) => {
+        const view = views.get(id);
+        return view ? [view.preload()] : [];
+    }));
+};

package/dist/react/live.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether the app is drawn as it is now, not at a past Step, as Time Travel
+ * shows it: what an effect that touches the page around the app, like its
+ * scroll, reads first. Outside an app, always; on a server, never.
+ */
+export declare const useLive: () => boolean;
+//# sourceMappingURL=live.d.ts.map

package/dist/react/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../src/react/live.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,OAAO,QAAO,OAO1B,CAAC"}

package/dist/react/live.js

@@ -0,0 +1,13 @@
+import { use, useSyncExternalStore } from 'react';
+import { AppContext } from './view.js';
+const never = () => false;
+const noop = () => () => { };
+/**
+ * Whether the app is drawn as it is now, not at a past Step, as Time Travel
+ * shows it: what an effect that touches the page around the app, like its
+ * scroll, reads first. Outside an app, always; on a server, never.
+ */
+export const useLive = () => {
+    const drawn = use(AppContext);
+    return useSyncExternalStore(drawn?.subscribe ?? noop, drawn?.live ?? (() => true), never);
+};

package/dist/react/view.d.ts

@@ -1,14 +1,22 @@
 import type { CSSProperties, ReactNode, Ref } from 'react';
-import type { AnyActor, Many, Only, Types } from '../core/index.ts';
+import type { AnyActor, Only, Types } from '../core/index.ts';
+import { lazy, preload } from './lazy.tsx';
 /** One Instance in the tree, to draw: its ID and, for a keyed Child, its key. Never changes. */
 export interface Handle<A> {
     readonly id: string;
     readonly key?: string;
     readonly actor?: A;
 }
-type HandleOf<S> = S extends Many<infer A> ? ReadonlyArray<Handle<A> & {
+/** A Child as its View finds it: a list of `each`, one that may be absent `while` its test is false, else one always there. */
+type HandleOf<C> = C extends {
+    readonly actor: infer A;
+} ? C extends {
+    readonly each: Function;
+} ? ReadonlyArray<Handle<A> & {
     readonly key: string;
-}> : Handle<S>;
+}> : C extends {
+    readonly while: Function;
+} ? Handle<A> | undefined : Handle<A> : never;
 type KidsIn<A, T> = T extends keyof Types<A>['children'] ? Types<A>['children'][T] : {};
 /**
  * What a parent may hand the root element of a View: the `ref` and `style`
@@ -48,6 +56,8 @@ export interface DrawnApp {
     readonly instance: (id: string) => Drawable | undefined;
     /** The Instance as first drawn, before any Runtime: what a server draws and the client hydrates against. */
     readonly served: (id: string) => Drawable | undefined;
+    /** Whether it draws the app as it is now, not a past Step: what may touch the page around it. */
+    readonly live: () => boolean;
 }
 export declare const AppContext: import("react").Context<DrawnApp | undefined>;
 /**
@@ -55,16 +65,20 @@ export declare const AppContext: import("react").Context<DrawnApp | undefined>;
  * `ref` and `style` to animate it by. Data from the parent is its Props, which
  * the parent Actor hands it, so Update and Workers see it too.
  */
-export type ViewOf<A> = (props: {
+export type ViewOf<A> = ((props: {
     readonly instance: Handle<A>;
     readonly ref?: Ref<Element> | undefined;
     readonly style?: CSSProperties | undefined;
-}) => ReactNode;
+}) => ReactNode) & {
+    /** The Actor it draws. */
+    readonly actor: A;
+};
 /**
  * How one Actor is drawn: one function of its Instance. The result re-renders
  * only when its own Instance's Model, State, Props or set of Children changes,
  * or the parent hands it a new `ref` or `style`, never because a descendant
- * did.
+ * did. A new Instance in the same place, as a Child with a new key, is drawn
+ * afresh: no React state carries over from the one before.
  *
  * Once the Instance stops, the View keeps drawing its last data, so an exit
  * animation still has something to show.
@@ -73,8 +87,14 @@ export type ViewOf<A> = (props: {
  * the View a new `style` object on every render, with the same values.
  */
 declare const make: <A extends AnyActor>(actor: A, draw: (self: ViewProps<A>) => ReactNode) => ViewOf<A>;
+/**
+ * `make` draws an Actor; `lazy` loads a View made with `make` when it is
+ * first drawn; `preload` loads the lazy Views made with these ids.
+ */
 export declare const View: {
     make: typeof make;
+    lazy: typeof lazy;
+    preload: typeof preload;
 };
 export {};
 //# sourceMappingURL=view.d.ts.map

package/dist/react/view.d.ts.map

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

package/dist/react/view.js

@@ -1,10 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, memo, use, useRef, useSyncExternalStore } from 'react';
+import { lazy, preload } from './lazy.js';
 export const AppContext = createContext(undefined);
 /**
  * How one Actor is drawn: one function of its Instance. The result re-renders
  * only when its own Instance's Model, State, Props or set of Children changes,
  * or the parent hands it a new `ref` or `style`, never because a descendant
- * did.
+ * did. A new Instance in the same place, as a Child with a new key, is drawn
+ * afresh: no React state carries over from the one before.
  *
  * Once the Instance stops, the View keeps drawing its last data, so an exit
  * animation still has something to show.
@@ -13,7 +16,7 @@ export const AppContext = createContext(undefined);
  * the View a new `style` object on every render, with the same values.
  */
 const make = (actor, draw) => {
-    const View = memo(({ instance, ref, style, }) => {
+    const Drawn = ({ instance, ref, style }) => {
         const drawn = use(AppContext);
         if (!drawn)
             throw new Error(`[@kestack/kabuki] ${actor.name}View is drawn outside its app`);
@@ -31,8 +34,13 @@ const make = (actor, draw) => {
             ...self,
             root: { ref: ref, style },
         });
-    }, same);
-    View.displayName = `${actor.name}View`;
+    };
+    const View = memo((given) => (_jsx(Drawn, { ...given }, given.instance.id)), same);
+    // Read when shown, so a name given after the View is made still counts.
+    Object.defineProperties(View, {
+        actor: { value: actor, enumerable: true },
+        displayName: { get: () => `${actor.name}View`, configurable: true },
+    });
     return View;
 };
 /** What the parent hands is the same when each is the same value, and `style` when each of its values is. */
@@ -44,4 +52,8 @@ const same = (a, b) => {
         (key === 'style' && sameValues(a[key], b[key])));
 };
 const sameValues = (a, b) => a !== undefined && b !== undefined && same(a, b);
-export const View = { make };
+/**
+ * `make` draws an Actor; `lazy` loads a View made with `make` when it is
+ * first drawn; `preload` loads the lazy Views made with these ids.
+ */
+export const View = { make, lazy, preload };

package/dist/routing/adapter/adapter.d.ts

@@ -0,0 +1,38 @@
+import { Context } from 'effect';
+/**
+ * Where an app's Address lives, besides memory: the browser's own history or
+ * TanStack Router's. Every URL here is a whole path with its query, base
+ * included. An entry's key is what the router stamps on each history entry it
+ * writes, so Back and Forward land on an entry it knows. With no Adapter in
+ * the Layer, the app routes in memory and never touches a URL.
+ */
+export interface AdapterShape {
+    /** The URL shown now: path and query. */
+    readonly url: () => string;
+    /** The element on the page the URL names now, after its `#`, decoded; none if it names none. */
+    readonly hash?: () => string;
+    /** The key the router stamped on the entry shown now, if it wrote it. */
+    readonly key: () => string | null;
+    /** Hear every change of the URL, whoever made it; gives back how to stop. */
+    readonly listen: (changed: () => void) => () => void;
+    readonly push: (url: string, key: string) => void;
+    readonly replace: (url: string, key: string) => void;
+    /** Move through the history by `by` entries: -1 is Back. */
+    readonly go: (by: number) => void;
+    /**
+     * Go to a URL outside the app's base, or another site: hand it to whoever
+     * owns it. `replace` takes the place of the entry shown, as a Redirect does.
+     */
+    readonly leave: (url: string, options?: {
+        readonly replace?: boolean;
+    }) => void;
+}
+declare const Adapter_base: Context.ServiceClass<Adapter, "@kestack/kabuki/routing/Adapter", AdapterShape>;
+export declare class Adapter extends Adapter_base {
+}
+/** The key the router keeps in a history entry's state. */
+export declare const KEY = "@kestack/kabuki/routing";
+/** The key in a history entry's state, if the router wrote one. */
+export declare const keyIn: (state: unknown) => string | null;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/routing/adapter/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AASjC;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,gGAAgG;IAChG,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,MAAM,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IACrD,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,KACrC,IAAI,CAAC;CACX;;AAED,qBAAa,OAAQ,SAAQ,YAE5B;CAAG;AAEJ,2DAA2D;AAC3D,eAAO,MAAM,GAAG,4BAA4B,CAAC;AAE7C,mEAAmE;AACnE,eAAO,MAAM,KAAK,UAAW,OAAO,KAAG,MAAM,GAAG,IAG/C,CAAC"}

package/dist/routing/adapter/adapter.js

@@ -0,0 +1,10 @@
+import { Context } from 'effect';
+export class Adapter extends Context.Service()('@kestack/kabuki/routing/Adapter') {
+}
+/** The key the router keeps in a history entry's state. */
+export const KEY = '@kestack/kabuki/routing';
+/** The key in a history entry's state, if the router wrote one. */
+export const keyIn = (state) => {
+    const found = state?.[KEY];
+    return typeof found === 'string' ? found : null;
+};

package/dist/routing/adapter/browser/browser.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from 'effect';
+import { Adapter } from '../index.ts';
+/**
+ * The browser's own history, for an app that owns the address: the whole
+ * site, or everything under its base.
+ */
+export declare const browser: () => Layer.Layer<Adapter, never, never>;
+//# sourceMappingURL=browser.d.ts.map

package/dist/routing/adapter/browser/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../../src/routing/adapter/browser/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAc,MAAM,aAAa,CAAC;AAIlD;;;GAGG;AACH,eAAO,MAAM,OAAO,0CA2BhB,CAAC"}

package/dist/routing/adapter/browser/browser.js

@@ -0,0 +1,33 @@
+import { Layer } from 'effect';
+import { Adapter, KEY, keyIn } from '../index.js';
+const CHANGED = '@kestack/kabuki/routing:changed';
+/**
+ * The browser's own history, for an app that owns the address: the whole
+ * site, or everything under its base.
+ */
+export const browser = () => Layer.sync(Adapter, () => {
+    const tell = () => dispatchEvent(new Event(CHANGED));
+    return {
+        url: () => `${location.pathname}${location.search}`,
+        hash: () => decodeURIComponent(location.hash.slice(1)),
+        key: () => keyIn(history.state),
+        listen: (changed) => {
+            addEventListener('popstate', changed);
+            addEventListener(CHANGED, changed);
+            return () => {
+                removeEventListener('popstate', changed);
+                removeEventListener(CHANGED, changed);
+            };
+        },
+        push: (url, key) => {
+            history.pushState({ [KEY]: key }, '', url);
+            tell();
+        },
+        replace: (url, key) => {
+            history.replaceState({ [KEY]: key }, '', url);
+            tell();
+        },
+        go: (by) => history.go(by),
+        leave: (url, options) => options?.replace ? location.replace(url) : location.assign(url),
+    };
+});

package/dist/routing/adapter/browser/index.d.ts

@@ -0,0 +1,2 @@
+export { browser } from './browser.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/routing/adapter/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/routing/adapter/browser/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/routing/adapter/browser/index.js

@@ -0,0 +1 @@
+export { browser } from './browser.js';

package/dist/routing/adapter/index.d.ts

@@ -0,0 +1,3 @@
+export { Adapter, KEY, keyIn } from './adapter.ts';
+export type { AdapterShape } from './adapter.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/routing/adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routing/adapter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

package/dist/routing/adapter/index.js

@@ -0,0 +1 @@
+export { Adapter, KEY, keyIn } from './adapter.js';

package/dist/routing/adapter/tanstack/index.d.ts

@@ -0,0 +1,3 @@
+export { tanstack } from './tanstack.ts';
+export type { TanStackHistory } from './tanstack.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/routing/adapter/tanstack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/routing/adapter/tanstack/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/routing/adapter/tanstack/index.js

@@ -0,0 +1 @@
+export { tanstack } from './tanstack.js';

package/dist/routing/adapter/tanstack/tanstack.d.ts

@@ -0,0 +1,27 @@
+import { Layer } from 'effect';
+import { Adapter } from '../index.ts';
+/** The part of a TanStack Router history the Adapter needs: `router.history`. */
+export interface TanStackHistory {
+    readonly location: {
+        readonly pathname: string;
+        readonly search: string;
+        readonly hash?: string;
+        readonly state: unknown;
+    };
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly push: (path: string, state?: any) => void;
+    readonly replace: (path: string, state?: any) => void;
+    readonly go: (index: number) => void;
+}
+/**
+ * TanStack Router's history, for an app on a TanStack Start catch-all route:
+ * TanStack hands everything under the app's base to it, and gets back every
+ * URL outside it. Every move goes through TanStack's history, so TanStack
+ * keeps its own count of where Back goes and matches the same route again
+ * without remounting. By default it finds the router TanStack keeps on the
+ * page; `history` hands one over instead.
+ */
+export declare const tanstack: (options?: {
+    readonly history?: () => TanStackHistory;
+}) => Layer.Layer<Adapter, never, never>;
+//# sourceMappingURL=tanstack.d.ts.map

package/dist/routing/adapter/tanstack/tanstack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tanstack.d.ts","sourceRoot":"","sources":["../../../../src/routing/adapter/tanstack/tanstack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAc,MAAM,aAAa,CAAC;AAElD,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;KACzB,CAAC;IACF,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IACzD,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IACtD,QAAQ,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAcD;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,aAAc;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,eAAe,CAAC;CAC1C,uCAsBG,CAAC"}

package/dist/routing/adapter/tanstack/tanstack.js

@@ -0,0 +1,38 @@
+import { Layer } from 'effect';
+import { Adapter, KEY, keyIn } from '../index.js';
+/** The router TanStack keeps on `window` in a browser. */
+const fromWindow = () => {
+    const router = globalThis.__TSR_ROUTER__;
+    if (!router)
+        throw new Error('[@kestack/kabuki/routing] no TanStack Router on this page: pass `history` to tanstack()');
+    return router.history;
+};
+/**
+ * TanStack Router's history, for an app on a TanStack Start catch-all route:
+ * TanStack hands everything under the app's base to it, and gets back every
+ * URL outside it. Every move goes through TanStack's history, so TanStack
+ * keeps its own count of where Back goes and matches the same route again
+ * without remounting. By default it finds the router TanStack keeps on the
+ * page; `history` hands one over instead.
+ */
+export const tanstack = (options) => Layer.sync(Adapter, () => {
+    const history = (options?.history ?? fromWindow)();
+    return {
+        url: () => `${history.location.pathname}${history.location.search}`,
+        hash: () => decodeURIComponent((history.location.hash ?? '').replace(/^#/, '')),
+        key: () => keyIn(history.location.state),
+        listen: (changed) => history.subscribe(changed),
+        push: (url, key) => history.push(url, { [KEY]: key }),
+        replace: (url, key) => history.replace(url, { [KEY]: key }),
+        go: (by) => history.go(by),
+        // TanStack's history holds this site's URLs alone: another site is
+        // the browser's to go to.
+        leave: (url, options) => {
+            if (new URL(url, location.href).origin !== location.origin)
+                return options?.replace
+                    ? location.replace(url)
+                    : location.assign(url);
+            return options?.replace ? history.replace(url) : history.push(url);
+        },
+    };
+});

package/dist/routing/capability/cache.d.ts

@@ -0,0 +1,12 @@
+import { Layer } from 'effect';
+import { Loading } from './loading.ts';
+import type { RoutesWithPlaces } from './loading.ts';
+/**
+ * A `Loading` that keeps what `inner` loads, for the places of `routes`:
+ * `Router.cached(Routes, loading(Routes))`. `size` copies at most: the
+ * router's `cacheSize` unless said, 50 unless it says.
+ */
+export declare const cached: <E, R>(routes: RoutesWithPlaces, inner: Layer.Layer<Loading, E, R>, options?: {
+    readonly size?: number;
+}) => Layer.Layer<Loading, E, R>;
+//# sourceMappingURL=cache.d.ts.map

package/dist/routing/capability/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/routing/capability/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,EAAU,MAAM,QAAQ,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAU,gBAAgB,EAAU,MAAM,cAAc,CAAC;AAmDrE;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,UACjB,gBAAgB,SACjB,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,YACvB;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACnC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAoLE,CAAC"}

package/dist/routing/capability/cache.js

@@ -0,0 +1,170 @@
+import { Cause, Clock, Deferred, Effect, Layer, Stream } from 'effect';
+import { Loading } from './loading.js';
+/*
+ * The Data cache: the last data each place loaded, one copy per name and
+ * what its Loader is handed, newest wins. It sits in front of another
+ * `Loading` and lives as long as the Layer, so in a browser, as long as the
+ * tab; a server has none.
+ *
+ * 1. Keep    every place loaded, up to `size` copies, each with when it
+ *            arrived; the least recently used goes first, never one for its
+ *            age. A failure is never kept.
+ * 2. Answer  from a copy unless asked `again` or `fresh`: `stale` once it
+ *            is older than its place's Stale time; a static place's never
+ *            is.
+ * 3. Join    a place already being loaded: a click during a preload waits
+ *            for the same answer rather than asking again, and so does the
+ *            load behind a stale copy. A fresh ask, a reload's, joins
+ *            nothing, and an answer is kept only if nothing asked later is,
+ *            and the copies were not dropped since.
+ * 4. Batch   the places asked for in the same moment into one ask of the
+ *            Loading behind, so many places loading at once are one
+ *            request, each answered as it comes. The load runs on its own:
+ *            a place that stops waiting does not stop it, and its answer is
+ *            still kept.
+ * 5. Seed    with the data a server drew the page with, so a page first
+ *            seen from the server is kept as one loaded in the browser is,
+ *            arrived when the server loaded it.
+ *
+ * A preload loads only the places with no fresh copy.
+ */
+/** Asks of one batch, split so no ask names a place twice: answers come back by name. */
+const rounds = (asks) => {
+    const out = [];
+    for (const ask of asks) {
+        const round = out.find((each) => each.every((other) => other.place.name !== ask.place.name));
+        if (round)
+            round.push(ask);
+        else
+            out.push([ask]);
+    }
+    return out;
+};
+const reasonOf = (cause) => {
+    const error = Cause.squash(cause);
+    return error instanceof Error ? error.message : String(error);
+};
+/**
+ * A `Loading` that keeps what `inner` loads, for the places of `routes`:
+ * `Router.cached(Routes, loading(Routes))`. `size` copies at most: the
+ * router's `cacheSize` unless said, 50 unless it says.
+ */
+export const cached = (routes, inner, options) => Layer.effect(Loading, Effect.gen(function* () {
+    const source = yield* Loading;
+    const size = options?.size ?? routes.options?.cacheSize ?? 50;
+    const staleTimes = new Map(routes.every.map((place) => [place.name, place.staleTime]));
+    // 1. Keep
+    const copies = new Map();
+    /** Whether a copy of the place is younger than its Stale time. */
+    const freshOf = (place, copy, now) => now - copy.at < (staleTimes.get(place.name) ?? 0);
+    const flying = new Map();
+    let batch = [];
+    let asked = 0;
+    /** The last ask before the copies were dropped: no answer to one asked by then is kept. */
+    let forgotten = 0;
+    const keyOf = (place) => JSON.stringify([place.name, place.params]);
+    const keep = (key, copy) => {
+        copies.delete(key);
+        copies.set(key, copy);
+        for (const oldest of copies.keys()) {
+            if (copies.size <= size)
+                break;
+            copies.delete(oldest);
+        }
+    };
+    // 4. Batch
+    /** Settles one ask with what its place came to, and keeps its data, unless a newer ask's is kept or the copies were dropped since. */
+    const settle = (ask, outcome) => Effect.flatMap(Clock.currentTimeMillis, (at) => {
+        const { key, answer, seq, since } = ask;
+        if (flying.get(key) === ask)
+            flying.delete(key);
+        if (outcome._tag === 'Loaded' &&
+            seq > forgotten &&
+            seq > (copies.get(key)?.seq ?? 0))
+            keep(key, { data: outcome.data, seq, at });
+        return Deferred.succeed(answer, { ...outcome, at, took: at - since });
+    });
+    /** Asks the Loading behind for a batch, each settled as it comes if it can say so, and any left unanswered broken. */
+    const ask = (asks) => {
+        const places = asks.map(({ place }) => place);
+        const byName = new Map(asks.map((each) => [each.place.name, each]));
+        const answered = source.each
+            ? Stream.runForEach(source.each(places), ([name, outcome]) => {
+                const found = byName.get(name);
+                if (!found)
+                    return Effect.void;
+                byName.delete(name);
+                return settle(found, outcome);
+            })
+            : Effect.flatMap(source.load(places), (answers) => Effect.forEach(asks, (each) => {
+                const outcome = answers[each.place.name];
+                if (!outcome)
+                    return Effect.void;
+                byName.delete(each.place.name);
+                return settle(each, outcome);
+            }));
+        const left = (reason) => Effect.forEach([...byName.values()], (each) => settle(each, { _tag: 'Broken', reason: reason(each.place.name) }));
+        return answered.pipe(Effect.andThen(left((name) => `no answer for ${name}`)), Effect.catchCause((cause) => left(() => reasonOf(cause))));
+    };
+    const flush = Effect.sleep(0).pipe(Effect.andThen(Effect.suspend(() => {
+        const taken = batch;
+        batch = [];
+        return Effect.forEach(rounds(taken), ask, {
+            concurrency: 'unbounded',
+        });
+    })));
+    /**
+     * The place's answer, being loaded: joined if it already is, else
+     * added to the batch. A fresh ask joins nothing: what is on its way
+     * was asked before it.
+     */
+    const loading = (place, fresh = false) => Effect.flatMap(Clock.currentTimeMillis, (since) => {
+        const key = keyOf(place);
+        // 3. Join
+        const going = flying.get(key);
+        if (going && !fresh)
+            return Effect.succeed(going.answer);
+        const answer = Deferred.makeUnsafe();
+        const ask = { key, place, answer, seq: (asked += 1), since };
+        flying.set(key, ask);
+        batch.push(ask);
+        return batch.length === 1
+            ? Effect.as(Effect.forkDetach(flush), answer)
+            : Effect.succeed(answer);
+    });
+    // 2. Answer
+    const one = (place, fresh, again) => Effect.flatMap(Clock.currentTimeMillis, (now) => {
+        const key = keyOf(place);
+        const copy = copies.get(key);
+        if (!fresh && !again && copy) {
+            keep(key, copy);
+            return Effect.succeed({
+                _tag: 'Loaded',
+                data: copy.data,
+                stale: !freshOf(place, copy, now),
+                at: copy.at,
+                cached: true,
+            });
+        }
+        return Effect.flatMap(loading(place, fresh), Deferred.await);
+    });
+    return {
+        load: (places, options) => Effect.forEach(places, (place) => Effect.map(one(place, options?.fresh === true, options?.again === true), (answer) => [place.name, answer]), { concurrency: 'unbounded' }).pipe(Effect.map((answers) => Object.fromEntries(answers))),
+        preload: (places) => Effect.flatMap(Clock.currentTimeMillis, (now) => Effect.forEach(places.filter((place) => {
+            const copy = copies.get(keyOf(place));
+            return !copy || !freshOf(place, copy, now);
+        }), (place) => loading(place), { discard: true })),
+        // 5. Seed
+        keep: (place, data, arrived) => Effect.flatMap(Clock.currentTimeMillis, (now) => Effect.sync(() => {
+            const key = keyOf(place);
+            if (!copies.has(key))
+                keep(key, { data, seq: (asked += 1), at: arrived ?? now });
+        })),
+        // What is on its way was asked before: it is neither joined nor kept.
+        forget: Effect.sync(() => {
+            copies.clear();
+            flying.clear();
+            forgotten = asked;
+        }),
+    };
+})).pipe(Layer.provide(inner));

package/dist/routing/capability/index.d.ts

@@ -0,0 +1,6 @@
+export { Loading, memory, outcomeOf } from './loading.ts';
+export type { Answer, RoutesWithPlaces, Wanted } from './loading.ts';
+export { cached } from './cache.ts';
+export { Navigation, back, backTo, forward, moveOptions, preload, push, reload, replace, } from './navigation.ts';
+export type { AnyRoute, HashScrollOptions, MoveOptions } from './navigation.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/routing/capability/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routing/capability/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,OAAO,EACL,UAAU,EACV,IAAI,EACJ,MAAM,EACN,OAAO,EACP,WAAW,EACX,OAAO,EACP,IAAI,EACJ,MAAM,EACN,OAAO,GACR,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,QAAQ,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/routing/capability/index.js

@@ -0,0 +1,3 @@
+export { Loading, memory, outcomeOf } from './loading.js';
+export { cached } from './cache.js';
+export { Navigation, back, backTo, forward, moveOptions, preload, push, reload, replace, } from './navigation.js';