better-supabase 0.12.0 → 0.14.0

package/dist/money-BNRdJQzA.d.ts

@@ -0,0 +1,91 @@
+//#region src/commerce/money.d.ts
+/**
+ * An amount in the currency's minor units (cents for EUR, yen for JPY) and an
+ * ISO 4217 code. SQL stores the same pair as `bigint` and `char(3)`.
+ */
+interface Money {
+  readonly amount: bigint;
+  readonly currency: string;
+}
+/**
+ * `Money` as JSON: the amount as a string of minor units, since JSON has no
+ * bigint.
+ */
+interface MoneyJson {
+  readonly amount: string;
+  readonly currency: string;
+}
+/**
+ * Thrown when two amounts in different currencies meet; lines never mix
+ * currencies.
+ */
+declare class CurrencyMismatchError extends TypeError {
+  readonly currencies: readonly [string, string];
+  constructor(a: string, b: string);
+}
+/** Whether `code` is an ISO 4217 code with minor units, such as `EUR`. */
+declare function isCurrency(code: unknown): code is string;
+/** The number of minor units of `currency`: 2 for EUR, 0 for JPY, 3 for KWD. */
+declare function minorUnits(currency: string): number;
+/**
+ * `Money` from an integer number of minor units: `money(1999n, "EUR")` is 19.99
+ * EUR.
+ */
+declare function money(amount: bigint | number, currency: string): Money;
+/** Whether `value` is a `Money` with a bigint amount and a known currency. */
+declare function isMoney(value: unknown): value is Money;
+/**
+ * Reads a decimal such as `"19.99"` in `currency`. More decimals than the
+ * currency has minor units throw instead of rounding.
+ */
+declare function parseMoney(decimal: string, currency: string): Money;
+/**
+ * The amount as a decimal string with every minor unit: `"19.90"`, `"500"` for
+ * JPY.
+ */
+declare function toDecimal(value: Money): string;
+/**
+ * Formats with `Intl.NumberFormat`, passing the exact decimal string so large
+ * amounts keep every digit.
+ */
+declare function formatMoney(value: Money, locale?: Intl.LocalesArgument, options?: Omit<Intl.NumberFormatOptions, "style" | "currency">): string;
+/** `{ amount: "1999", currency: "EUR" }`, for JSON bodies and `jsonb` columns. */
+declare function moneyToJson(value: Money): MoneyJson;
+/** Reads `MoneyJson` back; throws for anything else. */
+declare function moneyFromJson(value: unknown): Money;
+declare function addMoney(a: Money, b: Money): Money;
+declare function subtractMoney(a: Money, b: Money): Money;
+/** The total of `values`, all in `currency`; zero for an empty list. */
+declare function sumMoney(values: readonly Money[], currency: string): Money;
+/**
+ * `value` times a whole `quantity`, such as a unit price times the line's
+ * quantity.
+ */
+declare function multiplyMoney(value: Money, quantity: bigint | number): Money;
+declare function negateMoney(value: Money): Money;
+/** -1, 0 or 1; throws for different currencies. */
+declare function compareMoney(a: Money, b: Money): -1 | 0 | 1;
+/**
+ * `numerator / denominator` rounded half to even (banker's rounding): ties go
+ * to the even neighbour, so rounding many lines doesn't drift one way.
+ */
+declare function roundHalfEven(numerator: bigint, denominator: bigint): bigint;
+/** Whether `rate` is a non-negative decimal fraction such as `"0.21"`. */
+declare function isRate(rate: unknown): rate is string;
+/**
+ * `value` times `rate` (a decimal fraction such as `"0.21"`), rounded half to
+ * even. With `included: true`, `value` already contains the rate (a
+ * tax-inclusive price) and the result is the part the rate accounts for: `value *
+ * rate / (1 + rate)`.
+ */
+declare function applyRate(value: Money, rate: string, options?: {
+  readonly included?: boolean;
+}): Money;
+/**
+ * Splits `value` by `weights` so the parts add up to it exactly. Each part is
+ * rounded down, and the leftover minor units go to the largest remainders,
+ * earlier parts first on a tie.
+ */
+declare function allocateMoney(value: Money, weights: readonly (bigint | number)[]): Money[];
+//#endregion
+export { toDecimal as S, negateMoney as _, allocateMoney as a, subtractMoney as b, formatMoney as c, isRate as d, minorUnits as f, multiplyMoney as g, moneyToJson as h, addMoney as i, isCurrency as l, moneyFromJson as m, Money as n, applyRate as o, money as p, MoneyJson as r, compareMoney as s, CurrencyMismatchError as t, isMoney as u, parseMoney as v, sumMoney as x, roundHalfEven as y };

