@kestack/web-platform 0.0.0-stage → 0.0.1

package/dist/app/apis/apis.d.ts

@@ -0,0 +1,55 @@
+import { Effect, Layer } from "effect";
+import { Rpc, RpcClient, RpcClientError, RpcGroup } from "effect/rpc";
+//#region src/app/apis/apis.d.ts
+/** How an API is reached on the cloud Backend. On the device Backend every
+ * API is called in this process, whatever its Transport. */
+export type Transport = 'http' | 'websocket';
+/** One of an app's APIs: a group and the Transport it is reached by. */
+export interface Api<Rpcs extends Rpc.Any = Rpc.Any> {
+  readonly group: RpcGroup.RpcGroup<Rpcs>;
+  readonly transport: Transport;
+  /** A path, resolved against the cloud address the Host knows, or a
+   * full URL, left alone. */
+  readonly path: string;
+}
+/**
+ * Declares an app's APIs, each by the Transport it is reached by:
+ * `Api.http(LedgerApi, { path: '/rpc' })` (POST, NDJSON, batched) or
+ * `Api.websocket(ChatApi, { path: '/rpc/chat' })`. Name them in one object;
+ * the names are how the Session and screens reach each one.
+ */
+export declare const Api: {
+  http: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options: {
+    readonly path: string;
+  }) => Api<Rpcs>;
+  websocket: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options: {
+    readonly path: string;
+  }) => Api<Rpcs>;
+};
+/** An app's APIs, by the names it gives them. A group is invariant in its
+ * calls, so any group's Api fits only as `Api<any>`. */
+export type Apis = Readonly<Record<string, Api<any>>>;
+/** The calls of one API. */
+export type RpcsOf<A> = A extends Api<infer Rpcs> ? Rpcs : never;
+/** An API's client: one Effect per call. */
+export type ApiClient<Rpcs extends Rpc.Any> = RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError>;
+/** Every API's client, by name. */
+export type ApiClients<A extends Apis> = { readonly [K in keyof A]: ApiClient<RpcsOf<A[K]>>; };
+/** One API's handlers, with everything they stand on, run on the device. */
+export type DeviceBackend<Rpcs extends Rpc.Any> = Layer.Layer<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>, unknown>;
+/** The device Backend: every API's handlers, by the same names. An app
+ * with a device Backend has one for every API, or the device Backend would
+ * be half real. */
+export type DeviceBackends<A extends Apis> = { readonly [K in keyof A]: DeviceBackend<RpcsOf<A[K]>>; };
+/** `path` against `base`; a full URL stays as it is. */
+export declare const resolve: (path: string, base: string) => string;
+/** How a call reaches one API on the cloud Backend. A call carries its
+ * Account's token and never a cookie, which names whoever is active in the
+ * browser. A WebSocket also opens with the token `token` gives at each
+ * connect, in its address, as a browser sets no headers on one: that is how
+ * the cloud knows whose it is before any call. */
+export declare const cloudProtocol: ({ group, transport, path }: Apis[string], base: string, token?: Effect.Effect<string> | null) => Layer.Layer<RpcClient.Protocol>;
+/** How a call reaches one API's handlers in this process. */
+export declare const deviceProtocol: ({ group }: Apis[string], handlers: DeviceBackend<Rpc.Any>) => Layer.Layer<RpcClient.Protocol>;
+//#endregion
+//# sourceMappingURL=apis.d.ts.map

package/dist/app/apis/apis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apis.d.ts","names":["EffectRpc"],"sources":["../../../src/app/apis/apis.ts"],"mappings":";;;;;YAWY;;iBAGK,IAAI,aAAaA,IAAU,MAAMA,IAAU;WACjD,OAAO,SAAS,SAAS;WACzB,WAAW;;;WAGX;;;;;;;;qBAgBE;EAAQ,OAXlB,aAAaA,IAAU,KAAG,OAClB,SAAS,SAAS,OAAK;aACV;QACnB,IAAI;EAQ+B,YAAS,aAAAA,IAAA,KAAA,OAAA,SAAA,SAAA,OAAA;;;;;;YAKrC,OAAO,SAAS,eAAe;;YAG/B,OAAO,KAAK,UAAU,UAAU,QAAQ;;YAGxC,UAAU,aAAaA,IAAU,OAAO,UAAU,UAC5D,MACA,eAAe;;YAIL,WAAW,UAAU,oBACrB,WAAW,IAAI,UAAU,OAAO,EAAE;;YAIlC,cAAc,aAAaA,IAAU,OAAO,MAAM,MAC5DA,IAAU,UAAU,QAAQA,IAAU,WAAW;;;;YAOvC,eAAe,UAAU,oBACzB,WAAW,IAAI,cAAc,OAAO,EAAE;;qBAIrC,UAAO,cAAgB;;;;;;qBAkBvB,kBAAa,OAAA,WAAA,QACI,cAAY,cAC5B,QACL,OAAO,0BACb,MAAM,MAAM,UAAU;;qBAUZ,mBAAc,SACd,cAAY,UACb,cAAcA,IAAU,SACjC,MAAM,MAAM,UAAU"}

package/dist/app/apis/apis.js

