better-supabase 0.12.0 → 0.14.0

package/dist/view-BtgqxQLM.js

@@ -0,0 +1,108 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { a as invalidActorError, i as delegationOf, n as actorOf } from "./actor-hNajGNEK.js";
+import { r as impersonatorOf } from "./impersonation-CZD9AOAk.js";
+//#region src/auth/mfa.ts
+/**
+* The session's assurance level from its claims; anything but `aal2` reads as
+* `aal1`.
+*/
+function aalOf(claims) {
+	return claims["aal"] === "aal2" ? "aal2" : "aal1";
+}
+/** The `amr` claim as typed entries, skipping malformed ones. */
+function amrOf(claims) {
+	const amr = claims["amr"];
+	if (!Array.isArray(amr)) return [];
+	return amr.flatMap((entry) => {
+		if (typeof entry !== "object" || entry === null) return [];
+		const { method, timestamp, provider } = entry;
+		if (typeof method !== "string" || typeof timestamp !== "number") return [];
+		return [typeof provider === "string" ? {
+			method,
+			timestamp,
+			provider
+		} : {
+			method,
+			timestamp
+		}];
+	});
+}
+/**
+* `undefined` when a user session meets `required`; otherwise a `forbidden`
+* error with `required` and code `INSUFFICIENT_AAL`, for the client to start an
+* MFA challenge. Non-user sessions pass: `allow` decides about them.
+*/
+function checkAal(auth, required) {
+	if (required === "aal1" || auth.kind !== "user" || !("claims" in auth)) return;
+	if (aalOf(auth.claims) === "aal2") return;
+	return dbError("forbidden", "Verify a second factor to continue", {
+		code: "INSUFFICIENT_AAL",
+		required
+	});
+}
+//#endregion
+//#region src/auth/view.ts
+/** Whether the token belongs to an anonymous user (`signInAnonymously()`). */
+function isAnonymousUser(claims) {
+	return "is_anonymous" in claims && claims.is_anonymous === true;
+}
+/** Drops the token from an `AuthState`, leaving only serializable fields. */
+function toSession(auth) {
+	switch (auth.kind) {
+		case "user": {
+			const outcome = actorOf(auth.claims);
+			if (!outcome.ok) return {
+				kind: "invalid",
+				reason: "actor",
+				error: invalidActorError()
+			};
+			const impersonator = impersonatorOf(auth.claims);
+			const actor = outcome.actor;
+			const client = actor?.kind === "oauth-client" || actor?.kind === "agent" && delegationOf(auth.claims) !== void 0 ? actor : void 0;
+			const scopes = client ? delegationOf(auth.claims)?.scopes : void 0;
+			const delegation = client && (scopes || client.chain) ? {
+				scopes: scopes ?? [],
+				...client.chain ? { chain: client.chain } : {}
+			} : void 0;
+			return {
+				kind: "user",
+				user: auth.user,
+				claims: auth.claims,
+				expiresAt: auth.expiresAt,
+				...auth.profile === void 0 ? {} : { profile: auth.profile },
+				aal: aalOf(auth.claims),
+				anonymous: isAnonymousUser(auth.claims),
+				amr: amrOf(auth.claims),
+				...impersonator ? { impersonator } : {},
+				...actor ? { actor } : {},
+				...delegation ? { delegation } : {}
+			};
+		}
+		case "service": return {
+			kind: "service",
+			keyName: auth.keyName
+		};
+		case "apiKey": return {
+			kind: "apiKey",
+			keyId: auth.keyId,
+			name: auth.name,
+			...auth.organizationId ? { organizationId: auth.organizationId } : {},
+			...auth.userId ? { userId: auth.userId } : {},
+			scopes: auth.scopes,
+			...auth.createdAt ? { createdAt: Math.floor(auth.createdAt.epochMilliseconds / 1e3) } : {},
+			...auth.createdBy ? { createdBy: auth.createdBy } : {}
+		};
+		case "anon": return {
+			kind: "anon",
+			reason: auth.reason
+		};
+		case "invalid": return {
+			kind: "invalid",
+			reason: auth.reason,
+			error: auth.error
+		};
+		default: return auth;
+	}
+}
+//#endregion
+export { checkAal as a, amrOf as i, toSession as n, aalOf as r, isAnonymousUser as t };