package/dist/money-BZl985O-.js

@@ -0,0 +1,197 @@
+import { t as ISO_4217_MINOR_UNITS } from "./iso4217-B-durg_y.js";
+//#region src/commerce/money.ts
+/**
+* Thrown when two amounts in different currencies meet; lines never mix
+* currencies.
+*/
+var CurrencyMismatchError = class extends TypeError {
+	currencies;
+	constructor(a, b) {
+		super(`Can't combine ${a} and ${b}: amounts must share one currency`);
+		this.name = "CurrencyMismatchError";
+		this.currencies = [a, b];
+	}
+};
+const RATE = /^(\d+)(?:\.(\d+))?$/;
+const DECIMAL = /^(-)?(\d+)(?:\.(\d+))?$/;
+/** Whether `code` is an ISO 4217 code with minor units, such as `EUR`. */
+function isCurrency(code) {
+	return typeof code === "string" && Object.hasOwn(ISO_4217_MINOR_UNITS, code);
+}
+/** The number of minor units of `currency`: 2 for EUR, 0 for JPY, 3 for KWD. */
+function minorUnits(currency) {
+	if (!isCurrency(currency)) throw new RangeError(`"${String(currency)}" is not an ISO 4217 currency code with minor units`);
+	return ISO_4217_MINOR_UNITS[currency] ?? 0;
+}
+/**
+* `Money` from an integer number of minor units: `money(1999n, "EUR")` is 19.99
+* EUR.
+*/
+function money(amount, currency) {
+	minorUnits(currency);
+	if (typeof amount === "number" && !Number.isSafeInteger(amount)) throw new RangeError(`${amount} is not a whole number of minor units; use parseMoney for a decimal`);
+	return Object.freeze({
+		amount: BigInt(amount),
+		currency
+	});
+}
+/** Whether `value` is a `Money` with a bigint amount and a known currency. */
+function isMoney(value) {
+	return typeof value === "object" && value !== null && "amount" in value && "currency" in value && typeof value.amount === "bigint" && isCurrency(value.currency);
+}
+/**
+* Reads a decimal such as `"19.99"` in `currency`. More decimals than the
+* currency has minor units throw instead of rounding.
+*/
+function parseMoney(decimal, currency) {
+	const units = minorUnits(currency);
+	const match = DECIMAL.exec(decimal.trim());
+	if (!match) throw new RangeError(`"${decimal}" is not a decimal amount`);
+	const [, sign, whole = "0", fraction = ""] = match;
+	if (fraction.length > units) throw new RangeError(`"${decimal}" has more decimals than ${currency}'s ${units} minor units`);
+	const amount = BigInt(whole + fraction.padEnd(units, "0"));
+	return money(sign === "-" ? -amount : amount, currency);
+}
+/**
+* The amount as a decimal string with every minor unit: `"19.90"`, `"500"` for
+* JPY.
+*/
+function toDecimal(value) {
+	const units = minorUnits(value.currency);
+	const negative = value.amount < 0n;
+	const digits = (negative ? -value.amount : value.amount).toString().padStart(units + 1, "0");
+	const whole = digits.slice(0, digits.length - units);
+	const fraction = units === 0 ? "" : `.${digits.slice(-units)}`;
+	return `${negative ? "-" : ""}${whole}${fraction}`;
+}
+/**
+* Formats with `Intl.NumberFormat`, passing the exact decimal string so large
+* amounts keep every digit.
+*/
+function formatMoney(value, locale, options = {}) {
+	return new Intl.NumberFormat(locale, {
+		...options,
+		style: "currency",
+		currency: value.currency
+	}).format(toDecimal(value));
+}
+/** `{ amount: "1999", currency: "EUR" }`, for JSON bodies and `jsonb` columns. */
+function moneyToJson(value) {
+	return {
+		amount: value.amount.toString(),
+		currency: value.currency
+	};
+}
+/** Reads `MoneyJson` back; throws for anything else. */
+function moneyFromJson(value) {
+	if (typeof value !== "object" || value === null || !("amount" in value) || !("currency" in value) || typeof value.amount !== "string" || typeof value.currency !== "string" || !/^-?\d+$/.test(value.amount)) throw new TypeError("Money JSON is { amount: \"<minor units>\", currency: \"<ISO 4217 code>\" }");
+	return money(BigInt(value.amount), value.currency);
+}
+const sameCurrency = (a, b) => {
+	if (a.currency !== b.currency) throw new CurrencyMismatchError(a.currency, b.currency);
+};
+function addMoney(a, b) {
+	sameCurrency(a, b);
+	return money(a.amount + b.amount, a.currency);
+}
+function subtractMoney(a, b) {
+	sameCurrency(a, b);
+	return money(a.amount - b.amount, a.currency);
+}
+/** The total of `values`, all in `currency`; zero for an empty list. */
+function sumMoney(values, currency) {
+	let total = money(0n, currency);
+	for (const value of values) total = addMoney(total, value);
+	return total;
+}
+/**
+* `value` times a whole `quantity`, such as a unit price times the line's
+* quantity.
+*/
+function multiplyMoney(value, quantity) {
+	if (typeof quantity === "number" && !Number.isSafeInteger(quantity)) throw new RangeError(`${quantity} is not a whole quantity`);
+	return money(value.amount * BigInt(quantity), value.currency);
+}
+function negateMoney(value) {
+	return money(-value.amount, value.currency);
+}
+/** -1, 0 or 1; throws for different currencies. */
+function compareMoney(a, b) {
+	sameCurrency(a, b);
+	if (a.amount === b.amount) return 0;
+	return a.amount < b.amount ? -1 : 1;
+}
+/**
+* `numerator / denominator` rounded half to even (banker's rounding): ties go
+* to the even neighbour, so rounding many lines doesn't drift one way.
+*/
+function roundHalfEven(numerator, denominator) {
+	if (denominator === 0n) throw new RangeError("Division by zero");
+	const [n, d] = denominator < 0n ? [-numerator, -denominator] : [numerator, denominator];
+	const quotient = n / d;
+	const remainder = n % d;
+	const twice = 2n * (remainder < 0n ? -remainder : remainder);
+	if (twice < d) return quotient;
+	const away = n < 0n ? quotient - 1n : quotient + 1n;
+	if (twice > d) return away;
+	return quotient % 2n === 0n ? quotient : away;
+}
+/** Whether `rate` is a non-negative decimal fraction such as `"0.21"`. */
+function isRate(rate) {
+	return typeof rate === "string" && RATE.test(rate);
+}
+const rateParts = (rate) => {
+	const match = RATE.exec(rate);
+	if (!match) throw new RangeError(`"${rate}" is not a rate; write a decimal fraction such as "0.21"`);
+	const [, whole = "0", fraction = ""] = match;
+	return [BigInt(whole + fraction), 10n ** BigInt(fraction.length)];
+};
+/**
+* `value` times `rate` (a decimal fraction such as `"0.21"`), rounded half to
+* even. With `included: true`, `value` already contains the rate (a
+* tax-inclusive price) and the result is the part the rate accounts for: `value *
+* rate / (1 + rate)`.
+*/
+function applyRate(value, rate, options = {}) {
+	const [numerator, denominator] = rateParts(rate);
+	const divisor = options.included ? denominator + numerator : denominator;
+	return money(roundHalfEven(value.amount * numerator, divisor), value.currency);
+}
+/**
+* Splits `value` by `weights` so the parts add up to it exactly. Each part is
+* rounded down, and the leftover minor units go to the largest remainders,
+* earlier parts first on a tie.
+*/
+function allocateMoney(value, weights) {
+	const shares = weights.map((weight) => {
+		if (typeof weight === "number" && !Number.isSafeInteger(weight)) throw new RangeError(`${weight} is not a whole weight`);
+		const share = BigInt(weight);
+		if (share < 0n) throw new RangeError("Weights can't be negative");
+		return share;
+	});
+	const total = shares.reduce((sum, share) => sum + share, 0n);
+	if (total === 0n) throw new RangeError("Weights must add up to more than 0");
+	const negative = value.amount < 0n;
+	const amount = negative ? -value.amount : value.amount;
+	const parts = shares.map((share) => ({
+		base: amount * share / total,
+		remainder: amount * share % total
+	}));
+	let left = amount - parts.reduce((sum, part) => sum + part.base, 0n);
+	const order = parts.map((part, index) => ({
+		index,
+		remainder: part.remainder
+	})).toSorted((a, b) => a.remainder === b.remainder ? a.index - b.index : a.remainder > b.remainder ? -1 : 1);
+	const extra = /* @__PURE__ */ new Set();
+	for (const { index } of order) {
+		if (left === 0n) break;
+		extra.add(index);
+		left -= 1n;
+	}
+	return parts.map((part, index) => {
+		const share = part.base + (extra.has(index) ? 1n : 0n);
+		return money(negative ? -share : share, value.currency);
+	});
+}
+//#endregion
+export { roundHalfEven as _, compareMoney as a, toDecimal as b, isMoney as c, money as d, moneyFromJson as f, parseMoney as g, negateMoney as h, applyRate as i, isRate as l, multiplyMoney as m, addMoney as n, formatMoney as o, moneyToJson as p, allocateMoney as r, isCurrency as s, CurrencyMismatchError as t, minorUnits as u, subtractMoney as v, sumMoney as y };