@@ -0,0 +1,43 @@
+import { Effect, Layer } from "effect";
+import { Rpc } from "@kestack/rpc-toolkit/rpc";
+//#region src/app/apis/apis.ts
+const api = (transport) => (group, options) => ({
+	group,
+	transport,
+	path: options.path
+});
+/**
+* Declares an app's APIs, each by the Transport it is reached by:
+* `Api.http(LedgerApi, { path: '/rpc' })` (POST, NDJSON, batched) or
+* `Api.websocket(ChatApi, { path: '/rpc/chat' })`. Name them in one object;
+* the names are how the Session and screens reach each one.
+*/
+const Api = {
+	http: api("http"),
+	websocket: api("websocket")
+};
+/** `path` against `base`; a full URL stays as it is. */
+const resolve = (path, base) => /^[a-z][a-z0-9+.-]*:\/\//i.test(path) ? path : `${base.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+const signedUrl = (url, token) => Effect.map(token, (current) => {
+	const signed = new URL(url);
+	signed.searchParams.set("access_token", current);
+	return signed.href;
+});
+/** How a call reaches one API on the cloud Backend. A call carries its
+* Account's token and never a cookie, which names whoever is active in the
+* browser. A WebSocket also opens with the token `token` gives at each
+* connect, in its address, as a browser sets no headers on one: that is how
+* the cloud knows whose it is before any call. */
+const cloudProtocol = ({ group, transport, path }, base, token = null) => {
+	const url = resolve(path, base);
+	return transport === "http" ? Rpc.http.client(group, {
+		url,
+		credentials: "omit"
+	}) : Rpc.websocket.client(group, { url: token === null ? url : signedUrl(url, token) });
+};
+/** How a call reaches one API's handlers in this process. */
+const deviceProtocol = ({ group }, handlers) => Rpc.inProcess.client(group, handlers).pipe(Layer.orDie);
+//#endregion
+export { Api, cloudProtocol, deviceProtocol, resolve };
+
+//# sourceMappingURL=apis.js.map

package/dist/app/apis/apis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apis.js","names":[],"sources":["../../../src/app/apis/apis.ts"],"sourcesContent":["import { Effect, Layer } from 'effect';\nimport type {\n  Rpc as EffectRpc,\n  RpcClient,\n  RpcClientError,\n  RpcGroup,\n} from 'effect/rpc';\nimport { Rpc } from '@kestack/rpc-toolkit/rpc';\n\n/** How an API is reached on the cloud Backend. On the device Backend every\n * API is called in this process, whatever its Transport. */\nexport type Transport = 'http' | 'websocket';\n\n/** One of an app's APIs: a group and the Transport it is reached by. */\nexport interface Api<Rpcs extends EffectRpc.Any = EffectRpc.Any> {\n  readonly group: RpcGroup.RpcGroup<Rpcs>;\n  readonly transport: Transport;\n  /** A path, resolved against the cloud address the Host knows, or a\n   * full URL, left alone. */\n  readonly path: string;\n}\n\nconst api =\n  (transport: Transport) =>\n  <Rpcs extends EffectRpc.Any>(\n    group: RpcGroup.RpcGroup<Rpcs>,\n    options: { readonly path: string },\n  ): Api<Rpcs> => ({ group, transport, path: options.path });\n\n/**\n * Declares an app's APIs, each by the Transport it is reached by:\n * `Api.http(LedgerApi, { path: '/rpc' })` (POST, NDJSON, batched) or\n * `Api.websocket(ChatApi, { path: '/rpc/chat' })`. Name them in one object;\n * the names are how the Session and screens reach each one.\n */\nexport const Api = { http: api('http'), websocket: api('websocket') };\n\n/** An app's APIs, by the names it gives them. A group is invariant in its\n * calls, so any group's Api fits only as `Api<any>`. */\n// oxlint-disable-next-line no-explicit-any\nexport type Apis = Readonly<Record<string, Api<any>>>;\n\n/** The calls of one API. */\nexport type RpcsOf<A> = A extends Api<infer Rpcs> ? Rpcs : never;\n\n/** An API's client: one Effect per call. */\nexport type ApiClient<Rpcs extends EffectRpc.Any> = RpcClient.RpcClient<\n  Rpcs,\n  RpcClientError.RpcClientError\n>;\n\n/** Every API's client, by name. */\nexport type ApiClients<A extends Apis> = {\n  readonly [K in keyof A]: ApiClient<RpcsOf<A[K]>>;\n};\n\n/** One API's handlers, with everything they stand on, run on the device. */\nexport type DeviceBackend<Rpcs extends EffectRpc.Any> = Layer.Layer<\n  EffectRpc.ToHandler<Rpcs> | EffectRpc.Middleware<Rpcs>,\n  unknown\n>;\n\n/** The device Backend: every API's handlers, by the same names. An app\n * with a device Backend has one for every API, or the device Backend would\n * be half real. */\nexport type DeviceBackends<A extends Apis> = {\n  readonly [K in keyof A]: DeviceBackend<RpcsOf<A[K]>>;\n};\n\n/** `path` against `base`; a full URL stays as it is. */\nexport const resolve = (path: string, base: string) =>\n  /^[a-z][a-z0-9+.-]*:\\/\\//i.test(path)\n    ? path\n    : `${base.replace(/\\/$/, '')}/${path.replace(/^\\//, '')}`;\n\n// `url` with the token `token` gives as its `access_token`.\nconst signedUrl = (url: string, token: Effect.Effect<string>) =>\n  Effect.map(token, (current) => {\n    const signed = new URL(url);\n    signed.searchParams.set('access_token', current);\n    return signed.href;\n  });\n\n/** How a call reaches one API on the cloud Backend. A call carries its\n * Account's token and never a cookie, which names whoever is active in the\n * browser. A WebSocket also opens with the token `token` gives at each\n * connect, in its address, as a browser sets no headers on one: that is how\n * the cloud knows whose it is before any call. */\nexport const cloudProtocol = (\n  { group, transport, path }: Apis[string],\n  base: string,\n  token: Effect.Effect<string> | null = null,\n): Layer.Layer<RpcClient.Protocol> => {\n  const url = resolve(path, base);\n  return transport === 'http'\n    ? Rpc.http.client(group, { url, credentials: 'omit' })\n    : (Rpc.websocket.client(group, {\n        url: token === null ? url : signedUrl(url, token),\n      }) as Layer.Layer<RpcClient.Protocol, never, never>);\n};\n\n/** How a call reaches one API's handlers in this process. */\nexport const deviceProtocol = (\n  { group }: Apis[string],\n  handlers: DeviceBackend<EffectRpc.Any>,\n): Layer.Layer<RpcClient.Protocol> =>\n  Rpc.inProcess\n    .client(group, handlers as never)\n    .pipe(Layer.orDie) as Layer.Layer<RpcClient.Protocol>;\n"],"mappings":";;;AAsBA,MAAM,OACH,eAEC,OACA,aACe;CAAE;CAAO;CAAW,MAAM,QAAQ;AAAK;;;;;;;AAQ1D,MAAa,MAAM;CAAE,MAAM,IAAI,MAAM;CAAG,WAAW,IAAI,WAAW;AAAE;;AAmCpE,MAAa,WAAW,MAAc,SACpC,2BAA2B,KAAK,IAAI,IAChC,OACA,GAAG,KAAK,QAAQ,OAAO,EAAE,EAAE,GAAG,KAAK,QAAQ,OAAO,EAAE;AAG1D,MAAM,aAAa,KAAa,UAC9B,OAAO,IAAI,QAAQ,YAAY;CAC7B,MAAM,SAAS,IAAI,IAAI,GAAG;CAC1B,OAAO,aAAa,IAAI,gBAAgB,OAAO;CAC/C,OAAO,OAAO;AAChB,CAAC;;;;;;AAOH,MAAa,iBACX,EAAE,OAAO,WAAW,QACpB,MACA,QAAsC,SACF;CACpC,MAAM,MAAM,QAAQ,MAAM,IAAI;CAC9B,OAAO,cAAc,SACjB,IAAI,KAAK,OAAO,OAAO;EAAE;EAAK,aAAa;CAAO,CAAC,IAClD,IAAI,UAAU,OAAO,OAAO,EAC3B,KAAK,UAAU,OAAO,MAAM,UAAU,KAAK,KAAK,EAClD,CAAC;AACP;;AAGA,MAAa,kBACX,EAAE,SACF,aAEA,IAAI,UACD,OAAO,OAAO,QAAiB,CAAC,CAChC,KAAK,MAAM,KAAK"}

