limen-auth 0.0.0 → 0.0.2-beta.0

package/dist/index.d.mts

@@ -1,30 +1,14 @@
-import { A as ActiveSession, B as deriveErrorCode, C as HTTPMethod, D as User, E as Session, I as RouteHandler, L as route, M as VerifyEmailInput, N as coreClientPlugin, O as SessionState, P as RouteCallOptions, R as LimenError, S as EnvelopeMode, T as RedirectFn, _ as AuthClient, a as defineRoutes, b as EnvelopeConfig, c as AfterResponseHook, d as PluginClientOverride, f as PluginIdOf, g as RouteMatcher, h as ResponseContext, i as defineClientPlugin, j as CoreContribution, k as SessionStore, l as BeforeRequestHook, m as RequestContext, o as AnyRouteContext, p as PluginOverrides, r as RunRoute, s as RouteContext, t as AnyClientPlugin, u as FetchInit, v as ClientFetchOptions, w as ParseSession, x as EnvelopeFields, y as CreateAuthClientOptions, z as LimenErrorCode } from "./define-plugin-Dv0xXIaH.mjs";
-import { n as camelizeKeys, t as camelizeEach } from "./helpers-CvmKjWi2.mjs";
-
-//#region src/version.d.ts
-declare const VERSION: string;
-//#endregion
-//#region src/client.d.ts
-declare function createAuthClient<const Plugins extends readonly AnyClientPlugin[] = readonly [], TFields = unknown>(opts: CreateAuthClientOptions<Plugins, TFields>): AuthClient<Plugins, TFields>;
-//#endregion
-//#region src/normalize.d.ts
-/**
- * Convert snake_case User keys from server payloads to camelCase. Unknown
- * extension fields are converted with the same rule so consumers consistently
- * read camelCase in SDK responses.
- */
-declare function normalizeUser<F = unknown>(raw: Record<string, unknown>): User<F>;
-declare function defaultSessionParse<F = unknown>(raw: unknown): Session<F>;
-//#endregion
-//#region src/serialize.d.ts
-/**
- * Default request serializer: shallow camelCase → snake_case, drops `undefined`,
- * leaves non-objects unchanged.
- *
- * `additionalFields` entries are merged into the top-level body verbatim.
- * Known route fields win on key collisions.
- */
-declare function defaultSerialize(input: unknown): unknown;
-//#endregion
-export { type ActiveSession, type AfterResponseHook, type AnyRouteContext, type AuthClient, type BeforeRequestHook, type ClientFetchOptions, type CoreContribution, type CreateAuthClientOptions, type EnvelopeConfig, type EnvelopeFields, type EnvelopeMode, type FetchInit, type HTTPMethod, LimenError, type LimenErrorCode, type ParseSession, type PluginClientOverride, type PluginIdOf, type PluginOverrides, type RedirectFn, type RequestContext, type ResponseContext, type RouteCallOptions, type RouteContext, type RouteHandler, type RouteMatcher, type RunRoute, type Session, type SessionState, type SessionStore, type User, VERSION, type VerifyEmailInput, camelizeEach, camelizeKeys, coreClientPlugin, createAuthClient, defaultSerialize, defaultSessionParse, defineClientPlugin, defineRoutes, deriveErrorCode, normalizeUser, route };
-//# sourceMappingURL=index.d.mts.map
+import { VERSION } from "./version.mjs";
+import { LimenError, LimenErrorCode, deriveErrorCode } from "./errors.mjs";
+import { RouteCallOptions, RouteHandler, route } from "./route.mjs";
+import { ActiveSession, CoreContribution, VerifyEmailInput, coreClientPlugin } from "./routes.mjs";
+import { SessionState, SessionStore } from "./session-store.mjs";
+import { AuthClient, ClientFetchOptions, CreateAuthClientOptions, EnvelopeConfig, EnvelopeFields, EnvelopeMode, HTTPMethod, ParseSession, RedirectFn, Session, User } from "./types.mjs";
+import { AfterResponseHook, BeforeRequestHook, FetchInit, PluginClientOverride, PluginIdOf, PluginOverrides, RequestContext, ResponseContext, RouteMatcher } from "./plugin.mjs";
+import { AnyRouteContext, RouteContext } from "./context.mjs";
+import { RunRoute, defineClientPlugin, defineRoutes } from "./define-plugin.mjs";
+import { createAuthClient } from "./client.mjs";
+import { camelizeEach, camelizeKeys } from "./helpers.mjs";
+import { defaultSessionParse, normalizeUser } from "./normalize.mjs";
+import { defaultSerialize } from "./serialize.mjs";
+export { type ActiveSession, type AfterResponseHook, type AnyRouteContext, type AuthClient, type BeforeRequestHook, type ClientFetchOptions, type CoreContribution, type CreateAuthClientOptions, type EnvelopeConfig, type EnvelopeFields, type EnvelopeMode, type FetchInit, type HTTPMethod, LimenError, type LimenErrorCode, type ParseSession, type PluginClientOverride, type PluginIdOf, type PluginOverrides, type RedirectFn, type RequestContext, type ResponseContext, type RouteCallOptions, type RouteContext, type RouteHandler, type RouteMatcher, type RunRoute, type Session, type SessionState, type SessionStore, type User, VERSION, type VerifyEmailInput, camelizeEach, camelizeKeys, coreClientPlugin, createAuthClient, defaultSerialize, defaultSessionParse, defineClientPlugin, defineRoutes, deriveErrorCode, normalizeUser, route };