package/dist/vue/index.d.ts

@@ -1,17 +1,35 @@
-import { b as DbError } from "../result-BREt7qOh.js";
-import { O as TemplateValues } from "../bucket-BbePDVwc.js";
-import { at as QuerySpec } from "../define-DYZnvAbs.js";
-import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-DAY_HOX2.js";
-import { t as AuthSnapshot } from "../bind-Bfo40o63.js";
-import { t as AuthSession } from "../view-KQhe6eNc.js";
-import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-Z-sgsdoN.js";
-import { t as SupportView } from "../support-view-Bj_lZ8Wr.js";
+import { b as DbError } from "../result-C6jDfedy.js";
+import { Ct as Events, D as BlockEventPattern, T as BlockEvent, bt as EventMap, k as BlockEventsMatching } from "../events-DbLjvxDX.js";
+import { J as QuerySpec } from "../define-Dw7pRO4h.js";
+import { $ as TemplateValues } from "../bucket-TkB7_xv8.js";
+import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-D9j8G2dw.js";
+import { t as AuthSnapshot } from "../bind-Dz8y3T5T.js";
+import { t as AuthSession } from "../view-2_I-2ukO.js";
+import { _ as LiveQueryHookOptions, a as BlockQueryActions, b as ProfileOf, c as BlockRefetchOn, d as ActionState, f as BroadcastOptions, g as LiveCountSource, h as LiveCountHookOptions, i as BlockMutationState, l as ActionInputOf, m as ClientLike, n as BlockEventSource, o as BlockQueryOptions, p as ClaimsOf, r as BlockMutationActions, s as BlockQueryState, t as fieldErrorsOf, u as ActionResultOf, v as PresenceHookOptions, x as UseActionOptions, y as PresenceTopic } from "../field-errors-vshYTVKr.js";
+import { t as VueController } from "../vue-bind-TPkbLl4z.js";
+import { i as BlockMethodName, n as BlockDataOf, t as BlockArgsOf } from "../block-method-hsPAGFi5.js";
+import { t as SupportView } from "../support-view-vwJbRMpV.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { App, ComputedRef, MaybeRefOrGetter, Ref } from "vue";
 import { QueryClient } from "@tanstack/query-core";