package/dist/app/apis/index.d.ts

@@ -0,0 +1,2 @@
+import { Api, ApiClient, ApiClients, Apis, DeviceBackend, DeviceBackends, RpcsOf, Transport, cloudProtocol, deviceProtocol, resolve } from "./apis.js";
+export { Api, type ApiClient, type ApiClients, type Apis, type DeviceBackend, type DeviceBackends, type RpcsOf, type Transport, cloudProtocol, deviceProtocol, resolve };

package/dist/app/apis/index.js

@@ -0,0 +1,2 @@
+import { Api, cloudProtocol, deviceProtocol, resolve } from "./apis.js";
+export { Api, cloudProtocol, deviceProtocol, resolve };

package/dist/app/app.d.ts

@@ -0,0 +1,77 @@
+import { Apis, DeviceBackends } from "./apis/apis.js";
+import "./apis/index.js";
+import { Storage } from "./host/host.js";
+import "./host/index.js";
+import { SessionDef } from "./session/define.js";
+import "./session/index.js";
+import { AuthApp, PublicApp } from "./assemble/assemble.js";
+import "./assemble/index.js";
+import { createTheme } from "../theme/theme.js";
+import { WebRootOptions, webRoot } from "../client/root/root.js";
+import "../client/index.js";
+import { LocalSignInChoice } from "../recipes/local-sign-in/local-sign-in.js";
+import { ReactNode } from "react";
+//#region src/app/app.d.ts
+/** Signing in, for an app that has Accounts. */
+export interface WebAuth<A extends Apis, S> {
+  /** The shared sign-in service. */
+  readonly url: string;
+  /** What one Account keeps while it is active. */
+  readonly session?: SessionDef<A, S>;
+  /** Who to try the device Backend as, in one tap. */
+  readonly presets?: ReadonlyArray<LocalSignInChoice>;
+}
+/** What a web app gives `createApp`. Everything else is given: the Theme,
+ * the PWA, the screens before an Account is open. */
+export interface WebAppConfig<A extends Apis, S, C> {
+  /** Names what the app keeps on the device and tells its other tabs. */
+  readonly name: string;
+  /** The app's name, as people read it: every page's title. */
+  readonly title: string;
+  /** One line on what the app is for, under its name before sign-in. */
+  readonly description?: string;
+  /** The app's mark, above its name before sign-in. */
+  readonly mark?: ReactNode;
+  readonly apis?: A;
+  /** The device Backend: every API's handlers on the device's Storage. */
+  readonly device?: (storage: Storage) => DeviceBackends<A> | Promise<DeviceBackends<A>>;
+  readonly auth?: WebAuth<A, S>;
+  /** What only this device keeps, such as Settings. */
+  readonly cache?: (storage: Storage) => C;
+  /** The Theme's cookie is shared by every app under `cookieDomain`. */
+  readonly theme?: {
+    readonly cookieDomain?: string | undefined;
+  };
+  /** The PWA is always on; this says how it asks to be installed. */
+  readonly pwa?: {
+    readonly installTitle?: string;
+  };
+}
+/** What `root` takes from the root route's file. */
+export type RootOptions = Pick<WebRootOptions, 'stylesheet' | 'icon' | 'loadTheme' | 'notFound'>;
+/**
+ * A web app: a PWA on TanStack Start in the app's Theme, with its APIs on
+ * the cloud Backend at this origin or on the device Backend in the page,
+ * and, with `auth`, several Accounts signed in on this device, one Session
+ * each. `root` is the root route; `SignedIn` wraps what needs an Account
+ * and shows the right screen otherwise. Make one per app, in `app.ts`.
+ */
+export declare function createApp<A extends Apis, S, C = never>(config: WebAppConfig<A, S, C> & {
+  readonly auth: WebAuth<A, S>;
+}): WebAuthApp<A, S, C>;
+export declare function createApp<A extends Apis, C = never>(config: WebAppConfig<A, never, C> & {
+  readonly auth?: undefined;
+}): WebPublicApp<A, C>;
+/** A web app with Accounts, as `createApp` makes it. */
+export type WebAuthApp<A extends Apis, S, C> = AuthApp<A, S, C> & {
+  readonly theme: ReturnType<typeof createTheme>;
+  /** The root route: pass it to `createRootRoute`. */
+  readonly root: (options: RootOptions) => ReturnType<typeof webRoot>;
+};
+/** A web app with no Accounts, as `createApp` makes it. */
+export type WebPublicApp<A extends Apis, C> = PublicApp<A, C> & {
+  readonly theme: ReturnType<typeof createTheme>;
+  readonly root: (options: RootOptions) => ReturnType<typeof webRoot>;
+};
+//#endregion
+//# sourceMappingURL=app.d.ts.map