package/dist/index.mjs

@@ -1,12 +1,10 @@
-import { n as camelizeEach, r as camelizeKeys } from "./helpers-Cs3VtXdv.mjs";
-import { a as defaultSerialize, i as normalizeUser, n as coreClientPlugin, r as defaultSessionParse, t as createAuthClient } from "./client-Er91De-z.mjs";
-import { n as deriveErrorCode, t as LimenError } from "./errors-4YJYt6f0.mjs";
-import { n as defineRoutes, t as defineClientPlugin } from "./define-plugin-C7WOGU4b.mjs";
-import { t as route } from "./route-DGxvFqWl.mjs";
-//#endregion
-//#region src/version.ts
-const VERSION = "0.0.0";
-//#endregion
+import { VERSION } from "./version.mjs";
+import { camelizeEach, camelizeKeys } from "./helpers.mjs";
+import { defaultSerialize } from "./serialize.mjs";
+import { LimenError, deriveErrorCode } from "./errors.mjs";
+import { defaultSessionParse, normalizeUser } from "./normalize.mjs";
+import { defineClientPlugin, defineRoutes } from "./define-plugin.mjs";
+import { route } from "./route.mjs";
+import { coreClientPlugin } from "./routes.mjs";
+import { createAuthClient } from "./client.mjs";
 export { LimenError, VERSION, camelizeEach, camelizeKeys, coreClientPlugin, createAuthClient, defaultSerialize, defaultSessionParse, defineClientPlugin, defineRoutes, deriveErrorCode, normalizeUser, route };
-
-//# sourceMappingURL=index.mjs.map

package/dist/infer.d.mts

@@ -0,0 +1,42 @@
+import { KebabToCamel, Split, UnionToIntersection } from "./type-utils.mjs";
+import { InputOf, OutputOf, RouteCallOptions } from "./route.mjs";
+
+//#region src/infer.d.ts
+type IsParam<S extends string> = S extends `:${string}` ? true : false;
+/**
+ * Turn a route path literal into its camelCased client-chain segments, dropping
+ * leading slashes and `:param` segments. `"/otp/send"` -> `["otp", "send"]`.
+ */
+type PathSegments<P extends string> = P extends `/${infer Rest}` ? PathSegments<Rest> : P extends `${infer Head}/${infer Tail}` ? Head extends "" ? PathSegments<Tail> : IsParam<Head> extends true ? PathSegments<Tail> : [KebabToCamel<Head>, ...PathSegments<Tail>] : P extends "" ? [] : IsParam<P> extends true ? [] : [KebabToCamel<P>];
+type PathOf<R> = R extends {
+  path: infer P extends string;
+} ? P : never;
+/**
+ * The resolved chain for one route: an absolute `as` wins, otherwise it is the
+ * plugin's base-path segments followed by the route-path segments.
+ */
+type ChainSegments<R, BasePrefix extends readonly string[]> = R extends {
+  as: infer A extends string;
+} ? Split<A, "."> : [...BasePrefix, ...PathSegments<PathOf<R>>];
+type Nest<Segs extends readonly string[], Fn> = Segs extends readonly [infer Head extends string, ...infer Rest extends readonly string[]] ? string extends Head ? unknown : { [K in Head]: Nest<Rest, Fn> } : Fn;
+/**
+ * A no-input route (`I` is `void`) takes no input — only the optional, trailing
+ * call options; everything else takes `input` followed by the call options.
+ * Options are always the trailing argument so the runtime can place them
+ * unambiguously (a lone argument is always the route input).
+ */
+type InferRouteFn<I, O> = [I] extends [void] ? (input?: void, opts?: RouteCallOptions<O>) => Promise<O> : (input: I, opts?: RouteCallOptions<O>) => Promise<O>;
+type IsExposed<R> = R extends {
+  expose: false;
+} ? false : true;
+type RouteFn<R> = InferRouteFn<InputOf<R>, OutputOf<R>>;
+type InferOneRoute<R, BasePrefix extends readonly string[]> = IsExposed<R> extends false ? unknown : Nest<ChainSegments<R, BasePrefix>, RouteFn<R>>;
+/**
+ * Infer the public API tree for a list of route descriptors, given the owning
+ * plugin's base-path segments. Each route mounts a callable at its resolved
+ * chain; sibling keys merge via intersection, so `signin.credential` and
+ * `signup.credential` coexist and both autocomplete.
+ */
+type InferRoutes<Routes extends readonly unknown[], BasePrefix extends readonly string[]> = UnionToIntersection<{ [K in keyof Routes]: InferOneRoute<Routes[K], BasePrefix> }[number]>;
+//#endregion
+export { InferRoutes, PathSegments };

