better-supabase 0.11.0 → 0.13.0

package/dist/react-DzukE6Wp.js

@@ -1,410 +0,0 @@
-import { n as dbError } from "./errors-BV1SKTVs.js";
-import { t as escapeLike } from "./escape-like-DHfx6jRr.js";
-import { r as err, s as toDbError } from "./result-DIeYscA3.js";
-import { t as ClientContext } from "./context-wDKxSl9x.js";
-import "./react/session.js";
-import { c as useBroadcastAuth } from "./sign-in-z2BaBdps.js";
-import { t as fieldErrorsOf } from "./field-errors-DZVRWRkf.js";
-import { n as ttlSeconds } from "./ttl-Hr34gRu8.js";
-import { useCallback, useContext, useEffect, useMemo, useRef, useState, useTransition } from "react";
-//#region src/react/actions.ts
-const IDLE$1 = {
-	data: void 0,
-	error: void 0
-};
-/**
-* Calls a Server Action from an event handler: tracks pending inputs and the
-* last result, and calls `onSuccess` or `onError`.
-*
-* ```tsx
-* const remove = useAction(removeMember, { onError: (e) => toast.error(message(e)) });
-* <Button disabled={remove.pendingInputs.some((p) => p.userId === id)} onClick={() => remove.run({ userId: id })} />
-* ```
-*/
-function useAction(action, options = {}) {
-	const [transitioning, startTransition] = useTransition();
-	const [inFlight, setInFlight] = useState([]);
-	const [settled, setSettled] = useState(IDLE$1);
-	const latest = useRef({
-		action,
-		options
-	});
-	latest.current = {
-		action,
-		options
-	};
-	const run = useCallback((input) => {
-		const entry = { input };
-		setInFlight((current) => [...current, entry]);
-		setSettled((current) => current.error === void 0 ? current : {
-			...current,
-			error: void 0
-		});
-		const settledRun = new Promise((resolve, reject) => {
-			const done = () => {
-				setInFlight((current) => current.filter((item) => item !== entry));
-			};
-			startTransition(async () => {
-				let result;
-				try {
-					result = await latest.current.action(input);
-				} catch (cause) {
-					done();
-					reject(cause instanceof Error ? cause : new Error(String(cause)));
-					throw cause;
-				}
-				done();
-				setSettled(result.ok ? {
-					data: result.data,
-					error: void 0
-				} : (current) => ({
-					data: current.data,
-					error: result.error
-				}));
-				const { onSuccess, onError } = latest.current.options;
-				if (result.ok) onSuccess?.(result.data, input);
-				else onError?.(result.error, input);
-				resolve(result);
-			});
-		});
-		settledRun.catch(() => void 0);
-		return settledRun;
-	}, []);
-	const reset = useCallback(() => {
-		setSettled(IDLE$1);
-	}, []);
-	const pendingInputs = inFlight.map((item) => item.input);
-	return {
-		run,
-		pending: transitioning || inFlight.length > 0,
-		pendingInputs,
-		pendingInput: pendingInputs.at(-1),
-		data: settled.data,
-		error: settled.error,
-		reset
-	};
-}
-/**
-* A `<form>` that submits `FormData` to a Server Action. Fields keep what
-* the user typed when the action fails (a `<form action>` resets them) and
-* clear only on success.
-*
-* ```tsx
-* const form = useActionForm(createCustomer, { onSuccess: () => toast.success('Saved') });
-* <form {...form.formProps}>
-*   <Input name="name" aria-invalid={form.fieldErrors.name !== undefined} />
-* </form>
-* ```
-*/
-function useActionForm(action, options = {}) {
-	const handle = useAction(action);
-	return {
-		formProps: { onSubmit: (event) => {
-			event.preventDefault();
-			const form = event.currentTarget;
-			handle.run(new FormData(form)).then((result) => {
-				if (!result.ok) {
-					options.onError?.(result.error, form);
-					return;
-				}
-				if (options.resetOnSuccess ?? true) form.reset();
-				options.onSuccess?.(result.data, form);
-			}, () => void 0);
-		} },
-		pending: handle.pending,
-		data: handle.data,
-		error: handle.error,
-		fieldErrors: fieldErrorsOf(handle.error),
-		reset: () => {
-			handle.reset();
-		}
-	};
-}
-//#endregion
-//#region src/react/presence.ts
-const NONE = [];
-const NO_HANDLERS = {};
-const notJoined = () => Promise.resolve(dbError("invalid_request", "better-supabase: the presence topic is not joined"));
-/**
-* Joins a presence topic while mounted and returns who is on it. Pass
-* `null` values to pause. It rejoins when the topic or the user changes.
-*
-* ```tsx
-* const { members } = usePresence(roomTopic, { roomId }, { state: { name } });
-* ```
-*/
-function usePresence(topic, values, options = {}) {
-	const context = useContext(ClientContext);
-	const supabase = options.client ?? context?.client.supabase;
-	if (!supabase) throw new Error("better-supabase: usePresence needs <BetterSupabaseProvider client={bs}> or { client: supabase }");
-	const auth = useBroadcastAuth(options.client === void 0 ? context?.client : void 0, supabase);
-	const [members, setMembers] = useState(NONE);
-	const [status, setStatus] = useState("closed");
-	const joinedRef = useRef(null);
-	const trackedKey = useRef(void 0);
-	const name = values ? topic.topic(values) : null;
-	const userId = auth.userId;
-	const state = options.state;
-	const stateKey = state === void 0 ? void 0 : JSON.stringify(state);
-	const latest = useRef({
-		state,
-		stateKey
-	});
-	latest.current = {
-		state,
-		stateKey
-	};
-	useEffect(() => {
-		if (!name || auth.status === "loading") return;
-		const matched = topic.match(name);
-		if (!matched) return;
-		const joined = topic.subscribe(supabase, matched, NO_HANDLERS, {
-			onStatus: setStatus,
-			onPresence: setMembers
-		});
-		joinedRef.current = joined;
-		syncState(joined, latest.current, trackedKey);
-		return () => {
-			joinedRef.current = null;
-			trackedKey.current = void 0;
-			setMembers(NONE);
-			setStatus("closed");
-			joined.unsubscribe();
-		};
-	}, [
-		supabase,
-		topic,
-		name,
-		userId,
-		auth.status
-	]);
-	useEffect(() => {
-		const joined = joinedRef.current;
-		if (joined) syncState(joined, {
-			state: latest.current.state,
-			stateKey
-		}, trackedKey);
-	}, [stateKey]);
-	return {
-		members,
-		status,
-		...useMemo(() => ({
-			track: async (next) => {
-				const joined = joinedRef.current;
-				if (!joined) return notJoined();
-				const result = await joined.track(next);
-				return result.ok ? void 0 : result.error;
-			},
-			untrack: async () => {
-				const joined = joinedRef.current;
-				if (!joined) return notJoined();
-				const result = await joined.untrack();
-				return result.ok ? void 0 : result.error;
-			}
-		}), [])
-	};
-}
-/** Tracks or untracks the `state` option once per distinct value. */
-function syncState(joined, current, tracked) {
-	if (current.stateKey === void 0 || current.stateKey === tracked.current) return;
-	tracked.current = current.stateKey;
-	if (current.state === null || current.state === void 0) joined.untrack();
-	else joined.track(current.state);
-}
-//#endregion
-//#region src/react/search.ts
-/**
-* A search box's value, debounced. Pass `term` to `contains` (which
-* escapes it) or `pattern` to `ilike`; both are `undefined` while empty.
-*
-* ```tsx
-* const search = useDebouncedSearch();
-* useQuery(q.customers.findMany({ where: search.term ? { name: { contains: search.term } } : {} }));
-* ```
-*/
-function useDebouncedSearch(initial = "", options = {}) {
-	const delayMs = options.delayMs ?? 250;
-	const minLength = options.minLength ?? 1;
-	const [value, setValue] = useState(initial);
-	const [settled, setSettled] = useState(initial);
-	useEffect(() => {
-		if (value === settled) return;
-		const timer = setTimeout(() => {
-			setSettled(value);
-		}, delayMs);
-		return () => {
-			clearTimeout(timer);
-		};
-	}, [
-		value,
-		settled,
-		delayMs
-	]);
-	const trimmed = settled.trim();
-	const term = trimmed.length >= minLength ? trimmed : void 0;
-	return {
-		value,
-		setValue,
-		term,
-		pattern: term === void 0 ? void 0 : `%${escapeLike(term)}%`,
-		pending: value !== settled
-	};
-}
-//#endregion
-//#region src/react/storage.ts
-/** Re-sign this share of the TTL before the URL expires. */
-const REFRESH_AT = .9;
-/**
-* A signed URL for an object, signed again before it expires. Pass `null`
-* as the target to pause. Connect the bucket with `cacheSignedUrls: true`
-* so components showing the same object share one URL.
-*
-* ```tsx
-* const { url } = useSignedUrl(avatars, user ? { userId: user.id } : null, { ttl: 'hour' });
-* ```
-*/
-function useSignedUrl(bucket, target, options = {}) {
-	const key = target === null || target === void 0 ? null : JSON.stringify([target, options]);
-	const [state, setState] = useState({
-		key: null,
-		url: void 0,
-		error: void 0
-	});
-	const latest = useRef({
-		target,
-		options
-	});
-	latest.current = {
-		target,
-		options
-	};
-	const ttl = ttlSeconds(options.ttl);
-	useEffect(() => {
-		if (key === null) return;
-		let active = true;
-		const sign = () => {
-			const current = latest.current.target;
-			if (current === null || current === void 0) return;
-			bucket.signedUrl(current, latest.current.options).then((result) => {
-				if (!active) return;
-				if (!result.ok) {
-					setState((last) => ({
-						key,
-						url: last.key === key ? last.url : void 0,
-						error: result.error
-					}));
-					return;
-				}
-				setState({
-					key,
-					url: result.data,
-					error: void 0
-				});
-			});
-		};
-		sign();
-		const timer = setInterval(sign, ttl * 1e3 * REFRESH_AT);
-		return () => {
-			active = false;
-			clearInterval(timer);
-		};
-	}, [
-		bucket,
-		key,
-		ttl
-	]);
-	const fresh = key !== null && state.key === key;
-	return {
-		url: fresh ? state.url : void 0,
-		error: fresh ? state.error : void 0,
-		loading: key !== null && (!fresh || state.url === void 0 && !state.error)
-	};
-}
-const IDLE = {
-	status: "idle",
-	progress: 0,
-	data: void 0,
-	error: void 0
-};
-/**
-* Uploads to a connected bucket with progress, abort and status state.
-* Unmounting aborts the upload in flight.
-*
-* ```tsx
-* const avatar = useUpload(avatars, { onSuccess: ({ path }) => save(path) });
-* <input type="file" onChange={(e) => avatar.upload({ userId }, e.target.files[0], { upsert: true })} />
-* <progress value={avatar.progress} />
-* ```
-*/
-function useUpload(bucket, options = {}) {
-	const [state, setState] = useState(IDLE);
-	const latest = useRef({
-		controller: void 0,
-		options
-	});
-	latest.current.options = options;
-	useEffect(() => () => {
-		latest.current.controller?.abort();
-	}, []);
-	const calls = useMemo(() => {
-		const stop = () => {
-			latest.current.controller?.abort();
-			latest.current.controller = void 0;
-			setState(IDLE);
-		};
-		return {
-			upload: async (target, body, uploadOptions) => {
-				latest.current.controller?.abort();
-				const controller = new AbortController();
-				latest.current.controller = controller;
-				const mine = () => latest.current.controller === controller;
-				setState({
-					...IDLE,
-					status: "uploading"
-				});
-				let result;
-				try {
-					result = await bucket.upload(target, body, {
-						...uploadOptions,
-						signal: controller.signal,
-						onProgress: (progress) => {
-							if (mine()) setState((last) => ({
-								...last,
-								progress
-							}));
-						}
-					});
-				} catch (cause) {
-					result = err(toDbError(cause));
-				}
-				if (!mine() || controller.signal.aborted) return result;
-				latest.current.controller = void 0;
-				if (result.ok) {
-					setState({
-						status: "done",
-						progress: 1,
-						data: result.data,
-						error: void 0
-					});
-					latest.current.options.onSuccess?.(result.data);
-				} else {
-					setState((last) => ({
-						...last,
-						status: "error",
-						error: result.error
-					}));
-					latest.current.options.onError?.(result.error);
-				}
-				return result;
-			},
-			abort: stop,
-			reset: stop
-		};
-	}, [bucket]);
-	return {
-		...state,
-		...calls
-	};
-}
-//#endregion
-export { useAction as a, usePresence as i, useUpload as n, useActionForm as o, useDebouncedSearch as r, useSignedUrl as t };