+//#region src/vue/block-hooks.d.ts
+/**
+ * Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
+ * from mount. `refetchOn` calls it again on block events.
+ */
+export declare function useBlockQuery<C extends object, const K extends BlockMethodName<C>>(client: C, method: K, args: BlockArgsOf<C, K>, options?: BlockQueryOptions): VueController<BlockQueryState<BlockDataOf<C, K>>, BlockQueryActions>;
+/** Calls a write method of any block client and tracks its state. */
+export declare function useBlockMutation<C extends object, const K extends BlockMethodName<C>>(client: C, method: K): VueController<BlockMutationState<BlockDataOf<C, K>>, BlockMutationActions<BlockArgsOf<C, K>, BlockDataOf<C, K>>>;
+/**
+ * Calls `handler` for each block event matching `pattern` (`"task.*"`), typed
+ * by `events` (`blockEvents` from `blocks.generated.ts`), from mount until the
+ * component goes away. `source` is the client's `betterSupabase`.
+ */
+export declare function useBlockEvent<M extends EventMap, const P extends BlockEventPattern<M>>(source: BlockEventSource, events: Events<M>, pattern: P, handler: (event: BlockEvent<M, BlockEventsMatching<M, P>>) => void): void;
+//#endregion
 //#region src/vue/index.d.ts
 export interface BetterSupabaseVueOptions {
-  /** better-supabase queries are reset when the user signs out or changes. */
+  /** Better-supabase queries are reset when the user signs out or changes. */
   readonly queryClient?: QueryClient;
 }
 export interface BetterSupabasePlugin {
@@ -22,16 +40,21 @@ export interface BetterSupabasePlugin {
  * `queryClient`, resets better-supabase queries when the caller changes.
  *
  * ```ts
- * app.use(VueQueryPlugin, { queryClient }).use(betterSupabase(bs, { queryClient }));
+ * app
+ *   .use(VueQueryPlugin, { queryClient })
+ *   .use(betterSupabase(bs, { queryClient }));
  * ```
  */
 export declare function betterSupabase(client: ClientLike, options?: BetterSupabaseVueOptions): BetterSupabasePlugin;
-/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+/**
+ * The session state for UI: `loading`, `signed-out` or `signed-in` with the
+ * user and claims.
+ */
 export declare function useAuth(): Readonly<Ref<AuthSnapshot>>;
 export declare function useSupabase(): SupabaseClient;
 /**
- * Shares a server-verified session (from `useAsyncData`, a loader or a
- * prop) with the components below.
+ * Shares a server-verified session (from `useAsyncData`, a loader or a prop)
+ * with the components below.
  */
 export declare function provideSession(session: MaybeRefOrGetter<AuthSession>): void;
 /** The session from the nearest `provideSession()`. */
@@ -41,7 +64,10 @@ export declare function useSupportSession(): ComputedRef<SupportView | undefined
 export interface BetterComposables<B extends ClientLike> {
   /** Repositories bound to the current session. */
   readonly useDb: () => B["db"];
-  /** TanStack Query option factories: `useQuery(useQueries().customers.findMany())`. */
+  /**
+   * TanStack Query option factories:
+   * `useQuery(useQueries().customers.findMany())`.
+   */
   readonly useQueries: () => B["queries"];
   readonly useSupabase: () => SupabaseClient;
   readonly useAuth: () => Readonly<Ref<AuthSnapshot>>;
@@ -51,16 +77,22 @@ export interface BetterComposables<B extends ClientLike> {
  * Composables typed for your schema.
  *
  * ```ts
- * export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+ * export const { useDb, useQueries, useAuth } =
+ *   createBindings<typeof bs>();
  * ```
  */
 export declare function createBindings<B extends ClientLike>(): BetterComposables<B>;
 /**
- * Subscribes to a topic while the component is mounted. A `null` value
- * pauses. It resubscribes when the topic values or the signed-in user change.
+ * Subscribes to a topic while the component is mounted. A `null` value pauses.
+ * It resubscribes when the topic values or the signed-in user change.
  *
  * ```ts
- * useBroadcast(customersTopic, () => ({ organizationId: org.value }), {}, { invalidate: ['customers'] });
+ * useBroadcast(
+ *   customersTopic,
+ *   () => ({ organizationId: org.value }),
+ *   {},
+ *   { invalidate: ["customers"] },
+ * );
  * ```
  */
 export declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: MaybeRefOrGetter<TemplateValues<P> | null | undefined>, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Readonly<Ref<SubscriptionStatus>>;
@@ -69,7 +101,11 @@ export declare function useBroadcast<P extends string, E extends EventSchemas>(t
  * spec touches whenever one of them changes. A `null` spec pauses.
  *
  * ```ts
- * const spec = computed(() => betterSupabase.spec.customers.findMany({ where: { orgId: org.value } }));
+ * const spec = computed(() =>
+ *   betterSupabase.spec.customers.findMany({
+ *     where: { orgId: org.value },
+ *   }),
+ * );
  * useLiveQuery(spec);
  * ```
  */
@@ -87,7 +123,9 @@ export interface LiveCount {
  * seed; `null` pauses. The returned object's fields are reactive.
  *
  * ```ts
- * const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+ * const unread = useLiveCount(() =>
+ *   betterSupabase.spec.messages.count({ where: { read: false } }),
+ * );
  * // {{ unread.count }}
  * ```
  */
@@ -104,11 +142,13 @@ export interface VuePresenceOptions<I> extends Omit<PresenceHookOptions<I>, "sta
   readonly state?: MaybeRefOrGetter<I | null | undefined>;
 }
 /**
- * Joins a presence topic while mounted and returns who is on it. A `null`
- * value pauses. The returned object's fields are reactive.
+ * Joins a presence topic while mounted and returns who is on it. A `null` value
+ * pauses. The returned object's fields are reactive.
  *
  * ```ts
- * const room = usePresence(roomTopic, () => ({ roomId: id.value }), { state: () => ({ name: name.value }) });
+ * const room = usePresence(roomTopic, () => ({ roomId: id.value }), {
+ *   state: () => ({ name: name.value }),
+ * });
  * ```
  */
 export declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: MaybeRefOrGetter<TemplateValues<P> | null | undefined>, options?: VuePresenceOptions<I>): Presence<I, O>;
@@ -118,15 +158,17 @@ export interface ActionHandle<I, T> extends ActionState<I, T> {
   readonly reset: () => void;
 }
 /**
- * Calls a server action from an event handler: tracks pending inputs and
- * the last result, and calls `onSuccess` or `onError`. The returned
- * object's fields are reactive.
+ * Calls a server action from an event handler: tracks pending inputs and the
+ * last result, and calls `onSuccess` or `onError`. The returned object's fields
+ * are reactive.
  *
  * ```ts
- * const remove = useAction(removeMember, { onError: (e) => toast.error(e.message) });
+ * const remove = useAction(removeMember, {
+ *   onError: (e) => toast.error(e.message),
+ * });
  * // <button :disabled="remove.pending" @click="remove.run({ userId })">
  * ```
  */
 export declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
 //#endregion
-export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type SupportView, type UseActionOptions, fieldErrorsOf };
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BlockEventSource, type BlockMutationActions, type BlockMutationState, type BlockQueryActions, type BlockQueryOptions, type BlockQueryState, type BlockRefetchOn, type BroadcastOptions, type ClaimsOf, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type ProfileOf, type SupportView, type UseActionOptions, fieldErrorsOf };

package/dist/vue/index.js

@@ -1,9 +1,34 @@
-import { t as clearOnUserChange } from "../user-change-XzvgafU4.js";
-import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-CHR8IBNG.js";
+import { t as clearOnUserChange } from "../user-change-CSR_prhd.js";
+import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-C_0XZieg.js";
 import { t as supportOf } from "../support-view-g4YLBeqX.js";
-import { t as fieldErrorsOf } from "../field-errors-DZVRWRkf.js";
-import { n as onClient, r as useContext, t as CLIENT } from "../context-D6ZMKc2L.js";
+import { a as fieldErrorsOf, i as listenToBlockEvents, n as createBlockMutation, r as createBlockQuery } from "../block-controller-DTGuBemi.js";
+import { i as useContext, n as CLIENT, r as onClient, t as bindVueController } from "../vue-bind-CFxon-Vs.js";
 import { computed, getCurrentScope, inject, onScopeDispose, provide, readonly, shallowRef, toValue, watch } from "vue";
+//#region src/vue/block-hooks.ts
+/**
+* Calls a read method of any block client (`blocks.tasks.list`, renamed or not)
+* from mount. `refetchOn` calls it again on block events.
+*/
+function useBlockQuery(client, method, args, options = {}) {
+	return bindVueController(createBlockQuery(client, method, args, options));
+}
+/** Calls a write method of any block client and tracks its state. */
+function useBlockMutation(client, method) {
+	return bindVueController(createBlockMutation(client, method));
+}
+/**
+* Calls `handler` for each block event matching `pattern` (`"task.*"`), typed
+* by `events` (`blockEvents` from `blocks.generated.ts`), from mount until the
+* component goes away. `source` is the client's `betterSupabase`.
+*/
+function useBlockEvent(source, events, pattern, handler) {
+	let stop;
+	onClient(() => {
+		stop = listenToBlockEvents(source, events, pattern, () => handler);
+	});
+	if (getCurrentScope()) onScopeDispose(() => stop?.());
+}
+//#endregion
 //#region src/vue/index.ts
 const SESSION = Symbol("better-supabase-session");
 /**
@@ -11,7 +36,9 @@ const SESSION = Symbol("better-supabase-session");
 * `queryClient`, resets better-supabase queries when the caller changes.
 *
 * ```ts
-* app.use(VueQueryPlugin, { queryClient }).use(betterSupabase(bs, { queryClient }));
+* app
+*   .use(VueQueryPlugin, { queryClient })
+*   .use(betterSupabase(bs, { queryClient }));
 * ```
 */
 function betterSupabase(client, options = {}) {
@@ -31,7 +58,10 @@ function betterSupabase(client, options = {}) {
 		});
 	} };
 }