package/dist/json-deep-equal.mjs

@@ -0,0 +1,27 @@
+//#region src/json-deep-equal.ts
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function equalArrays(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i += 1) if (!deepJsonEqual(a[i], b[i])) return false;
+	return true;
+}
+function equalObjects(a, b) {
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) if (!Object.hasOwn(b, key) || !deepJsonEqual(a[key], b[key])) return false;
+	return true;
+}
+/** Structural equality for JSON-shaped values. */
+function deepJsonEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return equalArrays(a, b);
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
+	return equalObjects(a, b);
+}
+//#endregion
+export { deepJsonEqual };

package/dist/normalize.d.mts

@@ -0,0 +1,12 @@
+import { Session, User } from "./types.mjs";
+
+//#region src/normalize.d.ts
+/**
+ * Convert snake_case User keys from server payloads to camelCase. Unknown
+ * extension fields are converted with the same rule so consumers consistently
+ * read camelCase in SDK responses.
+ */
+declare function normalizeUser<F = unknown>(raw: Record<string, unknown>): User<F>;
+declare function defaultSessionParse<F = unknown>(raw: unknown): Session<F>;
+//#endregion
+export { defaultSessionParse, normalizeUser };

package/dist/normalize.mjs

@@ -0,0 +1,19 @@
+import { toCamelCaseKey } from "./helpers.mjs";
+//#region src/normalize.ts
+/**
+* Convert snake_case User keys from server payloads to camelCase. Unknown
+* extension fields are converted with the same rule so consumers consistently
+* read camelCase in SDK responses.
+*/
+function normalizeUser(raw) {
+	const out = {};
+	for (const [key, value] of Object.entries(raw)) out[toCamelCaseKey(key)] = value;
+	return out;
+}
+function defaultSessionParse(raw) {
+	if (!raw || typeof raw !== "object") throw new TypeError(`Expected session response to be an object, got ${raw === null ? "null" : typeof raw}`);
+	const obj = raw;
+	return { user: normalizeUser(obj["user"] ?? obj) };
+}
+//#endregion
+export { defaultSessionParse, normalizeUser };

package/dist/package.mjs

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "0.0.2-beta.0";
+//#endregion
+export { version };

package/dist/path.mjs

@@ -0,0 +1,41 @@
+import { kebabToCamel } from "./helpers.mjs";
+//#region src/path.ts
+/**
+* Derive the public client chain from a route path. Mirrors the type-level
+* `PathSegments` in `infer.ts` exactly, so runtime materialization and compile
+* time inference can never drift.
+*
+*   "/otp/send"            -> ["otp", "send"]
+*   "/revoke-sessions"     -> ["revokeSessions"]
+*   "/:provider/authorize" -> ["authorize"]   (param segments are dropped)
+*/
+function pathToChain(path) {
+	return path.split("/").filter((seg) => seg.length > 0 && !seg.startsWith(":")).map(kebabToCamel);
+}
+function chainFromDotted(chain) {
+	return chain.split(".").filter((seg) => seg.length > 0);
+}
+/**
+* Substitute declared path params from `input` into `path` and strip them from
+* the payload.
+*/
+function resolvePath(path, params, input) {
+	if (!params || params.length === 0) return {
+		path,
+		rest: input
+	};
+	const rest = { ...input ?? {} };
+	let resolved = path;
+	for (const param of params) {
+		const value = rest[param];
+		if (value === void 0) throw new Error(`Missing required path param "${param}" for route "${path}"`);
+		resolved = resolved.replace(`:${param}`, encodeURIComponent(value));
+		delete rest[param];
+	}
+	return {
+		path: resolved,
+		rest
+	};
+}
+//#endregion
+export { chainFromDotted, pathToChain, resolvePath };

