@salesforce/templates 66.5.5 → 66.6.0

package/lib/templates/project/reactinternalapp/_p_/_m_/_w_/_a_/src/_f_/_os_/components/filters/NumericRangeFilter.tsx

@@ -0,0 +1,85 @@
+import { Input } from "../../../../components/ui/input";
+import { Label } from "../../../../components/ui/label";
+import { cn } from "../../../../lib/utils";
+import { useFilterField } from "../FilterContext";
+import type { ActiveFilterValue } from "../../utils/filterUtils";
+
+interface NumericRangeFilterProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+	field: string;
+	label: string;
+	helpText?: string;
+}
+
+export function NumericRangeFilter({
+	field,
+	label,
+	helpText,
+	className,
+	...props
+}: NumericRangeFilterProps) {
+	const { value, onChange } = useFilterField(field);
+	return (
+		<div className={cn("space-y-1.5", className)} {...props}>
+			<Label>{label}</Label>
+			<NumericRangeFilterInputs field={field} label={label} value={value} onChange={onChange} />
+			{helpText && <p className="text-xs text-muted-foreground">{helpText}</p>}
+		</div>
+	);
+}
+
+interface NumericRangeFilterInputsProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+	field: string;
+	label: string;
+	value: ActiveFilterValue | undefined;
+	onChange: (value: ActiveFilterValue | undefined) => void;
+	minInputProps?: React.ComponentProps<typeof Input>;
+	maxInputProps?: React.ComponentProps<typeof Input>;
+}
+
+export function NumericRangeFilterInputs({
+	field,
+	label,
+	value,
+	onChange,
+	className,
+	minInputProps,
+	maxInputProps,
+	...props
+}: NumericRangeFilterInputsProps) {
+	const handleChange = (bound: "min" | "max", v: string) => {
+		const next = {
+			field,
+			label,
+			type: "numeric" as const,
+			min: value?.min ?? "",
+			max: value?.max ?? "",
+			[bound]: v,
+		};
+		if (!next.min && !next.max) {
+			onChange(undefined);
+		} else {
+			onChange(next);
+		}
+	};
+
+	return (
+		<div className={cn("flex gap-2", className)} {...props}>
+			<Input
+				type="number"
+				placeholder="Min"
+				value={value?.min ?? ""}
+				onChange={(e) => handleChange("min", e.target.value)}
+				aria-label={`${label} minimum`}
+				{...minInputProps}
+			/>
+			<Input
+				type="number"
+				placeholder="Max"
+				value={value?.max ?? ""}
+				onChange={(e) => handleChange("max", e.target.value)}
+				aria-label={`${label} maximum`}
+				{...maxInputProps}
+			/>
+		</div>
+	);
+}

package/lib/templates/project/reactinternalapp/_p_/_m_/_w_/_a_/src/_f_/_os_/components/filters/SearchFilter.tsx

@@ -0,0 +1,37 @@
+import { Label } from "../../../../components/ui/label";
+import { cn } from "../../../../lib/utils";
+import { SearchBar } from "../SearchBar";
+import { useFilterField } from "../FilterContext";
+
+interface SearchFilterProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+	field: string;
+	label: string;
+	placeholder?: string;
+}
+
+export function SearchFilter({
+	field,
+	label,
+	placeholder,
+	className,
+	...props
+}: SearchFilterProps) {
+	const { value, onChange } = useFilterField(field);
+	return (
+		<div className={cn("space-y-1.5", className)} {...props}>
+			<Label htmlFor={`filter-${field}`}>{label}</Label>
+			<SearchBar
+				value={value?.value ?? ""}
+				handleChange={(v) => {
+					if (v) {
+						onChange({ field, label, type: "search", value: v });
+					} else {
+						onChange(undefined);
+					}
+				}}
+				placeholder={placeholder}
+				inputProps={{ id: `filter-${field}` }}
+			/>
+		</div>
+	);
+}

package/lib/templates/project/reactinternalapp/_p_/_m_/_w_/_a_/src/_f_/_os_/components/filters/SelectFilter.tsx

