better-supabase 0.8.0 → 0.9.0

package/dist/client-VvY0K3wr.d.ts

@@ -0,0 +1,59 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { p as SubscriptionStatus } from "./topic-cMS7UtM1.js";
+import { n as TopicPort } from "./watch-topic-EFpOIIDE.js";
+import { g as Workflows, n as WorkflowRun } from "./workflows-DFQeXDAI.js";
+import { n as Controller, t as AuthPort } from "./controller-D845qKh2.js";
+import { D as WorkflowStepInfo, T as WorkflowNodeRun, _ as WorkflowBuilder, b as WorkflowDefinition } from "./types-vaoP9S9_.js";
+//#region src/blocks/workflow-builder/client.d.ts
+interface WorkflowBuilderControllerOptions {
+  readonly client: {
+    readonly definitions: Pick<WorkflowBuilder["definitions"], "list">;
+    readonly steps: Pick<WorkflowBuilder["steps"], "list">;
+  };
+  readonly auth: AuthPort;
+  /** The tenant whose definitions to list. */
+  readonly tenant?: string | null;
+}
+interface WorkflowBuilderSnapshot {
+  /** `undefined` until the first load. */
+  readonly definitions: readonly WorkflowDefinition[] | undefined;
+  /** The step library, the canvas's palette. */
+  readonly steps: readonly WorkflowStepInfo[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface WorkflowBuilderActions {
+  readonly refresh: () => Promise<void>;
+}
+type WorkflowBuilderController = Controller<WorkflowBuilderSnapshot, WorkflowBuilderActions>;
+/** The definitions the signed-in user may read and the step library. */
+declare function createWorkflowBuilderController(options: WorkflowBuilderControllerOptions): WorkflowBuilderController;
+interface WorkflowCanvasRunControllerOptions {
+  readonly client: {
+    readonly runs: Pick<Workflows["runs"], "get">;
+    readonly nodeRuns: Pick<WorkflowBuilder["nodeRuns"], "list">;
+  };
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The run's id or its engine's id; `null` waits. */
+  readonly run: string | null;
+}
+interface WorkflowCanvasRunSnapshot {
+  readonly run: WorkflowRun | undefined;
+  /** Each node's status by node id, for the canvas overlay. */
+  readonly nodes: Readonly<Record<string, WorkflowNodeRun>>;
+  readonly error: DbError | undefined;
+  readonly status: SubscriptionStatus;
+}
+interface WorkflowCanvasRunActions {
+  readonly refresh: () => Promise<void>;
+}
+type WorkflowCanvasRunController = Controller<WorkflowCanvasRunSnapshot, WorkflowCanvasRunActions>;
+/**
+ * A run and the status of each of its nodes, loaded again on each message
+ * on `workflow-run:<id>` (run status changes and node records).
+ */
+declare function createWorkflowCanvasRunController(options: WorkflowCanvasRunControllerOptions): WorkflowCanvasRunController;
+//#endregion
+export { WorkflowCanvasRunActions as a, WorkflowCanvasRunSnapshot as c, WorkflowBuilderSnapshot as i, createWorkflowBuilderController as l, WorkflowBuilderController as n, WorkflowCanvasRunController as o, WorkflowBuilderControllerOptions as r, WorkflowCanvasRunControllerOptions as s, WorkflowBuilderActions as t, createWorkflowCanvasRunController as u };

package/dist/client-WAdEBBrH.d.ts

@@ -0,0 +1,65 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { p as SubscriptionStatus } from "./topic-cMS7UtM1.js";
+import { n as TopicPort } from "./watch-topic-EFpOIIDE.js";
+import { a as WorkflowRunStatus, g as Workflows, n as WorkflowRun } from "./workflows-DFQeXDAI.js";
+import { n as Controller, t as AuthPort } from "./controller-D845qKh2.js";
+//#region src/blocks/workflows/client.d.ts
+interface WorkflowRunsControllerOptions {
+  readonly client: {
+    readonly runs: Pick<Workflows["runs"], "list">;
+  };
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The tenant whose runs to list; it also joins the tenant's `workflow-runs:<tenant>` topic. Without one, the signed-in user's own runs load once. */
+  readonly tenant?: string | null;
+  readonly definition?: string;
+  readonly status?: WorkflowRunStatus;
+  readonly limit?: number;
+}
+interface WorkflowRunsSnapshot {
+  /** `undefined` until the first load. */
+  readonly runs: readonly WorkflowRun[] | undefined;
+  readonly error: DbError | undefined;
+  readonly status: SubscriptionStatus;
+}
+interface WorkflowRunsActions {
+  readonly refresh: () => Promise<void>;
+}
+type WorkflowRunsController = Controller<WorkflowRunsSnapshot, WorkflowRunsActions>;
+/**
+ * The runs the signed-in user may read, newest first, loaded again when a
+ * run in the tenant changes status.
+ */
+declare function createWorkflowRunsController(options: WorkflowRunsControllerOptions): WorkflowRunsController;
+interface WorkflowRunControllerOptions {
+  readonly client: {
+    readonly runs: Pick<Workflows["runs"], "get" | "requestCancel">;
+  };
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The run's id or its engine's id; `null` waits. */
+  readonly run: string | null;
+}
+interface WorkflowRunSnapshot {
+  /** `undefined` until the first load, and when the user may not read the run. */
+  readonly run: WorkflowRun | undefined;
+  readonly error: DbError | undefined;
+  readonly status: SubscriptionStatus;
+}
+interface WorkflowRunActions {
+  readonly refresh: () => Promise<void>;
+  /** Asks the engine to cancel the run, then loads it again. */
+  readonly cancel: () => Promise<void>;
+}
+type WorkflowRunController = Controller<WorkflowRunSnapshot, WorkflowRunActions>;
+/**
+ * One run by its id or its engine's id, loaded again on each status change
+ * broadcast on `workflow-run:<id>`.
+ */
+declare function createWorkflowRunController(options: WorkflowRunControllerOptions): WorkflowRunController;
+//#endregion
+export { WorkflowRunsActions as a, WorkflowRunsSnapshot as c, WorkflowRunSnapshot as i, createWorkflowRunController as l, WorkflowRunController as n, WorkflowRunsController as o, WorkflowRunControllerOptions as r, WorkflowRunsControllerOptions as s, WorkflowRunActions as t, createWorkflowRunsController as u };

package/dist/client-WHeWTNVL.d.ts

@@ -0,0 +1,130 @@
+import { E as ValidationIssue } from "./result-Cj3yWhjH.js";
+import { n as Controller } from "./controller-D845qKh2.js";
+import { a as FormDefinition, c as FormJson, d as FormStep, i as FormCondition, l as FormJsonSchema, o as FormField } from "./form-definition-sagoefQr.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/forms/validate.d.ts
+/** A submission's answers, by field key. */
+type FormAnswers = {
+  readonly [key: string]: FormJson;
+};
+/**
+ * Checks answers against a form version's schema with the keywords the
+ * generator emits, so a form can show errors before it submits. Postgres
+ * checks the same schema again on submit; this is not a general JSON
+ * Schema validator.
+ */
+declare function validateAnswers(schema: FormJsonSchema, answers: unknown): readonly ValidationIssue[];
+/** A form version's schema as a Standard Schema, for form libraries. */
+declare function answersSchema(schema: FormJsonSchema): StandardSchemaV1<unknown, FormAnswers>;
+//#endregion
+//#region src/blocks/forms/questionnaire.d.ts
+/** Whether `condition` holds for `answers`, with the semantics of its JSON Schema `if`. */
+declare function conditionHolds(condition: FormCondition | undefined, answers: FormAnswers): boolean;
+/** The steps whose `showIf` holds. */
+declare function visibleSteps(definition: FormDefinition, answers: FormAnswers): readonly FormStep[];
+/** The step's fields whose `showIf` holds. */
+declare function visibleFields(step: FormStep, answers: FormAnswers): readonly FormField[];
+/**
+ * The answers without the ones for hidden steps and fields. Removing an
+ * answer can hide a later field, so it repeats until nothing changes.
+ */
+declare function pruneAnswers(definition: FormDefinition, answers: FormAnswers): FormAnswers;
+/** The schema's issues for the fields `step` shows. */
+declare function stepIssues(schema: FormJsonSchema, step: FormStep, answers: FormAnswers): readonly ValidationIssue[];
+interface QuestionnaireState {
+  /** The step on screen, by key. */
+  readonly step: string;
+  readonly answers: FormAnswers;
+  /** The steps that passed their checks on `next`. */
+  readonly completed: readonly string[];
+  /** The issues of the step on screen after a `next` or `submit` that failed. */
+  readonly issues: readonly ValidationIssue[];
+}
+type QuestionnaireAction = {
+  readonly type: "answer";
+  readonly key: string;
+  readonly value: FormJson | undefined;
+} | {
+  readonly type: "next";
+} | {
+  readonly type: "back";
+} | {
+  readonly type: "goTo";
+  readonly step: string;
+} | {
+  readonly type: "reset";
+  readonly answers?: FormAnswers;
+};
+interface QuestionnaireForm {
+  readonly definition: FormDefinition;
+  /** The version's generated schema. */
+  readonly schema: FormJsonSchema;
+}
+/** The state before the first answer. */
+declare function initialQuestionnaire(form: QuestionnaireForm, answers?: FormAnswers): QuestionnaireState;
+/**
+ * The questionnaire as a reducer: answers, the current step and the steps
+ * done. `next` checks the step's fields against the version's schema and
+ * stays put with `issues` when one fails; hidden steps are skipped.
+ */
+declare function questionnaireReducer(form: QuestionnaireForm, state: QuestionnaireState, action: QuestionnaireAction): QuestionnaireState;
+interface QuestionnaireStepView {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly fields: readonly FormField[];
+  readonly completed: boolean;
+  readonly active: boolean;
+}
+/** The visible steps with their status, in the shape a Stepper renders. */
+declare function questionnaireSteps(form: QuestionnaireForm, state: QuestionnaireState): readonly QuestionnaireStepView[];
+/** The pruned answers, or every issue when the whole form does not pass. */
+declare function finishQuestionnaire(form: QuestionnaireForm, state: QuestionnaireState): {
+  readonly ok: true;
+  readonly answers: FormAnswers;
+} | {
+  readonly ok: false;
+  readonly issues: readonly ValidationIssue[];
+};
+//#endregion
+//#region src/blocks/forms/client.d.ts
+interface QuestionnaireOptions {
+  /** A form version, or anything with its `definition` and `schema`. */
+  readonly form: QuestionnaireForm;
+  /** Answers to start from, such as a saved draft. */
+  readonly initialAnswers?: FormAnswers;
+  /** Receives the answers of the visible fields once the whole form passes. */
+  readonly onSubmit: (answers: FormAnswers) => Promise<void> | void;
+}
+interface QuestionnaireSnapshot {
+  /** The visible steps, for a Stepper's items. */
+  readonly steps: readonly QuestionnaireStepView[];
+  /** The step on screen. */
+  readonly step: QuestionnaireStepView | undefined;
+  readonly answers: FormAnswers;
+  /** Issues by field key: the step on screen's after `next`, every field's after a failed `submit`. */
+  readonly issues: Readonly<Record<string, readonly string[]>>;
+  readonly isFirst: boolean;
+  readonly isLast: boolean;
+  readonly submitting: boolean;
+}
+interface QuestionnaireActions {
+  /** `undefined` removes the answer. */
+  readonly setAnswer: (key: string, value: FormJson | undefined) => void;
+  /** Checks the step and moves to the next visible one. */
+  readonly next: () => void;
+  readonly back: () => void;
+  /** Moves to a step whose earlier steps are done, for a clickable Stepper. */
+  readonly goTo: (step: string) => void;
+  /** Checks the whole form, then calls `onSubmit`. Returns whether it passed. */
+  readonly submit: () => Promise<boolean>;
+  readonly reset: (answers?: FormAnswers) => void;
+}
+type QuestionnaireController = Controller<QuestionnaireSnapshot, QuestionnaireActions>;
+/**
+ * A multi-step form over a form version: the visible steps, the answers,
+ * and per-field issues checked against the version's JSON Schema.
+ */
+declare function createQuestionnaireController(options: QuestionnaireOptions): QuestionnaireController;
+//#endregion
+export { visibleFields as _, createQuestionnaireController as a, answersSchema as b, QuestionnaireState as c, finishQuestionnaire as d, initialQuestionnaire as f, stepIssues as g, questionnaireSteps as h, QuestionnaireSnapshot as i, QuestionnaireStepView as l, questionnaireReducer as m, QuestionnaireController as n, QuestionnaireAction as o, pruneAnswers as p, QuestionnaireOptions as r, QuestionnaireForm as s, QuestionnaireActions as t, conditionHolds as u, visibleSteps as v, validateAnswers as x, FormAnswers as y };

package/dist/client-WgrPIHH-.js

@@ -0,0 +1,213 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+//#region src/blocks/inbox/client.ts
+function loader(load, state) {
+	return async () => {
+		try {
+			state.set({
+				items: await load(),
+				error: void 0
+			});
+		} catch (cause) {
+			state.set({ error: cause });
+		}
+	};
+}
+/**
+* The staff view of an organization's conversations, kept current: loads,
+* then loads again after each ping on `inbox:org:<id>` and on rejoin.
+*/
+function createInboxController(options) {
+	const topic = options.organizationId === null ? null : `${options.topic ?? "inbox"}:org:${options.organizationId}`;
+	return defineController({
+		items: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		const refresh = loader(options.load, state);
+		return {
+			actions: { refresh },
+			start: () => {
+				if (topic === null) return;
+				return whileSignedIn(options.auth, () => {
+					refresh();
+					return options.ports.topic(topic, {
+						onMessage: (event, payload) => {
+							options.onMessage?.(event, payload);
+							refresh();
+						},
+						onRejoin: () => void refresh(),
+						onStatus: (status) => {
+							state.set({ status });
+						}
+					}).leave;
+				});
+			}
+		};
+	});
+}
+const NO_TYPERS = [];
+/**
+* One conversation's messages, kept current over `inbox:<id>`, with typing
+* pings between staff and the contact. Notes never reach this topic.
+*/
+function createConversationController(options) {
+	const typingMs = options.typingMs ?? 5e3;
+	const topic = options.conversationId === null ? null : `${options.topic ?? "inbox"}:${options.conversationId}`;
+	let joined;
+	return defineController({
+		items: void 0,
+		status: "closed",
+		error: void 0,
+		typing: NO_TYPERS
+	}, (state) => {
+		const refresh = loader(options.load, state);
+		const join = (name, userId) => {
+			const seen = /* @__PURE__ */ new Map();
+			const typer = (who, on) => {
+				const timer = seen.get(who);
+				if (timer !== void 0) clearTimeout(timer);
+				if (on) seen.set(who, setTimeout(() => {
+					typer(who, false);
+				}, typingMs));
+				else seen.delete(who);
+				state.set({ typing: [...seen.keys()] });
+			};
+			const handle = options.ports.topic(name, {
+				onMessage: (event, payload) => {
+					if (event !== "typing") {
+						refresh();
+						return;
+					}
+					if (typeof payload !== "object" || payload === null) return;
+					const who = "user_id" in payload ? String(payload.user_id) : "";
+					if (who !== "" && who !== userId) typer(who, !("typing" in payload) || payload.typing !== false);
+				},
+				onRejoin: () => void refresh(),
+				onStatus: (status) => {
+					state.set({ status });
+				}
+			});
+			joined = {
+				userId,
+				send: (on) => {
+					handle.send("typing", {
+						user_id: userId,
+						typing: on
+					});
+				}
+			};
+			return () => {
+				for (const timer of seen.values()) clearTimeout(timer);
+				joined = void 0;
+				handle.leave();
+				state.set({ typing: NO_TYPERS });
+			};
+		};
+		return {
+			actions: {
+				refresh,
+				setTyping: (on) => {
+					joined?.send(on);
+				}
+			},
+			start: () => {
+				if (topic === null) return;
+				return whileSignedIn(options.auth, (userId) => {
+					refresh();
+					return join(topic, userId);
+				});
+			}
+		};
+	});
+}
+/**
+* The visitor side of an in-app inbox: the first message opens the
+* conversation, later ones go into it, and the messages and typing pings
+* stay current. Visitors without an account sign in anonymously first.
+*/
+function createInboxWidgetController(options) {
+	const key = options.storageKey === void 0 ? "better-supabase:inbox-widget" : options.storageKey;
+	const storage = key === null ? void 0 : options.ports.storage;
+	let conversationId = null;
+	let restored = storage === void 0;
+	let active = false;
+	let inner;
+	let leaveInner;
+	return defineController({
+		items: void 0,
+		status: "closed",
+		error: void 0,
+		typing: NO_TYPERS,
+		conversationId: null
+	}, (state) => {
+		let show = () => void 0;
+		const attach = () => {
+			leaveInner?.();
+			leaveInner = active ? inner?.subscribe(show) : void 0;
+		};
+		const follow = () => {
+			const id = conversationId;
+			const current = createConversationController({
+				auth: options.auth,
+				ports: options.ports,
+				conversationId: id,
+				load: () => id === null ? Promise.resolve([]) : options.load(id),
+				...options.topic === void 0 ? {} : { topic: options.topic }
+			});
+			inner = current;
+			show = () => {
+				state.set({
+					...current.getSnapshot(),
+					conversationId: id
+				});
+			};
+			show();
+			attach();
+		};
+		const choose = (id) => {
+			if (id === conversationId) return;
+			conversationId = id;
+			follow();
+		};
+		follow();
+		return {
+			actions: {
+				refresh: () => inner?.actions.refresh() ?? Promise.resolve(),
+				setTyping: (on) => {
+					inner?.actions.setTyping(on);
+				},
+				submit: async (message) => {
+					if (conversationId === null) {
+						const id = await options.open(message);
+						if (key !== null) await storage?.set(key, id);
+						choose(id);
+						return;
+					}
+					await options.send(conversationId, message);
+					await inner?.actions.refresh();
+				},
+				reset: () => {
+					if (key !== null) storage?.remove(key);
+					choose(null);
+				}
+			},
+			start: () => {
+				active = true;
+				attach();
+				if (!restored && key !== null && storage) {
+					restored = true;
+					storage.get(key).then((stored) => {
+						if (stored !== null && conversationId === null) choose(stored);
+					});
+				}
+				return () => {
+					active = false;
+					leaveInner?.();
+					leaveInner = void 0;
+				};
+			}
+		};
+	});
+}
+//#endregion
+export { createInboxController as n, createInboxWidgetController as r, createConversationController as t };

package/dist/client-ZTtSV3l8.js

@@ -0,0 +1,40 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+//#region src/blocks/onboarding/client.ts
+/** A checklist's progress for the signed-in user, or for an organization. */
+function createOnboardingController(options) {
+	const { client, checklist } = options;
+	const organizationId = options.organizationId ?? null;
+	const ready = checklist.scope === "user" || organizationId !== null;
+	const subject = checklist.scope === "organization" && organizationId !== null ? [organizationId] : [];
+	return defineController({
+		progress: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const result = await client.progress(checklist, ...subject);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				progress: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const change = async (action, step) => {
+			const result = await client[action](checklist, step, ...subject);
+			if (result.ok) await refresh();
+			else state.set({ error: result.error });
+		};
+		return {
+			actions: {
+				refresh,
+				complete: (step) => change("complete", step),
+				reset: (step) => change("reset", step)
+			},
+			start: () => ready ? whileSignedIn(options.auth, () => {
+				refresh();
+			}) : void 0
+		};
+	});
+}
+//#endregion
+export { createOnboardingController as t };