package/dist/pipeline.mjs

@@ -0,0 +1,65 @@
+import { camelizeEach } from "./helpers.mjs";
+import { resolvePath } from "./path.mjs";
+import { defaultSerialize } from "./serialize.mjs";
+//#region src/pipeline.ts
+/**
+* Run the default HTTP steps for a route — merge defaults, resolve path params,
+* serialize, dispatch, parse — without applying session effects.
+*/
+async function runHttp(ctx, def, input) {
+	let merged = input;
+	if (def.defaults !== void 0) merged = {
+		...def.defaults,
+		...input ?? {}
+	};
+	const { path, rest } = resolvePath(def.path, def.params, merged);
+	const payload = def.serialize !== void 0 ? def.serialize(rest) : defaultSerialize(rest);
+	const init = {
+		method: def.method,
+		absolute: def.absolute ?? false
+	};
+	if (def.method === "GET" && payload !== void 0) init.query = payload;
+	else init.body = payload;
+	const raw = await ctx.fetch(path, init);
+	if (def.parseSession === true) return ctx.parseSession(raw);
+	if (def.parse !== void 0) return def.parse(raw);
+	return Array.isArray(raw) ? camelizeEach(raw) : raw;
+}
+async function applyEffects(ctx, def, result) {
+	if (def.clearSession === true) ctx.store.setData(null);
+	if (def.parseSession === true && def.skipStore !== true) {
+		if (result !== null && typeof result === "object" && "user" in result) ctx.store.setData(result);
+	}
+	if (def.refetchSession === true) await ctx.store.refetch();
+}
+function makeHttpRunner(ctx, def, boundInput) {
+	const run = (override) => runHttp(ctx, def, override === void 0 ? boundInput : override);
+	return run;
+}
+/**
+* Execute a route's behaviour: delegate to its `handler` when present (handler
+* owns all behaviour, including any effects), otherwise run the default
+* pipeline and apply declarative effects once at the top level.
+*/
+async function dispatchRoute(ctx, def, input) {
+	if (def.handler !== void 0) return def.handler(ctx, input, makeHttpRunner(ctx, def, input));
+	const result = await runHttp(ctx, def, input);
+	await applyEffects(ctx, def, result);
+	return result;
+}
+/**
+* Run a route as a public client call, firing the per-call `onSuccess` /
+* `onError` hooks around the resolved value or thrown error.
+*/
+async function runRoute(ctx, def, input, opts) {
+	try {
+		const result = await dispatchRoute(ctx, def, input);
+		opts?.onSuccess?.(result);
+		return result;
+	} catch (error) {
+		opts?.onError?.(error);
+		throw error;
+	}
+}
+//#endregion
+export { runRoute };

package/dist/plugin.d.mts

