@atelic-action/ui 0.17.2 → 1.1.0

package/src/app/lib/format.ts

@@ -0,0 +1,61 @@
+/**
+ * Generic date and time phrasing shared across features. Domain vocab
+ * (sport verbs, kitchen fractions) stays with its feature.
+ */
+
+const DAY_MS = 86_400_000;
+
+/** A date only string (YYYY-MM-DD) is a local calendar day, not UTC midnight. */
+function parse(iso: string): Date {
+	const day = /^(\d{4})-(\d{2})-(\d{2})$/.exec(iso);
+	return day ? new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3])) : new Date(iso);
+}
+
+/**
+ * Compact `H:MM` (or `Nm`) duration. Differs from `formatDuration` in
+ * src/features/activities — that one is the full `HH:MM:SS`. This one is
+ * meant for tight UI (stats grid, card mod lines).
+ */
+export function fmtTimeShort(seconds: number): string {
+	const h = Math.floor(seconds / 3600);
+	const m = Math.floor((seconds % 3600) / 60);
+	return h > 0 ? `${h}:${m.toString().padStart(2, "0")}` : `${m}m`;
+}
+
+export function shortDate(iso: string): string {
+	const d = parse(iso);
+	return d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+
+/**
+ * Phrase a date relative to today: `today`, `yesterday`, weekday name for the
+ * past week, then `Mon Day` afterwards. Used by the Today salut line and the
+ * Training card mod row.
+ */
+export function relDay(iso: string, now: Date = new Date()): string {
+	const then = parse(iso);
+	const startOfNow = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+	const startOfThen = new Date(then.getFullYear(), then.getMonth(), then.getDate()).getTime();
+	const diffDays = Math.round((startOfNow - startOfThen) / DAY_MS);
+	if (diffDays === 0) return "today";
+	if (diffDays === 1) return "yesterday";
+	if (diffDays > 1 && diffDays < 7) return then.toLocaleDateString("en-US", { weekday: "long" });
+	return then.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+
+export function partOfDay(d: Date = new Date()): string {
+	const h = d.getHours();
+	if (h < 5) return "Late night";
+	if (h < 12) return "Morning";
+	if (h < 17) return "Afternoon";
+	if (h < 21) return "Evening";
+	return "Tonight";
+}
+
+/**
+ * Compact local time of day ("9:38 am").
+ */
+export function formatTimeOfDay(iso: string): string {
+	const d = new Date(iso);
+	return d.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" }).toLowerCase();
+}

package/src/app/lib/http.ts

@@ -0,0 +1,205 @@
+/**
+ * The transport: how this app talks to its api. Everything technology specific
+ * about the wire lives here (base URL, bearer token, proactive and reactive
+ * refresh, the snake_case to camelCase transform, error shapes). Resource
+ * modules under src/features/<feature>/api.ts build on `apiFetch` and never
+ * touch `fetch` themselves; swapping the backend means swapping this file and
+ * the session module beside it, not the features. The base URL is the app's
+ * `apiBaseUrl`, read on every call.
+ */
+
+import { getAppConfig } from "../config";
+import { useAuthStore } from "../stores/authStore";
+import { ensureValidToken, handleUnauthorized } from "./tokenRefresh";
+import { transformKeys } from "./transformKeys";
+
+/**
+ * Auth endpoints that should NOT trigger token validation.
+ * These endpoints are used during login when no valid token exists.
+ */
+const AUTH_ENDPOINTS = ["/v1/auth/token"] as const;
+
+/**
+ * Check if an endpoint is an auth endpoint that should skip token validation.
+ */
+function isAuthEndpoint(endpoint: string): boolean {
+	const pathname = endpoint.split("?")[0];
+	return AUTH_ENDPOINTS.some((authPath) => pathname === authPath);
+}
+
+/**
+ * The human-readable half of an error response. Rails renders validation
+ * failures as an `errors` array (one message per problem) and everything else
+ * as a single `error` string, so both shapes have to reach the toast -- without
+ * the array, a 422 the server explained carefully shows up as a bare status.
+ */
+function errorMessage(errorData: unknown, response: Response): string {
+	const body = errorData as { error?: string; message?: string; errors?: unknown } | null;
+
+	if (body?.error) return body.error;
+	if (body?.message) return body.message;
+	if (Array.isArray(body?.errors) && body.errors.length > 0) {
+		return body.errors.map((entry) => String(entry)).join(". ");
+	}
+	return `${response.status} ${response.statusText}`;
+}
+
+/**
+ * Make a fetch request with the current auth token.
+ */
+async function fetchWithAuth(url: string, options: RequestInit = {}): Promise<Response> {
+	const token = useAuthStore.getState().token;
+
+	return fetch(url, {
+		...options,
+		headers: {
+			"Content-Type": "application/json",
+			...(token && { Authorization: `Bearer ${token}` }),
+			...options.headers,
+		},
+	});
+}
+
+/**
+ * Parse a successful response. A 204 or an empty body (a DELETE the api
+ * answered with no content) is a success with nothing to read, not a parse
+ * error.
+ */
+async function readBody<T>(response: Response): Promise<T> {
+	if (response.status === 204) return undefined as T;
+	const text = await response.text();
+	if (text === "") return undefined as T;
+	return transformKeys<T>(JSON.parse(text));
+}
+
+/**
+ * A read that needs no session: what a public page (see publicRoutes.ts)
+ * loads for a visitor who is not signed in. No bearer token, no refresh, no
+ * logout on failure; the same error shapes and the same camelCase transform
+ * as `apiFetch`. A signed in reader uses it too, since the endpoint serves
+ * the same public subset either way and a stale token must never break a
+ * page that needs none. GET only by design: nothing public writes.
+ */
+export async function publicFetch<T>(endpoint: string): Promise<T> {
+	const response = await fetch(`${getAppConfig().apiBaseUrl}${endpoint}`, {
+		headers: { Accept: "application/json" },
+	});
+
+	if (!response.ok) {
+		const errorData = await response.json().catch(() => null);
+		throw new Error(`API error: ${errorMessage(errorData, response)}`);
+	}
+
+	return transformKeys<T>(await response.json());
+}
+
+/**
+ * Base fetch wrapper for API calls.
+ * Handles authentication headers, proactive token refresh, and 401 retry.
+ */
+export async function apiFetch<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+	const url = `${getAppConfig().apiBaseUrl}${endpoint}`;
+	const skipAuth = isAuthEndpoint(endpoint);
+
+	// Proactive refresh: skip for auth endpoints (login/refresh)
+	if (!skipAuth && !(await ensureValidToken())) {
+		throw new Error("Session expired. Please log in again.");
+	}
+
+	let response = await fetchWithAuth(url, options);
+
+	// Reactive refresh: skip for auth endpoints to avoid refresh loops
+	if (!skipAuth && response.status === 401) {
+		const refreshed = await handleUnauthorized();
+		if (refreshed) {
+			// Retry with new token
+			response = await fetchWithAuth(url, options);
+		} else {
+			// Refresh failed, user was logged out
+			throw new Error("Session expired. Please log in again.");
+		}
+	}
+
+	// Handle 401 errors from the retry. An auth endpoint's own 401 falls through
+	// to the error branch below, so the server's message reaches the caller.
+	if (response.status === 401 && !skipAuth) {
+		useAuthStore.getState().logout();
+		throw new Error("Session expired. Please log in again.");
+	}
+
+	if (!response.ok) {
+		const errorData = await response.json().catch(() => null);
+		throw new Error(`API error: ${errorMessage(errorData, response)}`);
+	}
+
+	return readBody<T>(response);
+}
+
+/**
+ * POST a multipart/form-data body (e.g. a file upload).
+ *
+ * Distinct from apiFetch because the browser must set the multipart boundary
+ * itself: we deliberately omit Content-Type and pass the FormData through
+ * untouched (no JSON.stringify, no toSnakeCase, which would corrupt it). Auth,
+ * the proactive/reactive token refresh, and the camelCase response transform
+ * all mirror apiFetch.
+ */
+export async function uploadFormData<T>(endpoint: string, formData: FormData): Promise<T> {
+	const url = `${getAppConfig().apiBaseUrl}${endpoint}`;
+
+	if (!(await ensureValidToken())) {
+		throw new Error("Session expired. Please log in again.");
+	}
+
+	const send = () => {
+		const token = useAuthStore.getState().token;
+		return fetch(url, {
+			method: "POST",
+			body: formData,
+			headers: { ...(token && { Authorization: `Bearer ${token}` }) },
+		});
+	};
+
+	let response = await send();
+
+	if (response.status === 401) {
+		const refreshed = await handleUnauthorized();
+		if (refreshed) {
+			response = await send();
+		} else {
+			throw new Error("Session expired. Please log in again.");
+		}
+	}
+
+	if (response.status === 401) {
+		useAuthStore.getState().logout();
+		throw new Error("Session expired. Please log in again.");
+	}
+
+	if (!response.ok) {
+		const errorData = await response.json().catch(() => null);
+		throw new Error(`API error: ${errorMessage(errorData, response)}`);
+	}
+
+	return readBody<T>(response);
+}
+
+/**
+ * Build a query string from filter parameters.
+ * Arrays are joined with commas. Undefined/null values are skipped.
+ */
+export function buildQueryString(
+	params: Record<string, string | number | string[] | undefined | null>,
+): string {
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) {
+		if (value === undefined || value === null) continue;
+		if (Array.isArray(value)) {
+			if (value.length > 0) searchParams.set(key, value.join(","));
+		} else {
+			searchParams.set(key, String(value));
+		}
+	}
+	const queryString = searchParams.toString();
+	return queryString ? `?${queryString}` : "";
+}