@@ -0,0 +1,93 @@
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "../../../../components/ui/select";
+import { Label } from "../../../../components/ui/label";
+import { cn } from "../../../../lib/utils";
+import { useFilterField } from "../FilterContext";
+import type { ActiveFilterValue } from "../../utils/filterUtils";
+
+const ALL_VALUE = "__all__";
+
+interface SelectFilterProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+	field: string;
+	label: string;
+	options: Array<{ value: string; label: string }>;
+	helpText?: string;
+}
+
+export function SelectFilter({
+	field,
+	label,
+	options,
+	helpText,
+	className,
+	...props
+}: SelectFilterProps) {
+	const { value, onChange } = useFilterField(field);
+	return (
+		<div className={cn("space-y-1.5", className)} {...props}>
+			<Label htmlFor={`filter-${field}`}>{label}</Label>
+			<SelectFilterControl
+				field={field}
+				label={label}
+				options={options}
+				value={value}
+				onChange={onChange}
+			/>
+			{helpText && <p className="text-xs text-muted-foreground">{helpText}</p>}
+		</div>
+	);
+}
+
+interface SelectFilterControlProps {
+	field: string;
+	label: string;
+	options: Array<{ value: string; label: string }>;
+	value: ActiveFilterValue | undefined;
+	onChange: (value: ActiveFilterValue | undefined) => void;
+	triggerProps?: React.ComponentProps<typeof SelectTrigger>;
+	contentProps?: React.ComponentProps<typeof SelectContent>;
+}
+
+export function SelectFilterControl({
+	field,
+	label,
+	options,
+	value,
+	onChange,
+	triggerProps,
+	contentProps,
+}: SelectFilterControlProps) {
+	return (
+		<Select
+			value={value?.value ?? ALL_VALUE}
+			onValueChange={(v) => {
+				if (v === ALL_VALUE) {
+					onChange(undefined);
+				} else {
+					onChange({ field, label, type: "picklist", value: v });
+				}
+			}}
+		>
+			<SelectTrigger
+				id={`filter-${field}`}
+				{...triggerProps}
+				className={cn("w-full", triggerProps?.className)}
+			>
+				<SelectValue placeholder={`Select ${label.toLowerCase()}`} />
+			</SelectTrigger>
+			<SelectContent {...contentProps}>
+				<SelectItem value={ALL_VALUE}>All</SelectItem>
+				{options.map((opt) => (
+					<SelectItem key={opt.value} value={opt.value}>
+						{opt.label}
+					</SelectItem>
+				))}
+			</SelectContent>
+		</Select>
+	);
+}

package/lib/templates/project/reactinternalapp/_p_/_m_/_w_/_a_/src/_f_/_os_/components/filters/TextFilter.tsx

@@ -0,0 +1,74 @@
+import { Input } from "../../../../components/ui/input";
+import { Label } from "../../../../components/ui/label";
+import { cn } from "../../../../lib/utils";
+import { useFilterField } from "../FilterContext";
+import type { ActiveFilterValue } from "../../utils/filterUtils";
+
+interface TextFilterProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+	field: string;
+	label: string;
+	placeholder?: string;
+	helpText?: string;
+}
+
+export function TextFilter({
+	field,
+	label,
+	placeholder,
+	helpText,
+	className,
+	...props
+}: TextFilterProps) {
+	const { value, onChange } = useFilterField(field);
+	return (
+		<div className={cn("space-y-1.5", className)} {...props}>
+			<Label htmlFor={`filter-${field}`}>{label}</Label>
+			<TextFilterInput
+				field={field}
+				label={label}
+				placeholder={placeholder}
+				value={value}
+				onChange={onChange}
+			/>
+			{helpText && <p className="text-xs text-muted-foreground">{helpText}</p>}
+		</div>
+	);
+}
+
+interface TextFilterInputProps extends Omit<
+	React.ComponentProps<typeof Input>,
+	"onChange" | "value"
+> {
+	field: string;
+	label: string;
+	value: ActiveFilterValue | undefined;
+	onChange: (value: ActiveFilterValue | undefined) => void;
+}
+
+export function TextFilterInput({
+	field,
+	label,
+	value,
+	onChange,
+	className,
+	...props
+}: TextFilterInputProps) {
+	return (
+		<Input
+			id={`filter-${field}`}
+			type="text"
+			placeholder={props.placeholder ?? `Filter by ${label.toLowerCase()}...`}
+			value={value?.value ?? ""}
+			onChange={(e) => {
+				const v = e.target.value;
+				if (v) {
+					onChange({ field, label, type: "text", value: v });
+				} else {
+					onChange(undefined);
+				}
+			}}
+			className={cn(className)}
+			{...props}
+		/>
+	);
+}