@@ -0,0 +1,71 @@
+import { KebabToCamel } from "./type-utils.mjs";
+import { HTTPMethod } from "./types.mjs";
+
+//#region src/plugin.d.ts
+/**
+ * Route filter for hooks. Matches the stable route path, so client overrides do
+ * not change which hooks run.
+ */
+type RouteMatcher = string | readonly string[] | ((ctx: {
+  path: string;
+}) => boolean);
+/**
+ * Mutable request context passed to `beforeRequest` hooks. Return the updated
+ * context, or throw to abort the request.
+ */
+type RequestContext = {
+  method: HTTPMethod; /** Path relative to `baseURL` (already includes the configured `basePath`). */
+  fullPath: string; /** Path relative to the client `basePath`. */
+  path: string; /** Stable route identifier, unaffected by client overrides. */
+  routePath: string; /** Full request URL. */
+  url: string;
+  headers: Headers;
+  body: unknown;
+};
+/**
+ * Mutable response context passed to `afterResponse` hooks. The body has
+ * already been envelope-unwrapped.
+ */
+type ResponseContext = Omit<RequestContext, "url"> & {
+  /** Status code. */status: number; /** Whether the response is successful. */
+  ok: boolean;
+};
+type BeforeRequestHook = {
+  /** Optional route filter. Omit to run for every request. */match?: RouteMatcher;
+  run: (req: RequestContext) => RequestContext | Promise<RequestContext>;
+};
+type AfterResponseHook = {
+  match?: RouteMatcher; /** Run even for failed responses. */
+  allowOnFailure?: boolean;
+  run: (res: ResponseContext) => ResponseContext | Promise<ResponseContext>;
+};
+/**
+ * Request and response hooks contributed by a plugin.
+ */
+type PluginHooks = {
+  beforeRequest?: BeforeRequestHook[];
+  afterResponse?: AfterResponseHook[];
+};
+/** Options accepted by `ctx.fetch(path, init)`. */
+type FetchInit = {
+  method?: HTTPMethod; /** JSON body. The fetcher stringifies. */
+  body?: unknown; /** Appended as `?k=v` query string. */
+  query?: Record<string, string>; /** Extra headers to merge with the defaults (`Content-Type`, `Accept`). */
+  headers?: HeadersInit;
+  /**
+   * Resolve `path` from the client base path instead of the plugin base path.
+   */
+  absolute?: boolean;
+};
+type PluginIdOf<P> = P extends {
+  readonly id: infer Id extends string;
+} ? Id : never;
+type PluginClientOverride = {
+  /** Replace the plugin's default base path (relative to the client `basePath`). */basePath?: string;
+};
+/**
+ * Per-plugin client overrides, keyed by camelCased plugin id.
+ */
+type PluginOverrides<Plugins extends readonly unknown[]> = Partial<Record<KebabToCamel<PluginIdOf<Plugins[number]>>, PluginClientOverride>>;
+//#endregion
+export { AfterResponseHook, BeforeRequestHook, FetchInit, PluginClientOverride, PluginHooks, PluginIdOf, PluginOverrides, RequestContext, ResponseContext, RouteMatcher };

package/dist/plugins/bearer/index.d.mts

@@ -1,2 +1,14 @@
-import { a as BearerPlugin, c as BearerTokens, i as resolveDefaultStorage, n as localStorageBearerStorage, o as BearerPluginConfig, r as memoryBearerStorage, s as BearerStorage, t as bearerPlugin } from "../../index-B8SpHkSd.mjs";
+import { ClientPlugin } from "../../define-plugin.mjs";
+import { BearerPlugin, BearerPluginConfig, BearerStorage, BearerTokens } from "./types.mjs";
+import { localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage } from "./storage.mjs";
+
+//#region src/plugins/bearer/index.d.ts
+declare function bearerPlugin(config?: BearerPluginConfig): ClientPlugin<"bearer", "", [], {
+  bearer: {
+    getTokens: () => BearerTokens | null;
+    setTokens: (tokens: BearerTokens) => void;
+    clear: () => void;
+  };
+}>;
+//#endregion
 export { type BearerPluginConfig, type BearerPlugin as BearerPublic, type BearerStorage, type BearerTokens, bearerPlugin, localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage };

package/dist/plugins/bearer/index.mjs

@@ -1,2 +1,44 @@
-import { i as resolveDefaultStorage, n as localStorageBearerStorage, r as memoryBearerStorage, t as bearerPlugin } from "../../bearer-Cqmrmjjf.mjs";
+import { SET_AUTH_TOKEN_HEADER, SET_REFRESH_TOKEN_HEADER } from "../../constants.mjs";
+import { defineClientPlugin, defineRoutes } from "../../define-plugin.mjs";
+import { localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage } from "./storage.mjs";
+//#region src/plugins/bearer/index.ts
+function bearerPlugin(config = {}) {
+	const store = config.storage ?? resolveDefaultStorage(config.storageKey ?? "limen.tokens");
+	return defineClientPlugin({
+		id: "bearer",
+		routes: defineRoutes(),
+		actions: () => ({ bearer: {
+			getTokens: () => store.get(),
+			setTokens: (tokens) => store.set(tokens),
+			clear: () => store.clear()
+		} }),
+		hooks: {
+			beforeRequest: [{ run: (req) => {
+				const tokens = store.get();
+				if (tokens?.accessToken && !req.headers.has("Authorization")) req.headers.set("Authorization", `Bearer ${tokens.accessToken}`);
+				return req;
+			} }],
+			afterResponse: [{
+				allowOnFailure: true,
+				run: (res) => {
+					const accessToken = res.headers.get(SET_AUTH_TOKEN_HEADER);
+					if (accessToken) {
+						const tokens = { accessToken };
+						const refreshToken = res.headers.get(SET_REFRESH_TOKEN_HEADER);
+						if (refreshToken) tokens.refreshToken = refreshToken;
+						store.set(tokens);
+					}
+					return res;
+				}
+			}, {
+				match: ["/signout", "/revoke-sessions"],
+				run: (res) => {
+					store.clear();
+					return res;
+				}
+			}]
+		}
+	});
+}
+//#endregion
 export { bearerPlugin, localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage };

package/dist/plugins/bearer/storage.d.mts

@@ -0,0 +1,8 @@
+import { BearerStorage } from "./types.mjs";
+
+//#region src/plugins/bearer/storage.d.ts
+declare function memoryBearerStorage(): BearerStorage;
+declare function localStorageBearerStorage(key?: string): BearerStorage;
+declare function resolveDefaultStorage(key: string): BearerStorage;
+//#endregion
+export { localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage };

package/dist/plugins/bearer/storage.mjs

@@ -0,0 +1,41 @@
+import { DEFAULT_TOKEN_STORAGE_KEY } from "../../constants.mjs";
+//#region src/plugins/bearer/storage.ts
+function memoryBearerStorage() {
+	let tokens = null;
+	return {
+		get: () => tokens,
+		set: (next) => {
+			tokens = next;
+		},
+		clear: () => {
+			tokens = null;
+		}
+	};
+}
+function localStorageBearerStorage(key = DEFAULT_TOKEN_STORAGE_KEY) {
+	return {
+		get: () => {
+			try {
+				const raw = globalThis.localStorage.getItem(key);
+				if (!raw) return null;
+				const parsed = JSON.parse(raw);
+				if (typeof parsed?.accessToken !== "string") return null;
+				return parsed;
+			} catch {
+				return null;
+			}
+		},
+		set: (tokens) => {
+			globalThis.localStorage.setItem(key, JSON.stringify(tokens));
+		},
+		clear: () => {
+			globalThis.localStorage.removeItem(key);
+		}
+	};
+}
+function resolveDefaultStorage(key) {
+	if (typeof globalThis.localStorage !== "undefined") return localStorageBearerStorage(key);
+	return memoryBearerStorage();
+}
+//#endregion
+export { localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage };

package/dist/{index-B8SpHkSd.d.mts → plugins/bearer/types.d.mts}