package/dist/react-controller-Xn-IU44p.js

@@ -1,40 +0,0 @@
-import { useMemo, useRef, useState, useSyncExternalStore } from "react";
-//#region src/blocks/react-controller.ts
-/**
-* A controller's state and actions, rendered again when the state changes.
-* The controller is made again when `deps` change; its work starts with the
-* first subscription and stops with the last, so StrictMode's second mount
-* and an unmount need no cleanup here.
-*/
-function useController(create, deps) {
-	const [held, setHeld] = useState(() => ({
-		deps,
-		controller: create()
-	}));
-	let current = held;
-	if (changed(held.deps, deps)) {
-		current = {
-			deps,
-			controller: create()
-		};
-		setHeld(current);
-	}
-	const { controller } = current;
-	const snapshot = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
-	return {
-		controller,
-		view: useMemo(() => ({
-			...snapshot,
-			...controller.actions
-		}), [snapshot, controller])
-	};
-}
-const changed = (before, after) => before.length !== after.length || before.some((value, index) => !Object.is(value, after[index]));
-/** A ref that always holds the latest value, for callbacks a controller calls later. */
-function useLatest(value) {
-	const latest = useRef(value);
-	latest.current = value;
-	return latest;
-}
-//#endregion
-export { useLatest as n, useController as t };

package/dist/react-env-Cc7Vf6eb.js

@@ -1,13 +0,0 @@
-import { t as ClientContext } from "./context-wDKxSl9x.js";
-import { t as blockEnv } from "./block-env-CBd_SoL5.js";
-import { useContext, useMemo } from "react";
-//#region src/blocks/react-env.ts
-/** The provider's client, session and ports; the topic port defaults to its supabase-js client. */
-function useBlockEnv() {
-	const value = useContext(ClientContext);
-	if (!value) throw new Error("better-supabase: wrap your app in <BetterSupabaseProvider client={bs}>");
-	const { client } = value;
-	return useMemo(() => blockEnv(client), [client]);
-}
-//#endregion
-export { useBlockEnv as t };