-/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+/**
+* The session state for UI: `loading`, `signed-out` or `signed-in` with the
+* user and claims.
+*/
 function useAuth() {
 	return useContext().auth;
 }
@@ -39,8 +69,8 @@ function useSupabase() {
 	return useContext().client.supabase;
 }
 /**
-* Shares a server-verified session (from `useAsyncData`, a loader or a
-* prop) with the components below.
+* Shares a server-verified session (from `useAsyncData`, a loader or a prop)
+* with the components below.
 */
 function provideSession(session) {
 	provide(SESSION, session);
@@ -60,7 +90,8 @@ function useSupportSession() {
 * Composables typed for your schema.
 *
 * ```ts
-* export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+* export const { useDb, useQueries, useAuth } =
+*   createBindings<typeof bs>();
 * ```
 */
 function createBindings() {
@@ -93,11 +124,16 @@ function supabaseFor(hook, context, client) {
 	return supabase;
 }
 /**
-* Subscribes to a topic while the component is mounted. A `null` value
-* pauses. It resubscribes when the topic values or the signed-in user change.
+* Subscribes to a topic while the component is mounted. A `null` value pauses.
+* It resubscribes when the topic values or the signed-in user change.
 *
 * ```ts
-* useBroadcast(customersTopic, () => ({ organizationId: org.value }), {}, { invalidate: ['customers'] });
+* useBroadcast(
+*   customersTopic,
+*   () => ({ organizationId: org.value }),
+*   {},
+*   { invalidate: ["customers"] },
+* );
 * ```
 */
 function useBroadcast(topic, values, handlers, options) {
@@ -142,7 +178,11 @@ function useBroadcast(topic, values, handlers, options) {
 * spec touches whenever one of them changes. A `null` spec pauses.
 *
 * ```ts
-* const spec = computed(() => betterSupabase.spec.customers.findMany({ where: { orgId: org.value } }));
+* const spec = computed(() =>
+*   betterSupabase.spec.customers.findMany({
+*     where: { orgId: org.value },
+*   }),
+* );
 * useLiveQuery(spec);
 * ```
 */
@@ -186,7 +226,9 @@ function useLiveQuery(spec, options = {}) {
 * seed; `null` pauses. The returned object's fields are reactive.
 *
 * ```ts
-* const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+* const unread = useLiveCount(() =>
+*   betterSupabase.spec.messages.count({ where: { read: false } }),
+* );
 * // {{ unread.count }}
 * ```
 */
@@ -246,11 +288,13 @@ function useLiveCount(source, options = {}) {
 }
 const NO_MEMBERS = [];
 /**
-* Joins a presence topic while mounted and returns who is on it. A `null`
-* value pauses. The returned object's fields are reactive.
+* Joins a presence topic while mounted and returns who is on it. A `null` value
+* pauses. The returned object's fields are reactive.
 *
 * ```ts
-* const room = usePresence(roomTopic, () => ({ roomId: id.value }), { state: () => ({ name: name.value }) });
+* const room = usePresence(roomTopic, () => ({ roomId: id.value }), {
+*   state: () => ({ name: name.value }),
+* });
 * ```
 */
 function usePresence(topic, values, options = {}) {
@@ -305,12 +349,14 @@ function usePresence(topic, values, options = {}) {
 	};
 }
 /**
-* Calls a server action from an event handler: tracks pending inputs and
-* the last result, and calls `onSuccess` or `onError`. The returned
-* object's fields are reactive.
+* Calls a server action from an event handler: tracks pending inputs and the
+* last result, and calls `onSuccess` or `onError`. The returned object's fields
+* are reactive.
 *
 * ```ts
-* const remove = useAction(removeMember, { onError: (e) => toast.error(e.message) });
+* const remove = useAction(removeMember, {
+*   onError: (e) => toast.error(e.message),
+* });
 * // <button :disabled="remove.pending" @click="remove.run({ userId })">
 * ```
 */
@@ -346,4 +392,4 @@ function useAction(action, options = {}) {
 	};
 }
 //#endregion
-export { betterSupabase, createBindings, fieldErrorsOf, provideSession, useAction, useAuth, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession, useSupabase, useSupportSession };
+export { betterSupabase, createBindings, fieldErrorsOf, provideSession, useAction, useAuth, useBlockEvent, useBlockMutation, useBlockQuery, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession, useSupabase, useSupportSession };

package/dist/vue-bind-CFxon-Vs.js

@@ -0,0 +1,45 @@
+import { getCurrentInstance, getCurrentScope, inject, onMounted, onScopeDispose, shallowRef } from "vue";
+//#region src/vue/context.ts
+const CLIENT = Symbol("better-supabase");
+/** What `app.use(betterSupabase(bs))` provides. */
+function useContext() {
+	const context = inject(CLIENT, null);
+	if (!context) throw new Error("better-supabase: install the plugin with app.use(betterSupabase(bs))");
+	return context;
+}
+/**
+* Runs `start` on mount in a component, at once elsewhere (an effect scope),
+* and never during server rendering.
+*/
+function onClient(start) {
+	if (getCurrentInstance()) onMounted(start);
+	else start();
+}
+//#endregion
+//#region src/blocks/vue-bind.ts
+/**
+* Keeps `state` current from mount (at once in an effect scope, never during
+* server rendering), and disposes the controller with the component or scope.
+*/
+function bindVueController(controller) {
+	const state = shallowRef(controller.getSnapshot());
+	let unsubscribe;
+	onClient(() => {
+		const sync = () => {
+			state.value = controller.getSnapshot();
+		};
+		unsubscribe = controller.subscribe(sync);
+		sync();
+	});
+	if (getCurrentScope()) onScopeDispose(() => {
+		unsubscribe?.();
+		controller.dispose();
+	});
+	return {
+		state,
+		actions: controller.actions,
+		controller
+	};
+}
+//#endregion
+export { useContext as i, CLIENT as n, onClient as r, bindVueController as t };

package/dist/vue-bind-TPkbLl4z.d.ts

@@ -0,0 +1,11 @@
+import { n as Controller } from "./controller-DAD4hbl4.js";
+import { ShallowRef } from "vue";
+//#region src/blocks/vue-bind.d.ts
+/** A block controller in a Vue component: `state` follows the controller. */
+interface VueController<S, A> {
+  readonly state: Readonly<ShallowRef<S>>;
+  readonly actions: A;
+  readonly controller: Controller<S, A>;
+}
+//#endregion
+export { VueController as t };

package/dist/vue-controller-WtbuT-Ux.js

@@ -0,0 +1,13 @@
+import { n as withEnv, t as blockEnv } from "./block-env-DJiUu1fq.js";
+import { i as useContext, t as bindVueController } from "./vue-bind-CFxon-Vs.js";
+//#region src/blocks/vue-controller.ts
+/**
+* Makes a controller once and keeps `state` current. Its work starts on mount
+* (at once in an effect scope, never during server rendering), and the
+* controller is disposed with the component or scope.
+*/
+function useBlockController(create, options, usesEnv = true) {
+	return bindVueController(create(withEnv(options, usesEnv ? () => blockEnv(useContext().client) : void 0)));
+}
+//#endregion
+export { useBlockController as t };

package/dist/watch-CfMT6vX7.js

@@ -0,0 +1,139 @@
+import { r as isPlainObject } from "./clone-CkG0-hlI.js";
+import { r as err, s as toDbError } from "./result-B3m7xtRY.js";
+//#region src/core/share.ts
+function sameValue(prev, next) {
+	if (Object.is(prev, next)) return true;
+	if (typeof prev !== "object" || typeof next !== "object") return false;
+	if (prev === null || next === null) return false;
+	return Object.getPrototypeOf(prev) === Object.getPrototypeOf(next) && !Array.isArray(prev) && !isPlainObject(prev) && "toJSON" in prev && typeof prev.toJSON === "function" && JSON.stringify(prev) === JSON.stringify(next);
+}
+function idOf(value) {
+	return isPlainObject(value) ? value["id"] : void 0;
+}
+/**
+* `next` with every part that equals `prev` replaced by `prev`'s object, so
+* unchanged rows keep their identity and `memo` skips them. Array items match
+* by their `id` when they have one (a reordered list keeps its rows), else by
+* position. Returns `prev` itself when nothing changed.
+*/
+function shareStructure(prev, next) {
+	if (sameValue(prev, next)) return prev;
+	if (Array.isArray(prev) && Array.isArray(next)) {
+		const before = prev;
+		const after = next;
+		const byId = /* @__PURE__ */ new Map();
+		for (const item of before) {
+			const id = idOf(item);
+			if (id !== void 0) byId.set(id, item);
+		}
+		let same = before.length === after.length;
+		const shared = after.map((item, index) => {
+			const id = idOf(item);
+			const value = shareStructure(id === void 0 ? before[index] : byId.get(id), item);
+			if (value !== before[index]) same = false;
+			return value;
+		});
+		return same ? prev : shared;
+	}
+	if (isPlainObject(prev) && isPlainObject(next)) {
+		const keys = Object.keys(next);
+		let same = keys.length === Object.keys(prev).length;
+		const shared = {};
+		for (const key of keys) {
+			const value = shareStructure(prev[key], next[key]);
+			if (!Object.hasOwn(prev, key) || value !== prev[key]) same = false;
+			shared[key] = value;
+		}
+		return same ? prev : shared;
+	}
+	return next;
+}
+//#endregion
+//#region src/powersync/watch.ts
+/**
+* Reruns a repository call whenever PowerSync reports a change to one of
+* `tables`: local writes and synced rows alike. The same call works with lists,
+* aggregates and single rows. Unchanged rows keep their identity between runs,
+* and a run that changes nothing calls no `onResult`. Returns a function that
+* stops it.
+*
+* ```ts
+* const stop = watch(powersync, () => customerList.run(db, query), {
+*   tables: ["customers"],
+*   onResult: (page) => render(page),
+* });
+* ```
+*/
+function watch(db, query, options) {
+	if (!db.onChange) throw new TypeError("better-supabase: watch() needs a PowerSync database with onChange()");
+	const refresh = options.refresh ?? {};
+	if (refresh.onReconnect && !db.registerListener) throw new TypeError("better-supabase: watch() refresh.onReconnect needs a PowerSync database with registerListener()");
+	const signal = options.signal;
+	if (signal?.aborted) return () => void 0;
+	const controller = new AbortController();
+	const stop = () => {
+		controller.abort();
+	};
+	signal?.addEventListener("abort", stop, { once: true });
+	let latest = 0;
+	let previous;
+	const sharing = options.structuralSharing ?? true;
+	const rerun = async () => {
+		latest += 1;
+		const run = latest;
+		let result;
+		try {
+			result = await query();
+		} catch (cause) {
+			result = err(toDbError(cause));
+		}
+		if (run !== latest || controller.signal.aborted) return;
+		if (sharing) {
+			const shared = shareStructure(previous, result);
+			if (shared === previous) return;
+			result = shared;
+		}
+		previous = result;
+		options.onResult(result);
+	};
+	rerun();
+	const unsubscribe = db.onChange({ onChange: rerun }, {
+		tables: [...options.tables],
+		signal: controller.signal,
+		...options.throttleMs === void 0 ? {} : { throttleMs: options.throttleMs }
+	});
+	const timer = refresh.everyMs === void 0 ? void 0 : setInterval(() => {
+		if (db.currentStatus?.connected === false) return;
+		rerun();
+	}, refresh.everyMs);
+	let connected = db.currentStatus?.connected ?? true;
+	const unlisten = refresh.onReconnect && db.registerListener ? db.registerListener({ statusChanged: (status) => {
+		const reconnected = status.connected && !connected;
+		connected = status.connected;
+		if (reconnected) rerun();
+	} }) : void 0;
+	const cleanup = () => {
+		clearInterval(timer);
+		unlisten?.();
+	};
+	controller.signal.addEventListener("abort", cleanup, { once: true });
+	return () => {
+		signal?.removeEventListener("abort", stop);
+		stop();
+		unsubscribe();
+	};
+}
+/**
+* The SQLite table names of app table keys (`customerTags` to `customer_tags`).
+* Pass the executor's `tableName` when it renames tables, so `watch` listens to
+* the names the queries read.
+*/
+function sqliteTables(betterSupabase, keys, options = {}) {
+	return keys.map((key) => {
+		const table = betterSupabase.meta.tables[key];
+		if (!table) throw new TypeError(`better-supabase: unknown table "${key}"`);
+		return options.tableName ? options.tableName(table) : table.name;
+	});
+}
+//#endregion
+export { watch as n, sqliteTables as t };