@@ -1,5 +1,3 @@
-import { n as ClientPlugin } from "./define-plugin-Dv0xXIaH.mjs";
-
 //#region src/plugins/bearer/types.d.ts
 type BearerPlugin = {
   bearer: {
@@ -30,19 +28,4 @@ type BearerPluginConfig = {
   storageKey?: string;
 };
 //#endregion
-//#region src/plugins/bearer/storage.d.ts
-declare function memoryBearerStorage(): BearerStorage;
-declare function localStorageBearerStorage(key?: string): BearerStorage;
-declare function resolveDefaultStorage(key: string): BearerStorage;
-//#endregion
-//#region src/plugins/bearer/index.d.ts
-declare function bearerPlugin(config?: BearerPluginConfig): ClientPlugin<"bearer", "", [], {
-  bearer: {
-    getTokens: () => BearerTokens | null;
-    setTokens: (tokens: BearerTokens) => void;
-    clear: () => void;
-  };
-}>;
-//#endregion
-export { BearerPlugin as a, BearerTokens as c, resolveDefaultStorage as i, localStorageBearerStorage as n, BearerPluginConfig as o, memoryBearerStorage as r, BearerStorage as s, bearerPlugin as t };
-//# sourceMappingURL=index-B8SpHkSd.d.mts.map
+export { BearerPlugin, BearerPluginConfig, BearerStorage, BearerTokens };

package/dist/plugins/credential/index.d.mts

@@ -1,2 +1,55 @@
-import { a as ResetPasswordInput, c as SignUpCredentialInput, i as RequestPasswordResetInput, n as ChangePasswordInput, o as SetPasswordInput, r as CheckUsernameInput, s as SignInCredentialInput, t as credentialPasswordPlugin } from "../../index-Cgr2wHmM.mjs";
+import { RouteDescriptor } from "../../route.mjs";
+import { Session } from "../../types.mjs";
+import { ClientPlugin } from "../../define-plugin.mjs";
+import { ChangePasswordInput, CheckUsernameInput, RequestPasswordResetInput, ResetPasswordInput, SetPasswordInput, SignInCredentialInput, SignUpCredentialInput } from "./types.mjs";
+
+//#region src/plugins/credential/index.d.ts
+declare function credentialPasswordPlugin<TFields = unknown>(): ClientPlugin<"credential-password", "/", [RouteDescriptor<SignInCredentialInput, Session<TFields>, {
+  readonly method: "POST";
+  readonly path: "/signin/credential";
+  readonly parseSession: true;
+  readonly as: "signIn.credential";
+  readonly defaults: {
+    readonly rememberMe: true;
+  };
+}>, RouteDescriptor<SignUpCredentialInput, Session<TFields>, {
+  readonly method: "POST";
+  readonly path: "/signup/credential";
+  readonly parseSession: true;
+  readonly as: "signUp.credential";
+}>, RouteDescriptor<RequestPasswordResetInput, {
+  message: string;
+}, {
+  readonly method: "POST";
+  readonly path: "/passwords/request-reset";
+  readonly as: "password.requestReset";
+}>, RouteDescriptor<ResetPasswordInput, {
+  message: string;
+}, {
+  readonly method: "POST";
+  readonly path: "/passwords/reset";
+  readonly as: "password.reset";
+}>, RouteDescriptor<ChangePasswordInput, Session<TFields>, {
+  readonly method: "POST";
+  readonly path: "/passwords/change";
+  readonly parseSession: true;
+  readonly defaults: {
+    readonly revokeOtherSessions: true;
+  };
+  readonly as: "password.change";
+}>, RouteDescriptor<SetPasswordInput, Session<TFields>, {
+  readonly method: "PUT";
+  readonly path: "/passwords";
+  readonly as: "password.set";
+  readonly parseSession: true;
+  readonly defaults: {
+    readonly revokeOtherSessions: true;
+  };
+}>, RouteDescriptor<CheckUsernameInput, boolean, {
+  readonly method: "POST";
+  readonly path: "/usernames/check";
+  readonly parse: (raw: unknown) => boolean;
+  readonly as: "username.checkAvailability";
+}>], Record<never, never>>;
+//#endregion
 export { type ChangePasswordInput, type CheckUsernameInput, type RequestPasswordResetInput, type ResetPasswordInput, type SetPasswordInput, type SignInCredentialInput, type SignUpCredentialInput, credentialPasswordPlugin };

package/dist/plugins/credential/index.mjs

@@ -1,5 +1,5 @@
-import { n as defineRoutes, t as defineClientPlugin } from "../../define-plugin-C7WOGU4b.mjs";
-import { t as route } from "../../route-DGxvFqWl.mjs";
+import { defineClientPlugin, defineRoutes } from "../../define-plugin.mjs";
+import { route } from "../../route.mjs";
 //#region src/plugins/credential/index.ts
 function credentialPasswordPlugin() {
 	return defineClientPlugin({
@@ -46,5 +46,3 @@ function credentialPasswordPlugin() {
 }
 //#endregion
 export { credentialPasswordPlugin };
-
-//# sourceMappingURL=index.mjs.map

package/dist/plugins/credential/types.d.mts

@@ -0,0 +1,35 @@
+//#region src/plugins/credential/types.d.ts
+type SignInCredentialInput = {
+  /** Email or username, depending on what the server enables. */credential: string;
+  password: string; /** When true (default), issues a long-lived session. */
+  rememberMe?: boolean;
+};
+type SignUpCredentialInput = {
+  email: string;
+  password: string; /** Required when username-on-signup is enabled. */
+  username?: string; /** Optional profile fields the server records on the user. */
+  firstname?: string;
+  lastname?: string; /** Extra fields recorded on the user at registration. */
+  additionalFields?: Record<string, unknown>;
+};
+type ChangePasswordInput = {
+  currentPassword: string;
+  newPassword: string; /** Invalidate other sessions on success. Defaults to true. */
+  revokeOtherSessions?: boolean;
+};
+type SetPasswordInput = {
+  newPassword: string;
+  revokeOtherSessions?: boolean;
+};
+type RequestPasswordResetInput = {
+  email: string;
+};
+type ResetPasswordInput = {
+  token: string;
+  newPassword: string;
+};
+type CheckUsernameInput = {
+  username: string;
+};
+//#endregion
+export { ChangePasswordInput, CheckUsernameInput, RequestPasswordResetInput, ResetPasswordInput, SetPasswordInput, SignInCredentialInput, SignUpCredentialInput };

package/dist/plugins/index.d.mts

@@ -1,7 +1,14 @@
-import { a as BearerPlugin, c as BearerTokens, i as resolveDefaultStorage, n as localStorageBearerStorage, o as BearerPluginConfig, r as memoryBearerStorage, s as BearerStorage, t as bearerPlugin } from "../index-B8SpHkSd.mjs";
-import { a as ResetPasswordInput, c as SignUpCredentialInput, i as RequestPasswordResetInput, n as ChangePasswordInput, o as SetPasswordInput, r as CheckUsernameInput, s as SignInCredentialInput, t as credentialPasswordPlugin } from "../index-Cgr2wHmM.mjs";
-import { n as RequestMagicLinkInput, r as VerifyMagicLinkInput, t as magicLinkPlugin } from "../index-dEksIImj.mjs";
-import { a as OAuthAuthorizeResult, i as OAuthAuthorizeQuery, n as LinkOAuthInput, o as OAuthTokens, r as OAuthAccount, s as SignInOAuthInput, t as oauthClientPlugin } from "../index-DV6YcNSu.mjs";
-import { n as SessionJwtPluginConfig, r as SessionJwtTokens, t as sessionJwtPlugin } from "../index-C9EuA9UZ.mjs";
-import { a as SendOTPInput, c as TwoFactorSetupURI, i as InitiateSetupInput, l as VerifyInput, n as DisableTwoFactorInput, o as TwoFactorConfig, r as FinalizeSetupInput, s as TwoFactorMethod, t as twoFactorPlugin } from "../index-C6atwjEq.mjs";
+import { BearerPlugin, BearerPluginConfig, BearerStorage, BearerTokens } from "./bearer/types.mjs";
+import { localStorageBearerStorage, memoryBearerStorage, resolveDefaultStorage } from "./bearer/storage.mjs";
+import { bearerPlugin } from "./bearer/index.mjs";
+import { ChangePasswordInput, CheckUsernameInput, RequestPasswordResetInput, ResetPasswordInput, SetPasswordInput, SignInCredentialInput, SignUpCredentialInput } from "./credential/types.mjs";
+import { credentialPasswordPlugin } from "./credential/index.mjs";
+import { RequestMagicLinkInput, VerifyMagicLinkInput } from "./magic-link/types.mjs";
+import { magicLinkPlugin } from "./magic-link/index.mjs";
+import { LinkOAuthInput, OAuthAccount, OAuthAuthorizeQuery, OAuthAuthorizeResult, OAuthTokens, SignInOAuthInput } from "./oauth/types.mjs";
+import { oauthClientPlugin } from "./oauth/index.mjs";
+import { SessionJwtPluginConfig, SessionJwtTokens } from "./session-jwt/types.mjs";
+import { sessionJwtPlugin } from "./session-jwt/index.mjs";
+import { DisableTwoFactorInput, FinalizeSetupInput, InitiateSetupInput, SendOTPInput, TwoFactorConfig, TwoFactorMethod, TwoFactorSetupURI, VerifyInput } from "./two-factor/types.mjs";
+import { twoFactorPlugin } from "./two-factor/index.mjs";
 export { type BearerPluginConfig, type BearerPlugin as BearerPublic, type BearerStorage, type BearerTokens, type ChangePasswordInput, type CheckUsernameInput, type DisableTwoFactorInput, type FinalizeSetupInput, type InitiateSetupInput, type LinkOAuthInput, type OAuthAccount, type OAuthAuthorizeQuery, type OAuthAuthorizeResult, type OAuthTokens, type RequestMagicLinkInput, type RequestPasswordResetInput, type ResetPasswordInput, type SendOTPInput, type SessionJwtPluginConfig, type SessionJwtTokens, type SetPasswordInput, type SignInCredentialInput, type SignInOAuthInput, type SignUpCredentialInput, type TwoFactorConfig, type TwoFactorMethod, type TwoFactorSetupURI, type VerifyInput, type VerifyMagicLinkInput, bearerPlugin, credentialPasswordPlugin, localStorageBearerStorage, magicLinkPlugin, memoryBearerStorage, oauthClientPlugin, resolveDefaultStorage, sessionJwtPlugin, twoFactorPlugin };