package/lib/templates/project/reactinternalapp/_p_/_m_/_w_/_a_/src/_f_/_os_/hooks/useAsyncData.ts

@@ -0,0 +1,54 @@
+import { useCallback, useEffect, useState } from "react";
+
+interface UseAsyncDataResult<T> {
+	data: T | null;
+	loading: boolean;
+	error: string | null;
+}
+
+/**
+ * Runs an async fetcher on mount and whenever `deps` change.
+ * Returns the loading/error/data state. Does not cache — every call
+ * to the fetcher hits the source directly.
+ *
+ * A cleanup flag prevents state updates if the component unmounts
+ * or deps change before the fetch completes (avoids React warnings
+ * and stale updates from out-of-order responses).
+ */
+export function useAsyncData<T>(
+	fetcher: () => Promise<T>,
+	deps: React.DependencyList,
+): UseAsyncDataResult<T> {
+	const [data, setData] = useState<T | null>(null);
+	const [loading, setLoading] = useState(true);
+	const [error, setError] = useState<string | null>(null);
+
+	// Re-create the fetcher reference only when deps change.
+	// eslint-disable-next-line react-hooks/exhaustive-deps --- deps are explicitly managed by the caller
+	const memoizedFetcher = useCallback(fetcher, deps);
+
+	useEffect(() => {
+		// Guard against setting state after unmount or dep change.
+		let cancelled = false;
+		setLoading(true);
+		setError(null);
+
+		memoizedFetcher()
+			.then((result) => {
+				if (!cancelled) setData(result);
+			})
+			.catch((err) => {
+				console.error(err);
+				if (!cancelled) setError(err instanceof Error ? err.message : "An error occurred");
+			})
+			.finally(() => {
+				if (!cancelled) setLoading(false);
+			});
+
+		return () => {
+			cancelled = true;
+		};
+	}, [memoizedFetcher]);
+
+	return { data, loading, error };
+}

package/lib/templates/project/reactinternalapp/_p_/_m_/_w_/_a_/src/_f_/_os_/hooks/useCachedAsyncData.ts