package/dist/app/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","names":[],"sources":["../../src/app/app.tsx"],"mappings":";;;;;;;;;;;;;;;iBA0BiB,QAAQ,UAAU,MAAM;;WAE9B;;WAEA,UAAU,WAAW,GAAG;;WAExB,UAAU,cAAc;;;;iBAKlB,aAAa,UAAU,MAAM,GAAG;;WAEtC;;WAEA;;WAEA;;WAEA,OAAO;WACP,OAAO;;WAEP,UACP,SAAS,YACN,eAAe,KAAK,QAAQ,eAAe;WACvC,OAAO,QAAQ,GAAG;;WAElB,SAAS,SAAS,YAAY;;WAE9B;aAAmB;;;WAEnB;aAAiB;;;;YAIhB,cAAc,KACxB;;;;;;;;wBA4Bc,UAAU,UAAU,MAAM,GAAG,WAC3C,QAAQ,aAAa,GAAG,GAAG;WAAgB,MAAM,QAAQ,GAAG;IAC3D,WAAW,GAAG,GAAG;wBACJ,UAAU,UAAU,MAAM,WACxC,QAAQ,aAAa,UAAU;WAAgB;IAC9C,aAAa,GAAG;;YA8HP,WAAW,UAAU,MAAM,GAAG,KAAK,QAAQ,GAAG,GAAG;WAClD,OAAO,kBAAkB;;WAEzB,OAAO,SAAS,gBAAgB,kBAAkB;;;YAIjD,aAAa,UAAU,MAAM,KAAK,UAAU,GAAG;WAChD,OAAO,kBAAkB;WACzB,OAAO,SAAS,gBAAgB,kBAAkB"}

package/dist/app/app.js