package/src/app/lib/lastAuth.ts

@@ -0,0 +1,45 @@
+/**
+ * `<prefix>-last-auth` cookie. Pure UX hint for the welcome back greeting.
+ * Does NOT grant any session; the JWT in localStorage does that. Read at the
+ * unauthenticated `/` to switch between first time and returning visitor copy;
+ * written on every successful sign in.
+ */
+
+import { getAppConfig } from "../config";
+
+const cookieName = () => `${getAppConfig().storagePrefix}-last-auth`;
+const COOKIE_MAX_AGE_SECONDS = 90 * 24 * 60 * 60; // 90 days
+
+export interface LastAuth {
+	email: string;
+	provider: string;
+}
+
+export function readLastAuth(): LastAuth | null {
+	if (typeof document === "undefined") return null;
+
+	const name = cookieName();
+	const match = document.cookie.split("; ").find((row) => row.startsWith(`${name}=`));
+	if (!match) return null;
+
+	const raw = match.slice(name.length + 1);
+	try {
+		const parsed = JSON.parse(decodeURIComponent(raw));
+		if (typeof parsed?.email === "string" && typeof parsed?.provider === "string") {
+			return parsed;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+export function writeLastAuth(value: LastAuth): void {
+	if (typeof document === "undefined") return;
+
+	const encoded = encodeURIComponent(JSON.stringify(value));
+	const isSecure = typeof window !== "undefined" && window.location.protocol === "https:";
+	const secureFlag = isSecure ? "; Secure" : "";
+	// biome-ignore lint/suspicious/noDocumentCookie: the Cookie Store API is missing from browsers the app serves
+	document.cookie = `${cookieName()}=${encoded}; Max-Age=${COOKIE_MAX_AGE_SECONDS}; Path=/; SameSite=Lax${secureFlag}`;
+}

package/src/app/lib/oauth.ts

@@ -0,0 +1,32 @@
+import { getAppConfig } from "../config";
+
+/**
+ * Start Google sign in. Submits a hidden POST form to OmniAuth's request
+ * phase rather than navigating via window.location.href, matching OmniAuth
+ * 2.0's POST-only default for resistance to login CSRF.
+ */
+export function startGoogleAuth(): void {
+	postNavigate(`${getAppConfig().apiBaseUrl}/auth/google_oauth2`);
+}
+
+/**
+ * Build and submit a hidden POST form, causing the browser to navigate to
+ * the target URL via a POST request. Used by OAuth start flows so OmniAuth
+ * sees a POST as it expects in 2.0+.
+ *
+ * CSRF tradeoff: the canonical defense (`omniauth-rails_csrf_protection` +
+ * an `authenticity_token` field) requires a Rails session, which this JSON
+ * API does not have. A session-less CSRF flow (mint one-time token via
+ * dedicated endpoint, include in form, validate server side) is the right
+ * long term fix; tracked as a follow on.
+ * The login-CSRF threat is bounded today by AUTHORIZED_EMAILS gating new
+ * sign ups (an attacker forcing a sign in still cannot create an account).
+ */
+export function postNavigate(url: string): void {
+	const form = document.createElement("form");
+	form.method = "POST";
+	form.action = url;
+	form.style.display = "none";
+	document.body.appendChild(form);
+	form.submit();
+}

package/src/app/lib/publicRoutes.ts

@@ -0,0 +1,33 @@
+import { peekAppConfig } from "../config";
+
+/**
+ * Which paths a signed out visitor may load, read from the app's config.
+ *
+ * Two kinds. A **public route** is an exact path the shell renders bare:
+ * the landing at "/" and the OAuth callback. A **public page** is a pattern,
+ * a prefix ending in "/*", for pages that stand on their own signed out and
+ * render inside the public chrome (a brand bar with a sign in link): a
+ * person's public activity or recipe under "/u/<username>/...". Signed in,
+ * a public page renders inside the normal app shell like any other page.
+ */
+
+// Before the app configures the shell nothing is public, so a guard that
+// runs early holds the page rather than opening it.
+const exact = (pathname: string) => (peekAppConfig()?.publicRoutes ?? []).includes(pathname);
+
+const matchesPattern = (pathname: string, pattern: string) => {
+	if (!pattern.endsWith("/*")) return pathname === pattern;
+	const prefix = pattern.slice(0, -1); // keep the trailing slash: "/u/" never matches "/users"
+	return pathname.startsWith(prefix) && pathname.length > prefix.length;
+};
+
+/** Whether the path is a public page: one that renders in the public chrome signed out. */
+export function isPublicPage(pathname: string): boolean {
+	const pages = peekAppConfig()?.publicPages ?? [];
+	return pages.some((pattern) => matchesPattern(pathname, pattern));
+}
+
+/** Whether a signed out visitor may load the path at all. */
+export function isPublicRoute(pathname: string): boolean {
+	return exact(pathname) || isPublicPage(pathname);
+}

package/src/app/lib/queryClient.ts

@@ -0,0 +1,38 @@
+import { MutationCache, QueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import type {} from "../types/query";
+
+const mutationCache = new MutationCache({
+	onSuccess: (data, _variables, _context, mutation) => {
+		const toastConfig = mutation.options.meta?.toast;
+		if (!toastConfig?.success) return;
+		const title =
+			typeof toastConfig.success === "function" ? toastConfig.success(data) : toastConfig.success;
+		const description =
+			typeof toastConfig.successDescription === "function"
+				? toastConfig.successDescription(data)
+				: toastConfig.successDescription;
+		toast.success(title, description ? { description } : undefined);
+	},
+	onError: (error, _variables, _context, mutation) => {
+		const toastConfig = mutation.options.meta?.toast;
+		if (!toastConfig?.error) return;
+		toast.error(toastConfig.error, { description: error.message });
+	},
+});
+
+/**
+ * TanStack Query client instance.
+ * Exported for use in:
+ * - QueryClientProvider (in __root.tsx)
+ * - Route loaders (queryClient.ensureQueryData)
+ */
+export const queryClient = new QueryClient({
+	mutationCache,
+	defaultOptions: {
+		queries: {
+			staleTime: 1000 * 60 * 5, // 5 minutes
+			retry: 1,
+		},
+	},
+});

package/src/app/lib/search.ts

@@ -0,0 +1,17 @@
+/**
+ * Check whether any of the given fields contain the search query.
+ * Accepts both string and string-array fields (e.g. tags).
+ */
+export function matchesSearch(
+	query: string,
+	fields: (string | string[] | null | undefined)[],
+): boolean {
+	const lower = query.toLowerCase();
+	return fields.some((field) => {
+		if (!field) return false;
+		if (Array.isArray(field)) {
+			return field.some((item) => item.toLowerCase().includes(lower));
+		}
+		return field.toLowerCase().includes(lower);
+	});
+}

package/src/app/lib/session.ts

@@ -0,0 +1,36 @@
+/**
+ * The session half of the api contract every app on this template shares:
+ * exchange an OAuth code for the token pair, and read the signed in user.
+ * The shell (UserContext, the OAuth callback) imports this directly and never
+ * the app's aggregate, so upstream code has no dependency on app resources.
+ */
+
+import type { RegisteredUser, TokenResponse } from "../types";
+import { apiFetch } from "./http";
+import { toSnakeCase } from "./transformKeys";
+import type { UnitPreferences } from "./units";
+import { type ApiEntityEnvelope, unwrapEntity } from "./unwrap";
+
+export const session = {
+	/** Exchange an OAuth code for the JWT pair. */
+	token: (code: string) =>
+		apiFetch<TokenResponse>("/v1/auth/token", {
+			method: "POST",
+			body: JSON.stringify({ code }),
+		}),
+
+	/** The signed in user. */
+	me: async () => {
+		const envelope = await apiFetch<ApiEntityEnvelope<RegisteredUser>>("/v1/users/me");
+		return unwrapEntity(envelope);
+	},
+
+	/** Save the person's unit preferences, a system per measure. */
+	updateUnits: async (units: UnitPreferences) => {
+		const envelope = await apiFetch<ApiEntityEnvelope<RegisteredUser>>("/v1/users/me", {
+			method: "PATCH",
+			body: JSON.stringify({ user: { units: toSnakeCase(units) } }),
+		});
+		return unwrapEntity(envelope);
+	},
+};

package/src/app/lib/tokenRefresh.ts

@@ -0,0 +1,137 @@
+/**
+ * Token refresh module for automatic JWT token refresh.
+ * Handles both proactive (before expiry) and reactive (on 401) refresh.
+ */
+
+import { getAppConfig } from "../config";
+import { DEFAULT_EXPIRY_BUFFER_MS, useAuthStore } from "../stores/authStore";
+import type { RefreshResponse } from "../types";
+import { transformKeys } from "./transformKeys";
+
+/**
+ * Module level promise for deduplicating concurrent refresh requests.
+ * Only one refresh request will be in flight at a time.
+ */
+let refreshPromise: Promise<RefreshResponse> | null = null;
+
+/**
+ * Refresh the access token using the stored refresh token.
+ * Deduplicates concurrent calls to ensure only one refresh request is made.
+ *
+ * @returns The new token response with updated access and refresh tokens
+ * @throws Error if refresh fails. Only a rejected refresh token logs out; a network error or a 5xx keeps the session.
+ */
+export async function refreshAccessToken(): Promise<RefreshResponse> {
+	// Return existing promise if refresh is already in progress
+	if (refreshPromise) {
+		return refreshPromise;
+	}
+
+	const { refreshToken, logout } = useAuthStore.getState();
+
+	if (!refreshToken) {
+		logout();
+		throw new Error("No refresh token available");
+	}
+
+	refreshPromise = (async () => {
+		const response = await fetch(`${getAppConfig().apiBaseUrl}/v1/auth/refresh`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			// The Rails API reads params[:refresh_token], so the body must be
+			// snake_case. This raw fetch does not run through apiFetch's
+			// toSnakeCase, so name the field explicitly here.
+			body: JSON.stringify({ refresh_token: refreshToken }),
+		});
+
+		if (!response.ok) {
+			// A rejected refresh token ends the session. A server error or a
+			// throttle says nothing about the token, so the session is kept.
+			if (response.status < 500 && response.status !== 408 && response.status !== 429) {
+				logout();
+			}
+			throw new Error(`Refresh failed: ${response.status}`);
+		}
+
+		const data = await response.json();
+		const result = transformKeys<RefreshResponse>(data);
+
+		// A sign out while the request was in flight must not be undone by its
+		// answer: only the session that asked may take the new tokens.
+		if (useAuthStore.getState().refreshToken !== refreshToken) {
+			throw new Error("Signed out during refresh");
+		}
+
+		// Update store with new tokens
+		useAuthStore.getState().setTokens(result.token, result.refreshToken, result.expiresIn);
+
+		return result;
+	})();
+
+	// Clear the promise after it settles for all consumers.
+	// The .catch() prevents unhandled rejection warnings since we're not awaiting this chain.
+	refreshPromise
+		.finally(() => {
+			refreshPromise = null;
+		})
+		.catch(() => {});
+
+	return refreshPromise;
+}
+
+/**
+ * Ensure the access token is valid before making an API call.
+ * Proactively refreshes the token if it is expiring soon.
+ *
+ * @param bufferMs Time before expiry to trigger refresh (default 5 minutes)
+ * @returns true if token is valid (or was refreshed), false if logout occurred
+ */
+export async function ensureValidToken(bufferMs = DEFAULT_EXPIRY_BUFFER_MS): Promise<boolean> {
+	const { isAuthenticated, isTokenExpiringSoon } = useAuthStore.getState();
+
+	// Not authenticated, nothing to refresh
+	if (!isAuthenticated) {
+		return false;
+	}
+
+	// Token is still valid
+	if (!isTokenExpiringSoon(bufferMs)) {
+		return true;
+	}
+
+	// Token is expiring soon, attempt refresh
+	try {
+		await refreshAccessToken();
+		return true;
+	} catch {
+		// A rejected refresh token logged the user out. A network error or a
+		// server error did not: the access token still serves until it expires.
+		const state = useAuthStore.getState();
+		return state.isAuthenticated && !state.isTokenExpiringSoon(0);
+	}
+}
+
+/**
+ * Handle a 401 Unauthorized response by attempting to refresh the token.
+ * Used for reactive refresh when the server rejects an expired token.
+ *
+ * @returns true if refresh succeeded and request should be retried, false if logout occurred
+ */
+export async function handleUnauthorized(): Promise<boolean> {
+	try {
+		await refreshAccessToken();
+		return true;
+	} catch {
+		// Refresh failed, user was logged out by refreshAccessToken
+		return false;
+	}
+}
+
+/**
+ * Reset the refresh promise (for testing purposes).
+ */
+export function resetRefreshState(): void {
+	refreshPromise = null;
+}

package/src/app/lib/transformKeys.ts

@@ -0,0 +1,60 @@
+/**
+ * Utility functions for transforming API keys.
+ * Used to convert between snake_case (Rails API) and camelCase (TypeScript).
+ */
+
+/**
+ * Convert a snake_case string to camelCase.
+ */
+function snakeToCamel(str: string): string {
+	return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+/**
+ * Convert a camelCase string to snake_case.
+ */
+function camelToSnake(str: string): string {
+	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+
+/**
+ * Recursively convert all keys in an object from snake_case to camelCase.
+ * Works with nested objects and arrays.
+ * Use for API responses.
+ *
+ * @example
+ * transformKeys({ user_name: "John", created_at: "2024-01-01" })
+ * // Returns: { userName: "John", createdAt: "2024-01-01" }
+ */
+export function transformKeys<T>(obj: unknown): T {
+	if (Array.isArray(obj)) {
+		return obj.map((item) => transformKeys(item)) as T;
+	}
+	if (obj !== null && typeof obj === "object") {
+		return Object.fromEntries(
+			Object.entries(obj).map(([key, value]) => [snakeToCamel(key), transformKeys(value)]),
+		) as T;
+	}
+	return obj as T;
+}
+
+/**
+ * Recursively convert all keys in an object from camelCase to snake_case.
+ * Works with nested objects and arrays.
+ * Use for API request bodies.
+ *
+ * @example
+ * toSnakeCase({ userName: "John", createdAt: "2024-01-01" })
+ * // Returns: { user_name: "John", created_at: "2024-01-01" }
+ */
+export function toSnakeCase<T>(obj: unknown): T {
+	if (Array.isArray(obj)) {
+		return obj.map((item) => toSnakeCase(item)) as T;
+	}
+	if (obj !== null && typeof obj === "object") {
+		return Object.fromEntries(
+			Object.entries(obj).map(([key, value]) => [camelToSnake(key), toSnakeCase(value)]),
+		) as T;
+	}
+	return obj as T;
+}