package/dist/money-codec-jMP0PQLZ.js

@@ -0,0 +1,41 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { a as bigintOf, x as optionalBigintOf } from "./block-helpers-CiKtrb6g.js";
+import { d as money, s as isCurrency } from "./money-BZl985O-.js";
+//#region src/blocks/money-codec.ts
+/**
+* `Money` from an amount block functions send as text and its currency. Throws
+* for a number (precision is already lost), a missing amount or a code ISO 4217
+* doesn't list.
+*/
+const moneyOf = (amount, currency, field = "amount") => money(bigintOf(amount, field), String(currency));
+/** `moneyOf`, or `undefined` when the amount is null. */
+function optionalMoneyOf(amount, currency, field = "amount") {
+	const found = optionalBigintOf(amount, field);
+	return found === void 0 ? void 0 : money(found, String(currency));
+}
+/** A `Money` as a function argument: minor units as text. */
+const amountText = (value) => value.amount.toString();
+/** An optional `Money` as a function argument, `null` when absent. */
+const optionalAmountText = (value) => value === void 0 || value === null ? null : amountText(value);
+/**
+* The `invalid_request` error for amounts that don't share `currency`, or
+* `undefined` when they all do. Amounts that are `undefined` are skipped.
+*/
+function currencyMismatch(currency, amounts) {
+	const present = amounts.filter((item) => item !== void 0);
+	const expected = currency ?? present[0]?.currency;
+	const other = present.find((item) => item.currency !== expected);
+	return other === void 0 || expected === void 0 ? void 0 : dbError("invalid_request", `Can't combine ${expected} and ${other.currency}: amounts must share one currency`, { hint: "CURRENCY_MISMATCH" });
+}
+/** The `invalid_request` error for a currency ISO 4217 doesn't list. */
+const unknownCurrency = (currency) => dbError("invalid_request", `${currency} is not an ISO 4217 currency code`, { hint: "CURRENCY_INVALID" });
+/**
+* Why amounts can't be written in `currency`, or `undefined` when they can: the
+* currency is unknown, or an amount is in another one.
+*/
+function amountsError(currency, amounts) {
+	if (currency !== void 0 && !isCurrency(currency)) return unknownCurrency(currency);
+	return currencyMismatch(currency, amounts);
+}
+//#endregion
+export { optionalAmountText as a, moneyOf as i, amountsError as n, optionalMoneyOf as o, currencyMismatch as r, unknownCurrency as s, amountText as t };