@@ -0,0 +1,118 @@
+import { createApp as createApp$1 } from "./assemble/assemble.js";
+import { webRoot } from "../client/root/root.js";
+import { pwaRoot } from "../pwa/root/root.js";
+import { AccountLost } from "../recipes/account-lost/account-lost.js";
+import { GateScreens } from "../recipes/gate-screens/gate-screens.js";
+import { LocalSignIn } from "../recipes/local-sign-in/local-sign-in.js";
+import { createTheme } from "../theme/theme.js";
+import { webHost } from "./web-host.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/app/app.tsx
+const screenOf = (view) => {
+	switch (view.kind) {
+		case "checking":
+		case "signingOut": return { kind: view.kind };
+		case "opening":
+		case "unopenable": return {
+			kind: view.kind,
+			name: view.account.user.name
+		};
+		case "signedOut": return {
+			kind: "signedOut",
+			unreachable: view.unreachable
+		};
+	}
+};
+function createApp(config) {
+	const theme = createTheme(config.theme?.cookieDomain === void 0 ? {} : { cookieDomain: config.theme.cookieDomain });
+	const host = () => webHost({
+		name: config.name,
+		authUrl: config.auth?.url
+	});
+	const parts = {
+		host,
+		...config.apis !== void 0 && { apis: config.apis },
+		...config.device !== void 0 && { device: config.device },
+		...config.cache !== void 0 && { cache: config.cache }
+	};
+	const pwa = pwaRoot(config.pwa?.installTitle === void 0 ? {} : { installTitle: config.pwa.installTitle });
+	const rootOf = (plugins) => (options) => webRoot({
+		title: config.title,
+		theme,
+		plugins,
+		...options
+	});
+	if (config.auth === void 0) return {
+		...createApp$1(parts),
+		theme,
+		root: rootOf([pwa])
+	};
+	const { auth } = config;
+	const app = createApp$1({
+		...parts,
+		host,
+		auth: auth.session === void 0 ? {} : { session: auth.session }
+	});
+	const named = { Provider: (props) => {
+		const { asking, answer } = app.useGate().namedSignIn;
+		return /* @__PURE__ */ jsxs(Fragment, { children: [props.children, /* @__PURE__ */ jsx(LocalSignIn, {
+			open: asking,
+			presets: auth.presets ?? [],
+			onChoose: answer,
+			onCancel: () => answer(null)
+		})] });
+	} };
+	/** The screen for whatever stands before an open Account. */
+	function GateFallback(props) {
+		const gate = app.useGate();
+		const { theme: shown } = theme.useTheme();
+		const notice = gate.notice;
+		const view = props.view;
+		if (view.kind === "accountLost") return /* @__PURE__ */ jsx(AccountLost, {
+			lost: view.account.user,
+			others: view.accounts.map(({ user }) => user),
+			onSignInAgain: () => void gate.signIn(),
+			onSwitch: gate.switchTo,
+			onSignOut: () => void gate.signOut()
+		});
+		return /* @__PURE__ */ jsx(GateScreens, {
+			title: config.title,
+			...config.description !== void 0 && { description: config.description },
+			mark: config.mark,
+			statusBar: /* @__PURE__ */ jsx(theme.StatusBar, {}),
+			theme: shown,
+			screen: screenOf(view),
+			backend: gate.backend,
+			hasDevice: config.device !== void 0,
+			loginError: notice?.kind === "loginError" ? notice.error.description ?? "Sign in didn’t finish. Try again." : null,
+			onLoginErrorShown: gate.dismissNotice,
+			onSignIn: gate.signIn,
+			onCheckAgain: gate.checkAgain,
+			onRetry: gate.retry,
+			onSignOut: () => void gate.signOut(),
+			onBackend: (backend) => void gate.setBackend(backend)
+		});
+	}
+	/**
+	* Renders `children` while an Account is open, and otherwise the screen
+	* for where sign-in stands, unless `fallback` says otherwise.
+	* Everything inside remounts on an Account Switch, so wrap as little as
+	* the part that needs an Account.
+	*/
+	function SignedIn(props) {
+		return /* @__PURE__ */ jsx(app.SignedIn, {
+			fallback: props.fallback ?? ((view) => /* @__PURE__ */ jsx(GateFallback, { view })),
+			children: props.children
+		});
+	}
+	return {
+		...app,
+		SignedIn,
+		theme,
+		root: rootOf(config.device === void 0 ? [pwa] : [pwa, named])
+	};
+}
+//#endregion
+export { createApp };
+
+//# sourceMappingURL=app.js.map