@@ -0,0 +1,184 @@
+import { useCallback, useEffect, useState } from "react";
+
+interface UseAsyncDataResult<T> {
+	data: T | null;
+	loading: boolean;
+	error: string | null;
+}
+
+interface CacheOptions {
+	/** Unique cache key. Used for lookups and invalidation via `clearCacheEntry`. */
+	key: string;
+	/** Time-to-live in ms. Default: 30_000 (30s) */
+	ttl?: number;
+	/** Max entries in the cache. Default: 50. Evicts oldest entry when exceeded. */
+	maxSize?: number;
+}
+
+interface CacheEntry {
+	data: unknown;
+	timestamp: number;
+}
+
+/**
+ * Module-level cache shared across all useCachedAsyncData consumers.
+ * Cleared automatically on page reload since it only lives in memory.
+ * Keys are caller-provided so different hook call-sites get independent entries.
+ */
+const cache = new Map<string, CacheEntry>();
+
+/**
+ * Returns a cached entry if it exists and hasn't exceeded its TTL.
+ * Expired entries are deleted lazily here rather than on a timer,
+ * so there's no background cleanup overhead.
+ */
+function getValidEntry(key: string, ttl: number): CacheEntry | undefined {
+	const entry = cache.get(key);
+	if (!entry) return undefined;
+	if (Date.now() - entry.timestamp > ttl) {
+		cache.delete(key);
+		return undefined;
+	}
+	return entry;
+}
+
+/**
+ * Stores a result in the cache. If the cache is at capacity and the key
+ * is new, the oldest entry (first in Map insertion order — FIFO) is evicted.
+ */
+function setEntry(key: string, data: unknown, maxSize: number): void {
+	if (!cache.has(key) && cache.size >= maxSize) {
+		const firstKey = cache.keys().next().value;
+		if (firstKey !== undefined) cache.delete(firstKey);
+	}
+	cache.set(key, { data, timestamp: Date.now() });
+}
+
+/**
+ * Removes a single cache entry by key. The key must match the
+ * `options.key` passed to `useCachedAsyncData`.
+ *
+ * @example
+ * // Hook:
+ * useCachedAsyncData(() => fetchAccountDetail(id), [id], { key: `account:${id}` });
+ *
+ * // Invalidate after a mutation:
+ * await updateAccount(id, fields);
+ * clearCacheEntry(`account:${id}`);
+ */
+export function clearCacheEntry(key: string): void {
+	cache.delete(key);
+}
+
+/**
+ * Removes all cache entries. Useful for global invalidation scenarios
+ * like user logout or after a bulk operation.
+ *
+ * @example
+ * async function handleLogout() {
+ *   await logout();
+ *   clearCache();
+ *   navigate("/login");
+ * }
+ */
+export function clearCache(): void {
+	cache.clear();
+}
+
+/**
+ * Async data hook with in-memory caching. Works like `useAsyncData` but
+ * avoids redundant network calls when the same data is requested again
+ * (e.g. navigating away from a page and back).
+ *
+ * Cache behaviour:
+ * - **Key**: Provided via `options.key`. Must be unique per logical data source.
+ *   Use the same key with `clearCacheEntry` to invalidate.
+ * - **Hit**: Data is returned synchronously on the initial render —
+ *   `loading` starts as `false`, so there's no flash of a loading state.
+ * - **Miss**: The fetcher runs, and the result is stored for future hits.
+ * - **TTL**: Entries expire after `options.ttl` ms (default 30 s).
+ *   Expiry is checked lazily on read, not on a timer.
+ * - **Max size**: Oldest entries are evicted FIFO when the cache exceeds
+ *   `options.maxSize` (default 50).
+ *
+ * @example
+ * // Cache picklist options for 5 minutes (data rarely changes)
+ * const { data: types } = useCachedAsyncData(fetchDistinctTypes, [], {
+ *   key: "distinctTypes",
+ *   ttl: 300_000,
+ * });
+ *
+ * // Cache search results with default 30 s TTL (back-nav returns instantly)
+ * const { data } = useCachedAsyncData(
+ *   () => searchAccounts({ where, orderBy, first, after }),
+ *   [where, orderBy, first, after],
+ *   { key: `accounts:${JSON.stringify({ where, orderBy, first, after })}` },
+ * );
+ *
+ * // Invalidate a specific entry after a mutation
+ * await updateAccount(id, fields);
+ * clearCacheEntry(`account:${id}`);
+ *
+ * // Or clear everything (e.g. on logout)
+ * clearCache();
+ */
+export function useCachedAsyncData<T>(
+	fetcher: () => Promise<T>,
+	deps: React.DependencyList,
+	options: CacheOptions,
+): UseAsyncDataResult<T> {
+	const ttl = options.ttl ?? 30_000;
+	const maxSize = options.maxSize ?? 50;
+	const cacheKey = options.key;
+
+	// Synchronous cache check during state initialization so a cache hit
+	// never triggers a loading → loaded transition (avoids UI flicker).
+	const cached = getValidEntry(cacheKey, ttl);
+
+	const [data, setData] = useState<T | null>((cached?.data as T) ?? null);
+	const [loading, setLoading] = useState(!cached);
+	const [error, setError] = useState<string | null>(null);
+
+	// eslint-disable-next-line react-hooks/exhaustive-deps --- deps are explicitly managed by the caller
+	const memoizedFetcher = useCallback(fetcher, deps);
+
+	useEffect(() => {
+		// Re-check the cache inside the effect because deps may have changed
+		// since the initial render (e.g. StrictMode double-invoke).
+		const entry = getValidEntry(cacheKey, ttl);
+		if (entry) {
+			setData(entry.data as T);
+			setLoading(false);
+			setError(null);
+			return;
+		}
+
+		// No cache hit — fetch from the network.
+		let cancelled = false;
+		setLoading(true);
+		setError(null);
+
+		memoizedFetcher()
+			.then((result) => {
+				if (!cancelled) {
+					setEntry(cacheKey, result, maxSize);
+					setData(result);
+				}
+			})
+			.catch((err) => {
+				console.error(err);
+				if (!cancelled) setError(err instanceof Error ? err.message : "An error occurred");
+			})
+			.finally(() => {
+				if (!cancelled) setLoading(false);
+			});
+
+		// Cleanup: if deps change or the component unmounts before the fetch
+		// completes, the cancelled flag prevents stale state updates.
+		return () => {
+			cancelled = true;
+		};
+	}, [memoizedFetcher, cacheKey, ttl, maxSize]);
+
+	return { data, loading, error };
+}