package/dist/my-work-kinds-BU3SlA-6.js

@@ -0,0 +1,11 @@
+//#region src/blocks/subjects/my-work-kinds.ts
+/** The kinds `my_work` returns, in the order the docs list them. */
+const MY_WORK_KINDS = [
+	"assigned",
+	"approval",
+	"reminder",
+	"mention",
+	"sla"
+];
+//#endregion
+export { MY_WORK_KINDS as t };

package/dist/nestjs/index.d.ts

@@ -1,10 +1,13 @@
-import { n as RouteGuardOptions } from "../refusal-C7geIBRl.js";
-import { t as Validated } from "../shared-DDSjEGDR.js";
-import { l as ToNodeOptions } from "../index-QWTq2o31.js";
+import { n as RouteGuardOptions } from "../refusal-efy5bZMd.js";
+import { t as Validated } from "../shared-CRRfQAKG.js";
+import { l as ToNodeOptions } from "../index-BgSuw4CC.js";
 import { AnyEntry } from "@supabase/middleware";
 import { IncomingMessage, ServerResponse } from "node:http";
 //#region src/nestjs/index.d.ts
-/** The part of Nest's `ArgumentsHost` and `ExecutionContext` the integration reads. */
+/**
+ * The part of Nest's `ArgumentsHost` and `ExecutionContext` the integration
+ * reads.
+ */
 export interface ExecutionContextLike {
   switchToHttp(): {
     getRequest(): object;
@@ -15,23 +18,35 @@ export interface ExecutionContextLike {
 export interface CanActivateLike {
   canActivate(context: ExecutionContextLike): Promise<boolean>;
 }
-/** A Nest exception filter instance, for `@UseFilters(...)` or `app.useGlobalFilters(...)`. */
+/**
+ * A Nest exception filter instance, for `@UseFilters(...)` or
+ * `app.useGlobalFilters(...)`.
+ */
 export interface ExceptionFilterLike {
   catch(exception: unknown, host: ExecutionContextLike): void;
 }
-/** Nest functional middleware: raw Node `req` and `res` under Express and Fastify. */
+/**
+ * Nest functional middleware: raw Node `req` and `res` under Express and
+ * Fastify.
+ */
 export type NestMiddleware = (req: IncomingMessage, res: ServerResponse, next: (error?: unknown) => void) => void;
-/** The contributions `toNestMiddleware` stored for a request (Express or Fastify), if it ran. */
+/**
+ * The contributions `toNestMiddleware` stored for a request (Express or
+ * Fastify), if it ran.
+ */
 export declare function contextOf(request: object): Readonly<Record<string, unknown>> | undefined;
 /**
- * Nest middleware that runs the entries before the route: a short circuit
- * (a 401, a CORS preflight) is the answer; otherwise the entries' cookies
- * go on the response and `@Ctx()` reads the contributions.
+ * Nest middleware that runs the entries before the route: a short circuit (a
+ * 401, a CORS preflight) is the answer; otherwise the entries' cookies go on
+ * the response and `@Ctx()` reads the contributions.
  *
- * ```ts title="src/app.module.ts"
+ * ```ts
+ * // src/app.module.ts
  * export class AppModule implements NestModule {
  *   configure(consumer: MiddlewareConsumer) {
- *     consumer.apply(toNestMiddleware([withBetterSupabase(server)])).forRoutes('*')
+ *     consumer
+ *       .apply(toNestMiddleware([withBetterSupabase(server)]))
+ *       .forRoutes("*");
  *   }
  * }
  * ```
@@ -48,8 +63,8 @@ export declare function toNestMiddleware<const Entries extends readonly AnyEntry
  */
 export declare function Ctx(key?: string): ParameterDecorator;
 /**
- * A guard instance that refuses callers outside `options`: Problem Details,
- * or a 303 to `signIn` or `mfa`, thrown as Nest's `HttpException`.
+ * A guard instance that refuses callers outside `options`: Problem Details, or
+ * a 303 to `signIn` or `mfa`, thrown as Nest's `HttpException`.
  *
  * ```ts
  * @UseGuards(guard({ roles: ['admin'] }))
@@ -57,9 +72,9 @@ export declare function Ctx(key?: string): ParameterDecorator;
  */
 export declare function guard(options?: RouteGuardOptions): CanActivateLike;
 /**
- * An exception filter that answers thrown `DbException`s (from
- * `.orThrow()`) with Problem Details. Register it with `@Catch()` scope in
- * mind: other exceptions are answered the way Nest's base filter does.
+ * An exception filter that answers thrown `DbException`s (from `.orThrow()`)
+ * with Problem Details. Register it with `@Catch()` scope in mind: other
+ * exceptions are answered the way Nest's base filter does.
  */
 export declare function problemFilter(options?: {
   readonly expose?: boolean;

package/dist/nestjs/index.js

@@ -1,11 +1,14 @@
-import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../refusal-CFpfmjcS.js";
-import { t as beforeRoute } from "../before-route-B98js9m_.js";
+import { a as routeRefusal, n as guardedLocals, t as errorResponse } from "../refusal-DXydjgsS.js";
+import { t as beforeRoute } from "../before-route-B23K2zYU.js";
 import { t as applyWebHeaders } from "../node-headers-C71zNQHe.js";
-import { n as toWebRequest, t as sendWebResponse } from "../http-Cv4T29xh.js";
+import { n as toWebRequest, t as sendWebResponse } from "../http-BjjojWg3.js";
 import { createRequire } from "node:module";
 //#region src/nestjs/index.ts
 const contexts = /* @__PURE__ */ new WeakMap();
-/** The Node request under an Express request or a Fastify request (`request.raw`). */
+/**
+* The Node request under an Express request or a Fastify request
+* (`request.raw`).
+*/
 function rawOf(value) {
 	return "raw" in value && typeof value.raw === "object" && value.raw !== null ? value.raw : value;
 }
@@ -20,7 +23,10 @@ function responseOf(host) {
 function requestOf(host) {
 	return rawOf(host.switchToHttp().getRequest());
 }
-/** The contributions `toNestMiddleware` stored for a request (Express or Fastify), if it ran. */
+/**
+* The contributions `toNestMiddleware` stored for a request (Express or
+* Fastify), if it ran.
+*/
 function contextOf(request) {
 	return contexts.get(rawOf(request));
 }
@@ -36,14 +42,17 @@ async function continueWith(step, next) {
 	if (proceed) next();
 }
 /**
-* Nest middleware that runs the entries before the route: a short circuit
-* (a 401, a CORS preflight) is the answer; otherwise the entries' cookies
-* go on the response and `@Ctx()` reads the contributions.
+* Nest middleware that runs the entries before the route: a short circuit (a
+* 401, a CORS preflight) is the answer; otherwise the entries' cookies go on
+* the response and `@Ctx()` reads the contributions.
 *
-* ```ts title="src/app.module.ts"
+* ```ts
+* // src/app.module.ts
 * export class AppModule implements NestModule {
 *   configure(consumer: MiddlewareConsumer) {
-*     consumer.apply(toNestMiddleware([withBetterSupabase(server)])).forRoutes('*')
+*     consumer
+*       .apply(toNestMiddleware([withBetterSupabase(server)]))
+*       .forRoutes("*");
 *   }
 * }
 * ```
@@ -73,9 +82,9 @@ function isNestCommon(value) {
 const NEST_COMMON = "@nestjs/common";
 let nest;
 /**
-* `@nestjs/common` is an optional peer, loaded on first use with a
-* variable specifier so apps on other frameworks never resolve it. It is
-* required synchronously because decorators run while the class is defined.
+* `@nestjs/common` is an optional peer, loaded on first use with a variable
+* specifier so apps on other frameworks never resolve it. It is required
+* synchronously because decorators run while the class is defined.
 */
 function nestCommon() {
 	if (nest) return nest;
@@ -108,8 +117,8 @@ function Ctx(key) {
 	return ctxDecorator(key);
 }
 /**
-* A guard instance that refuses callers outside `options`: Problem Details,
-* or a 303 to `signIn` or `mfa`, thrown as Nest's `HttpException`.
+* A guard instance that refuses callers outside `options`: Problem Details, or
+* a 303 to `signIn` or `mfa`, thrown as Nest's `HttpException`.
 *
 * ```ts
 * @UseGuards(guard({ roles: ['admin'] }))
@@ -130,9 +139,9 @@ function guard(options = {}) {
 	} };
 }
 /**
-* An exception filter that answers thrown `DbException`s (from
-* `.orThrow()`) with Problem Details. Register it with `@Catch()` scope in
-* mind: other exceptions are answered the way Nest's base filter does.
+* An exception filter that answers thrown `DbException`s (from `.orThrow()`)
+* with Problem Details. Register it with `@Catch()` scope in mind: other
+* exceptions are answered the way Nest's base filter does.
 */
 function problemFilter(options = {}) {
 	return { catch(exception, host) {

package/dist/next/client/index.d.ts

@@ -20,15 +20,16 @@ export interface SessionChangeOptions {
   readonly refreshToken?: TokenRefresher;
 }
 /**
- * After a session change, expire the server cache (`changed`), navigate,
- * then refresh the client router. `refresh()` in a Server Action leaves
- * prefetched private App Shells, so `router.push` alone shows the old
- * session. Pass a next-intl (or other) router when `push` must keep the
- * locale prefix.
+ * After a session change, expire the server cache (`changed`), navigate, then
+ * refresh the client router. `refresh()` in a Server Action leaves prefetched
+ * private App Shells, so `router.push` alone shows the old session. Pass a
+ * next-intl (or other) router when `push` must keep the locale prefix.
  *
  * ```ts
- * const switched = useSessionChange(sessionChanged, router, { refreshToken: useSupabase() });
- * await switched('/dashboard');
+ * const switched = useSessionChange(sessionChanged, router, {
+ *   refreshToken: useSupabase(),
+ * });
+ * await switched("/dashboard");
  * ```
  */
 export declare function useSessionChange(changed: () => Promise<void>, router?: SessionChangeRouter, options?: SessionChangeOptions): (to?: string) => Promise<void>;

package/dist/next/client/index.js

@@ -3,15 +3,16 @@ import { useCallback } from "react";
 import { useRouter } from "next/navigation.js";
 //#region src/next/client/index.ts
 /**
-* After a session change, expire the server cache (`changed`), navigate,
-* then refresh the client router. `refresh()` in a Server Action leaves
-* prefetched private App Shells, so `router.push` alone shows the old
-* session. Pass a next-intl (or other) router when `push` must keep the
-* locale prefix.
+* After a session change, expire the server cache (`changed`), navigate, then
+* refresh the client router. `refresh()` in a Server Action leaves prefetched
+* private App Shells, so `router.push` alone shows the old session. Pass a
+* next-intl (or other) router when `push` must keep the locale prefix.
 *
 * ```ts
-* const switched = useSessionChange(sessionChanged, router, { refreshToken: useSupabase() });
-* await switched('/dashboard');
+* const switched = useSessionChange(sessionChanged, router, {
+*   refreshToken: useSupabase(),
+* });
+* await switched("/dashboard");
 * ```
 */
 function useSessionChange(changed, router, options = {}) {

package/dist/next/image/index.d.ts

@@ -12,19 +12,21 @@ export interface ImageLoaderOptions {
   /** Resize mode for the transform. Defaults to Storage's own (`cover`). */
   readonly resize?: "cover" | "contain" | "fill";
   /**
-   * For images that are not public Storage objects (local files, other
-   * hosts). Defaults to returning `src` unchanged.
+   * For images that are not public Storage objects (local files, other hosts).
+   * Defaults to returning `src` unchanged.
    */
   readonly fallback?: ImageLoader;
 }
 /**
- * A `next/image` loader that serves public Storage objects through
- * Supabase image transformations (`/render/image/public`), so Next.js does
- * not proxy or re-encode them:
+ * A `next/image` loader that serves public Storage objects through Supabase
+ * image transformations (`/render/image/public`), so Next.js does not proxy or
+ * re-encode them:
  *
  * ```ts
  * // src/image-loader.ts, set as `images.loaderFile` in next.config.ts
- * export default createImageLoader({ url: process.env.NEXT_PUBLIC_SUPABASE_URL! });
+ * export default createImageLoader({
+ *   url: process.env.NEXT_PUBLIC_SUPABASE_URL!,
+ * });
  * ```
  *
  * Signed URLs pass through unchanged: their token covers the transform they

package/dist/next/image/index.js

@@ -1,13 +1,15 @@
-import { t as storageImageUrl } from "../../image-url-pIVlO6R1.js";
+import { i as storageImageUrl } from "../../image-url-_d7xYsXK.js";
 //#region src/next/image/index.ts
 /**
-* A `next/image` loader that serves public Storage objects through
-* Supabase image transformations (`/render/image/public`), so Next.js does
-* not proxy or re-encode them:
+* A `next/image` loader that serves public Storage objects through Supabase
+* image transformations (`/render/image/public`), so Next.js does not proxy or
+* re-encode them:
 *
 * ```ts
 * // src/image-loader.ts, set as `images.loaderFile` in next.config.ts
-* export default createImageLoader({ url: process.env.NEXT_PUBLIC_SUPABASE_URL! });
+* export default createImageLoader({
+*   url: process.env.NEXT_PUBLIC_SUPABASE_URL!,
+* });
 * ```
 *
 * Signed URLs pass through unchanged: their token covers the transform they