package/dist/app/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","names":["assemble"],"sources":["../../src/app/app.tsx"],"sourcesContent":["import { type Apis, type DeviceBackends } from './apis/index.ts';\nimport {\n  type AuthApp,\n  createApp as assemble,\n  type PublicApp,\n} from './assemble/index.ts';\nimport { type GateView } from './gate/index.ts';\nimport { type SessionDef } from './session/index.ts';\nimport { type Storage } from './host/index.ts';\nimport type { ReactNode } from 'react';\nimport {\n  type RootPlugin,\n  webRoot,\n  type WebRootOptions,\n} from '../client/index.ts';\nimport { pwaRoot } from '../pwa/index.ts';\nimport { AccountLost } from '../recipes/account-lost/index.ts';\nimport { type GateScreen, GateScreens } from '../recipes/gate-screens/index.ts';\nimport {\n  LocalSignIn,\n  type LocalSignInChoice,\n} from '../recipes/local-sign-in/index.ts';\nimport { createTheme } from '../theme/index.ts';\nimport { webHost } from './web-host.ts';\n\n/** Signing in, for an app that has Accounts. */\nexport interface WebAuth<A extends Apis, S> {\n  /** The shared sign-in service. */\n  readonly url: string;\n  /** What one Account keeps while it is active. */\n  readonly session?: SessionDef<A, S>;\n  /** Who to try the device Backend as, in one tap. */\n  readonly presets?: ReadonlyArray<LocalSignInChoice>;\n}\n\n/** What a web app gives `createApp`. Everything else is given: the Theme,\n * the PWA, the screens before an Account is open. */\nexport interface WebAppConfig<A extends Apis, S, C> {\n  /** Names what the app keeps on the device and tells its other tabs. */\n  readonly name: string;\n  /** The app's name, as people read it: every page's title. */\n  readonly title: string;\n  /** One line on what the app is for, under its name before sign-in. */\n  readonly description?: string;\n  /** The app's mark, above its name before sign-in. */\n  readonly mark?: ReactNode;\n  readonly apis?: A;\n  /** The device Backend: every API's handlers on the device's Storage. */\n  readonly device?: (\n    storage: Storage,\n  ) => DeviceBackends<A> | Promise<DeviceBackends<A>>;\n  readonly auth?: WebAuth<A, S>;\n  /** What only this device keeps, such as Settings. */\n  readonly cache?: (storage: Storage) => C;\n  /** The Theme's cookie is shared by every app under `cookieDomain`. */\n  readonly theme?: { readonly cookieDomain?: string | undefined };\n  /** The PWA is always on; this says how it asks to be installed. */\n  readonly pwa?: { readonly installTitle?: string };\n}\n\n/** What `root` takes from the root route's file. */\nexport type RootOptions = Pick<\n  WebRootOptions,\n  'stylesheet' | 'icon' | 'loadTheme' | 'notFound'\n>;\n\ntype NotOpen<S> = Exclude<GateView<S>, { kind: 'open' }>;\n\nconst screenOf = (\n  view: Exclude<NotOpen<unknown>, { kind: 'accountLost' }>,\n): GateScreen => {\n  switch (view.kind) {\n    case 'checking':\n    case 'signingOut':\n      return { kind: view.kind };\n    case 'opening':\n    case 'unopenable':\n      return { kind: view.kind, name: view.account.user.name };\n    case 'signedOut':\n      return { kind: 'signedOut', unreachable: view.unreachable };\n  }\n};\n\n/**\n * A web app: a PWA on TanStack Start in the app's Theme, with its APIs on\n * the cloud Backend at this origin or on the device Backend in the page,\n * and, with `auth`, several Accounts signed in on this device, one Session\n * each. `root` is the root route; `SignedIn` wraps what needs an Account\n * and shows the right screen otherwise. Make one per app, in `app.ts`.\n */\nexport function createApp<A extends Apis, S, C = never>(\n  config: WebAppConfig<A, S, C> & { readonly auth: WebAuth<A, S> },\n): WebAuthApp<A, S, C>;\nexport function createApp<A extends Apis, C = never>(\n  config: WebAppConfig<A, never, C> & { readonly auth?: undefined },\n): WebPublicApp<A, C>;\nexport function createApp<A extends Apis, S, C>(\n  config: WebAppConfig<A, S, C>,\n): WebAuthApp<A, S, C> | WebPublicApp<A, C> {\n  const theme = createTheme(\n    config.theme?.cookieDomain === undefined\n      ? {}\n      : { cookieDomain: config.theme.cookieDomain },\n  );\n  const host = () => webHost({ name: config.name, authUrl: config.auth?.url });\n  const parts = {\n    host,\n    ...(config.apis !== undefined && { apis: config.apis }),\n    ...(config.device !== undefined && { device: config.device }),\n    ...(config.cache !== undefined && { cache: config.cache }),\n  };\n  const pwa = pwaRoot(\n    config.pwa?.installTitle === undefined\n      ? {}\n      : { installTitle: config.pwa.installTitle },\n  );\n  const rootOf =\n    (plugins: ReadonlyArray<RootPlugin>) => (options: RootOptions) =>\n      webRoot({ title: config.title, theme, plugins, ...options });\n\n  if (config.auth === undefined) {\n    const app = assemble(parts as never) as unknown as PublicApp<A, C>;\n    return { ...app, theme, root: rootOf([pwa]) };\n  }\n\n  const { auth } = config;\n  const app = assemble({\n    ...(parts as object),\n    host,\n    auth: auth.session === undefined ? {} : { session: auth.session },\n  } as never) as AuthApp<A, S, C>;\n\n  // Asks who signs in to the device Backend, wherever the app is.\n  const named: RootPlugin = {\n    Provider: (props: { readonly children: ReactNode }) => {\n      const { asking, answer } = app.useGate().namedSignIn;\n      return (\n        <>\n          {props.children}\n          <LocalSignIn\n            open={asking}\n            presets={auth.presets ?? []}\n            onChoose={answer}\n            onCancel={() => answer(null)}\n          />\n        </>\n      );\n    },\n  };\n\n  /** The screen for whatever stands before an open Account. */\n  function GateFallback(props: { readonly view: NotOpen<S> }) {\n    const gate = app.useGate();\n    const { theme: shown } = theme.useTheme();\n    const notice = gate.notice;\n    const view = props.view as NotOpen<unknown>;\n    if (view.kind === 'accountLost')\n      return (\n        <AccountLost\n          lost={view.account.user}\n          others={view.accounts.map(({ user }) => user)}\n          onSignInAgain={() => void gate.signIn()}\n          onSwitch={gate.switchTo}\n          onSignOut={() => void gate.signOut()}\n        />\n      );\n    return (\n      <GateScreens\n        title={config.title}\n        {...(config.description !== undefined && {\n          description: config.description,\n        })}\n        mark={config.mark}\n        statusBar={<theme.StatusBar />}\n        theme={shown}\n        screen={screenOf(view)}\n        backend={gate.backend}\n        hasDevice={config.device !== undefined}\n        loginError={\n          notice?.kind === 'loginError'\n            ? (notice.error.description ?? 'Sign in didn’t finish. Try again.')\n            : null\n        }\n        onLoginErrorShown={gate.dismissNotice}\n        onSignIn={gate.signIn}\n        onCheckAgain={gate.checkAgain}\n        onRetry={gate.retry}\n        onSignOut={() => void gate.signOut()}\n        onBackend={(backend) => void gate.setBackend(backend)}\n      />\n    );\n  }\n\n  /**\n   * Renders `children` while an Account is open, and otherwise the screen\n   * for where sign-in stands, unless `fallback` says otherwise.\n   * Everything inside remounts on an Account Switch, so wrap as little as\n   * the part that needs an Account.\n   */\n  function SignedIn(props: {\n    readonly children: ReactNode;\n    readonly fallback?: ReactNode | ((view: NotOpen<S>) => ReactNode);\n  }) {\n    return (\n      <app.SignedIn\n        fallback={props.fallback ?? ((view) => <GateFallback view={view} />)}\n      >\n        {props.children}\n      </app.SignedIn>\n    );\n  }\n\n  return {\n    ...app,\n    SignedIn,\n    theme,\n    root: rootOf(config.device === undefined ? [pwa] : [pwa, named]),\n  };\n}\n\n/** A web app with Accounts, as `createApp` makes it. */\nexport type WebAuthApp<A extends Apis, S, C> = AuthApp<A, S, C> & {\n  readonly theme: ReturnType<typeof createTheme>;\n  /** The root route: pass it to `createRootRoute`. */\n  readonly root: (options: RootOptions) => ReturnType<typeof webRoot>;\n};\n\n/** A web app with no Accounts, as `createApp` makes it. */\nexport type WebPublicApp<A extends Apis, C> = PublicApp<A, C> & {\n  readonly theme: ReturnType<typeof createTheme>;\n  readonly root: (options: RootOptions) => ReturnType<typeof webRoot>;\n};\n"],"mappings":"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"}

package/dist/app/assemble/assemble.d.ts

@@ -0,0 +1,167 @@
+import { ApiClients, Apis, DeviceBackends } from "../apis/apis.js";
+import "../apis/index.js";
+import { Backend, Host, Storage } from "../host/host.js";
+import "../host/index.js";
+import { Opened } from "../session/open.js";
+import { useOpenedStatus } from "../session/react.js";
+import { Run, SessionDef, SessionOf } from "../session/define.js";
+import "../session/index.js";
+import { GateNotice, GateView } from "../gate/domain/types.js";
+import "../gate/index.js";
+import "../index.js";
+import { Context, Effect, Layer } from "effect";
+import { ReactNode } from "react";
+import { RpcClient } from "effect/rpc";
+//#region src/app/assemble/assemble.d.ts
+/** What an app with auth gives: what one Account keeps while it is
+ * active. Without a Session, `SignedIn` still works and every API is still
+ * signed; there is just nothing of the app's own to keep. */
+export interface AuthConfig<A extends Apis, S> {
+  readonly session?: SessionDef<A, S>;
+}
+/** What an app gives `createApp`, each part switching on only what needs
+ * it. */
+export interface AppConfig<A extends Apis, S, C> {
+  /** Where the app runs, made the first time anything asks. */
+  readonly host: () => Host;
+  /** The app's APIs, by name. */
+  readonly apis?: A;
+  /** The device Backend: every API's handlers, run in the app on the
+   * device's own Storage, or what loads them the first time it is chosen.
+   * Without it, the app has only the cloud Backend. */
+  readonly device?: (storage: Storage) => DeviceBackends<A> | Promise<DeviceBackends<A>>;
+  /** Signing in: several Accounts on this device, one open at a time, each
+   * with its own Session. Without it, the app has no Accounts. */
+  readonly auth?: AuthConfig<A, S>;
+  /** What only this device keeps and belongs to no user, such as Settings,
+   * opened on first use. */
+  readonly cache?: (storage: Storage) => C;
+}
+type NotOpen<S> = Exclude<GateView<S>, {
+  kind: 'open';
+}>;
+/** An app's parts with no Accounts: its APIs and its cache. */
+declare const makeCore: <A extends Apis, C>(config: Pick<AppConfig<A, unknown, C>, 'host' | 'apis' | 'device' | 'cache'>) => {
+  host: () => Host;
+  apis: A;
+  hasDevice: boolean;
+  cloudProtocols: (token?: Effect.Effect<string> | null) => {
+    [k: string]: Layer.Layer<RpcClient.Protocol, never, never>;
+  };
+  deviceProtocols: () => Promise<{
+    [k: string]: Layer.Layer<RpcClient.Protocol, never, never>;
+  }>;
+  protocolOf: (backend: Backend, name: string) => Promise<Layer.Layer<RpcClient.Protocol, never, never>>;
+  cache: () => C;
+};
+/**
+ * An app on any platform. Nothing runs until a screen first asks, so it
+ * can be made where the Host is not there yet, as on a web server. With
+ * `auth`, it runs sign-in on this device on the cloud or the device
+ * Backend, and opens one Session per active Account, with every API signed
+ * as them and a Std Sync named for them; the app's Session says what that
+ * Session holds, this says when. Make one per app. The Web Platform's
+ * `createApp` calls it with the browser's Host; tests call it with one in
+ * memory.
+ */
+export declare function createApp<A extends Apis, S, C = never>(config: AppConfig<A, S, C> & {
+  readonly auth: AuthConfig<A, S>;
+}): AuthApp<A, S, C>;
+export declare function createApp<A extends Apis, C = never>(config: AppConfig<A, never, C> & {
+  readonly auth?: undefined;
+}): PublicApp<A, C>;
+declare const publicApp: <A extends Apis, C>(core: ReturnType<typeof makeCore<A, C>>) => {
+  /** Where the app runs. */
+  host: () => Host;
+  /** This device's cache, opened on first use. */
+  cache: () => C;
+  /** One API's client. */
+  useApi: <K extends keyof A & string>(name: K) => ApiClients<A>[K];
+  /** The Backend the app runs on, and changing it. */
+  useBackend: () => {
+    backend: "cloud" | "device";
+    setBackend: (next: Backend) => void;
+  };
+};
+/** An app with no Accounts, as `createApp` makes it. */
+export type PublicApp<A extends Apis, C> = ReturnType<typeof publicApp<A, C>>;
+declare const authApp: <A extends Apis, S, C>(core: ReturnType<typeof makeCore<A, C>>, auth: AuthConfig<A, S>) => {
+  /** Where the app runs. */
+  host: () => Host;
+  /** The Gate itself, outside React: for tests and non-React code. */
+  gate: {
+    subscribe: (changed: () => void) => () => undefined;
+    view: () => GateView<Opened<S>>;
+    backend: () => Backend | null;
+    online: () => boolean;
+    onOnlineChange: (changed: () => void) => () => void;
+    canSignOut: () => boolean;
+    setBackend: (asked: Backend) => Promise<void>;
+    switchTo: (userId: string) => void | undefined;
+    addAccount: () => Promise<void>;
+    signOut: () => boolean;
+    signOutEveryone: () => boolean;
+    checkAgain: () => void | undefined;
+    retry: () => void | undefined;
+    takeNotice: () => GateNotice | null;
+    notice: () => GateNotice | null;
+    namedSignIn: {
+      subscribe: (listener: () => void) => () => undefined;
+      isAsking: () => boolean;
+      answer: (choice: import("@kestack/auth-toolkit/client").NamedChoice | null) => void;
+    };
+  };
+  /** This device's cache, opened on first use. */
+  cache: () => C;
+  SignedIn: (props: {
+    readonly children: ReactNode;
+    readonly fallback?: ReactNode | ((view: NotOpen<S>) => ReactNode);
+  }) => import("react").JSX.Element;
+  SignedOut: (props: {
+    readonly children: ReactNode;
+  }) => ReactNode;
+  /** The Gate, anywhere: what it shows, the Backend, online, signing in. */
+  useGate: () => {
+    view: GateView<Opened<S>>;
+    backend: "cloud" | "device" | null;
+    setBackend: (asked: Backend) => Promise<void>;
+    online: boolean;
+    notice: GateNotice | null;
+    dismissNotice: () => undefined;
+    checkAgain: () => void | undefined;
+    retry: () => void | undefined;
+    signIn: () => Promise<void>;
+    switchTo: (userId: string) => void | undefined;
+    signOut: () => boolean;
+    namedSignIn: {
+      asking: boolean;
+      answer: (choice: import("@kestack/auth-toolkit/client").NamedChoice | null) => void;
+    };
+  };
+  /** The Accounts signed in, what is done with them, and `manage`: the
+   * sign-in service's page for them. Only inside `SignedIn`. */
+  useAccounts: () => {
+    current: import("@kestack/auth-toolkit/client").Account;
+    all: readonly import("@kestack/auth-toolkit/client").Account[];
+    add: () => Promise<void>;
+    switchTo: (userId: string) => void | undefined;
+    signOut: () => boolean;
+    signOutEveryone: () => boolean;
+    manage: () => Promise<void>;
+  };
+  /** The open Session's value; only inside `SignedIn`. */
+  useSession: () => S;
+  /** Runs an Effect in the open Session; only inside `SignedIn`. */
+  useRun: () => Run<S>;
+  /** Whether the open Account has been confirmed, live. */
+  useStatus: typeof useOpenedStatus;
+  /** One API's client: signed as the open Account inside `SignedIn`, and
+   * as nobody outside it, where only a public call goes out. */
+  useApi: <K extends keyof A & string>(name: K) => ApiClients<A>[K];
+  /** The open Session, for Effect code: `yield* app.Session`. */
+  Session: Context.Service<SessionOf<S>, S>;
+};
+/** An app with Accounts, as `createApp` makes it. */
+export type AuthApp<A extends Apis, S, C> = ReturnType<typeof authApp<A, S, C>>;
+//#endregion
+//# sourceMappingURL=assemble.d.ts.map

package/dist/app/assemble/assemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.d.ts","names":["_$___index_ts0.GateNotice","_$___session_define_ts0.Run","_$___session_react_tsx0.useOpenedStatus","_$___session_define_ts0.SessionOf"],"sources":["../../../src/app/assemble/assemble.tsx"],"mappings":";;;;;;;;;;;;;;;;;;iBAgCiB,WAAW,UAAU,MAAM;WACjC,UAAU,WAAW,GAAG;;;;iBAKlB,UAAU,UAAU,MAAM,GAAG;;WAEnC,YAAY;;WAEZ,OAAO;;;;WAIP,UACP,SAAS,YACN,eAAe,KAAK,QAAQ,eAAe;;;WAGvC,OAAO,WAAW,GAAG;;;WAGrB,SAAS,SAAS,YAAY;;KAGpC,QAAQ,KAAK,QAAQ,SAAS;EAAM;;;cAiBnC,WAAY,UAAU,MAAM,GAAC,QACzB,KAAK,UAAU,YAAY;;;;EAWJ,iBAAA,QAAA,OAAO;;;;;;EAgBH,aAAA,SAAA,SAAO,iBAAc,QAAA,MAAA,MAAA,UAAA;;;;;;;;;;;;;wBAsD1C,UAAU,UAAU,MAAM,GAAG,WAC3C,QAAQ,UAAU,GAAG,GAAG;WAAgB,MAAM,WAAW,GAAG;IAC3D,QAAQ,GAAG,GAAG;wBACD,UAAU,UAAU,MAAM,WACxC,QAAQ,UAAU,UAAU;WAAgB;IAC3C,UAAU,GAAG;cAUV,YAAa,UAAU,MAAM,GAAC,MAC5B,kBAAkB,SAAS,GAAG;;EASlC,YAAI;;EAEJ,aAAK;;EAEL,SAAS,gBAAgB,YAAU,MAAQ,MAAI,WAAW,GAAG;;EAG7D;IACE;IAKA,aAAU,MAvDA;;;;YA6DJ,UAAU,UAAU,MAAM,KAAK,kBAAkB,UAAU,GAAG;cAEpE,UAAW,UAAU,MAAM,GAAG,GAAC,MAC7B,kBAAkB,SAAS,GAAG,KAAG,MACjC,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkFK,WAAA;aACd,UAAU;aACV,WAAW,cAAc,MAAM,QAAQ,OAAO;wBACxD,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCU,SAAA,gBAAgB,YAAU,MAAQ,MAAI,WAAW,GAAG;;;;;YAUrD,QAAQ,UAAU,MAAM,GAAG,KAAK,kBAAkB,QAAQ,GAAG,GAAG"}