@expokit/cli 0.4.4 → 0.5.0

package/registry/avatar/files/src/components/ui/avatar.tsx

@@ -1,5 +1,5 @@
 import * as Haptics from 'expo-haptics';
-import React, { useEffect, useId, useRef, useState } from 'react';
+import React, { useEffect, useId, useState } from 'react';
 import {
   AccessibilityInfo,
   Animated,
@@ -25,41 +25,41 @@ export type AvatarFallback = 'soft' | 'solid' | 'gradient';
 
 export interface AvatarProps {
   /** Image URL. Initials show while it loads, and stay if it fails. */
-  src?: string;
+  src?: string | undefined;
   /** Used for the initials, the fallback colour (same name → same colour) and the accessibility label. */
-  name?: string;
+  name?: string | undefined;
   /** 'xs' 24 · 'sm' 32 · 'md' 40 · 'lg' 56 · 'xl' 72, or any number of points. */
-  size?: AvatarSize | number;
-  shape?: AvatarShape;
+  size?: AvatarSize | number | undefined;
+  shape?: AvatarShape | undefined;
   /** Presence dot cut into the bottom-right edge. */
-  status?: AvatarStatus;
+  status?: AvatarStatus | undefined;
   /** Soft pulse behind the status dot (default: on for 'online'). */
-  pulse?: boolean;
+  pulse?: boolean | undefined;
   /** Ring around the face, separated by a clear gap. */
-  ring?: AvatarRing;
+  ring?: AvatarRing | undefined;
   /** The story has been watched: the ring cross-fades to a quiet hairline. */
-  seen?: boolean;
+  seen?: boolean | undefined;
   /** Ring colour override — the first entry is used as a solid colour (default: `accent`). */
-  ringColors?: string[];
+  ringColors?: string[] | undefined;
   /** Spin a broken story ring — a "story is loading" state. */
-  ringSpin?: boolean;
+  ringSpin?: boolean | undefined;
   /** Initials look when there is no photo. Default 'soft'. */
-  fallback?: AvatarFallback;
+  fallback?: AvatarFallback | undefined;
   /** Soft layered shadow under the face (default true for 72pt and up). */
-  elevated?: boolean;
+  elevated?: boolean | undefined;
   /** Notification count (`true` = dot), top-right. */
-  badge?: number | boolean;
+  badge?: number | boolean | undefined;
   /** Verified seal with a check, bottom-right (bottom-left when a status dot is shown). */
-  verified?: boolean;
+  verified?: boolean | undefined;
   /** Colour behind the avatar — the dot, badge and seal cut-outs are punched in it. Default: theme background. */
-  surface?: string;
+  surface?: string | undefined;
   /** Ring and verified seal colour (default: theme accent). */
-  accent?: string;
+  accent?: string | undefined;
   /** Makes it a button with a spring press and a light haptic tick. */
-  onPress?: () => void;
+  onPress?: (() => void) | undefined;
   /** Haptic tick on press (default true). */
-  haptics?: boolean;
-  style?: StyleProp<ViewStyle>;
+  haptics?: boolean | undefined;
+  style?: StyleProp<ViewStyle> | undefined;
 }
 
 const SIZES: Record<AvatarSize, number> = { xs: 24, sm: 32, md: 40, lg: 56, xl: 72 };
@@ -99,7 +99,9 @@ export function colorFromName(name = '') {
 export function initialsFrom(name = '', max = 2) {
   const parts = name.trim().split(/\s+/).filter(Boolean);
   if (!parts.length) return '';
-  const letters = parts.length === 1 ? [parts[0][0]] : [parts[0][0], parts[parts.length - 1][0]];
+  const first = parts[0] ?? '';
+  const last = parts[parts.length - 1] ?? '';
+  const letters = parts.length === 1 ? [first[0]] : [first[0], last[0]];
   return letters.slice(0, max).join('').toUpperCase();
 }
 
@@ -144,13 +146,13 @@ export function Avatar({
   // Remember which URL failed so a new `src` gets a fresh try without resetting state in an effect.
   const [failedSrc, setFailedSrc] = useState<string>();
   const failed = !!src && failedSrc === src;
-  const loaded = useRef(new Animated.Value(0)).current;
-  const press = useRef(new Animated.Value(1)).current;
-  const spin = useRef(new Animated.Value(0)).current;
-  const pulseV = useRef(new Animated.Value(0)).current;
+  const [loaded] = useState(() => new Animated.Value(0));
+  const [press] = useState(() => new Animated.Value(1));
+  const [spin] = useState(() => new Animated.Value(0));
+  const [pulseV] = useState(() => new Animated.Value(0));
 
   const isSeen = seen ?? ring === 'seen';
-  const seenV = useRef(new Animated.Value(isSeen ? 1 : 0)).current;
+  const [seenV] = useState(() => new Animated.Value(isSeen ? 1 : 0));
 
   useEffect(() => {
     loaded.setValue(0);
@@ -335,7 +337,7 @@ export function Avatar({
         strokeWidth={width}
         fill="none"
         strokeLinecap="round"
-        strokeDasharray={dashed ? [circ * 0.7, circ * 0.3] : undefined}
+        {...(dashed ? { strokeDasharray: [circ * 0.7, circ * 0.3] } : null)}
       />
     ) : (
       <Rect
@@ -568,12 +570,15 @@ const SEAL = (() => {
     const rr = k % 2 === 0 ? 12 : 10.1;
     return [12 + rr * Math.cos(a), 12 + rr * Math.sin(a)] as const;
   });
-  const mid = (a: readonly number[], b: readonly number[]) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+  type Pt = readonly [number, number];
+  const mid = (a: Pt, b: Pt): Pt => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
   const f = (v: number) => v.toFixed(2);
-  const start = mid(pts[pts.length - 1], pts[0]);
+  // `pts` has 2n points and every index below is taken modulo its length.
+  const at = (k: number) => pts[k % pts.length]!;
+  const start = mid(at(pts.length - 1), at(0));
   let d = `M${f(start[0])} ${f(start[1])}`;
   pts.forEach((pt, i) => {
-    const m = mid(pt, pts[(i + 1) % pts.length]);
+    const m = mid(pt, at(i + 1));
     d += `Q${f(pt[0])} ${f(pt[1])} ${f(m[0])} ${f(m[1])}`;
   });
   return d + 'Z';
@@ -593,20 +598,20 @@ export interface AvatarGroupProps {
   /** `<Avatar>` elements. The group sets their size, shape and surface. */
   children: React.ReactNode;
   /** Show at most this many, then a "+N" chip. */
-  max?: number;
-  size?: AvatarSize | number;
-  shape?: AvatarShape;
+  max?: number | undefined;
+  size?: AvatarSize | number | undefined;
+  shape?: AvatarShape | undefined;
   /** How far each avatar tucks under the previous one, as a fraction of its size (default 0.28). */
-  overlap?: number;
+  overlap?: number | undefined;
   /** Real total when it is larger than the children you pass (e.g. 1,284 members). */
-  total?: number;
+  total?: number | undefined;
   /** Staggered spring-in on mount (skipped with reduce motion). */
-  animated?: boolean;
+  animated?: boolean | undefined;
   /** Colour of the separating borders — match what the group sits on (default: theme background). */
-  surface?: string;
+  surface?: string | undefined;
   /** Makes the "+N" chip a button. */
-  onPressMore?: () => void;
-  style?: StyleProp<ViewStyle>;
+  onPressMore?: (() => void) | undefined;
+  style?: StyleProp<ViewStyle> | undefined;
 }
 
 /** Overlapping avatars separated by cut-out borders, with a "+N" chip and a staggered spring-in. */
@@ -622,7 +627,7 @@ export function AvatarGroup({
   onPressMore,
   style,
 }: AvatarGroupProps) {
-  const { colors, radius, dark, font } = useKit();
+  const { colors, radius, dark, font, labels } = useKit();
   const ff = font.family ? { fontFamily: font.family } : null;
   const reduceMotion = useReduceMotion();
   const px = resolveSize(size);
@@ -635,8 +640,13 @@ export function AvatarGroup({
   const inner = shape === 'circle' ? radius.full : Math.min(px / 2, radius.scale(Math.round(px * 0.3)));
   const wrapCorner = shape === 'circle' ? radius.full : inner + border;
 
-  const anims = useRef<Animated.Value[]>([]).current;
-  while (anims.length < count) anims.push(new Animated.Value(animated ? 0 : 1));
+  // One value per avatar, grown (never shrunk) as children are added; this render already uses the grown list.
+  const [pool, setPool] = useState<Animated.Value[]>([]);
+  let anims = pool;
+  if (pool.length < count) {
+    anims = [...pool, ...Array.from({ length: count - pool.length }, () => new Animated.Value(animated ? 0 : 1))];
+    setPool(anims);
+  }
 
   useEffect(() => {
     if (!animated) return;
@@ -654,35 +664,41 @@ export function AvatarGroup({
   const names = shown.map((c) => c.props.name).filter(Boolean) as string[];
   const label =
     names.length === 0
-      ? `${total ?? items.length} people`
-      : `${names.slice(0, 3).join(', ')}${(total ?? items.length) - Math.min(3, names.length) > 0 ? ` and ${(total ?? items.length) - Math.min(3, names.length)} more` : ''}`;
-
-  const wrap = (child: React.ReactNode, i: number, key: React.Key) => (
-    <Animated.View
-      key={key}
-      style={{
-        marginLeft: i === 0 ? 0 : -px * overlap,
-        borderRadius: wrapCorner,
-        padding: border,
-        backgroundColor: bg,
-        zIndex: count - i,
-        opacity: anims[i],
-        transform: [
-          { translateX: anims[i].interpolate({ inputRange: [0, 1], outputRange: [-8, 0] }) },
-          { scale: anims[i].interpolate({ inputRange: [0, 1], outputRange: [0.6, 1] }) },
-        ],
-      }}
-    >
-      {child}
-    </Animated.View>
-  );
+      ? labels.peopleCount(total ?? items.length)
+      : (total ?? items.length) - Math.min(3, names.length) > 0
+        ? labels.namesAndMore(names.slice(0, 3).join(', '), (total ?? items.length) - Math.min(3, names.length))
+        : names.slice(0, 3).join(', ');
+
+  // `anims` was grown to `count` above, and i < count.
+  const wrap = (child: React.ReactNode, i: number, key: React.Key) => {
+    const v = anims[i]!;
+    return (
+      <Animated.View
+        key={key}
+        style={{
+          marginLeft: i === 0 ? 0 : -px * overlap,
+          borderRadius: wrapCorner,
+          padding: border,
+          backgroundColor: bg,
+          zIndex: count - i,
+          opacity: v,
+          transform: [
+            { translateX: v.interpolate({ inputRange: [0, 1], outputRange: [-8, 0] }) },
+            { scale: v.interpolate({ inputRange: [0, 1], outputRange: [0.6, 1] }) },
+          ],
+        }}
+      >
+        {child}
+      </Animated.View>
+    );
+  };
 
   const extraText = extra > 999 ? `${(extra / 1000).toFixed(extra >= 10000 ? 0 : 1).replace(/\.0$/, '')}k` : String(extra);
   const more =
     extra > 0 ? (
       <Pressable
         accessibilityRole={onPressMore ? 'button' : 'text'}
-        accessibilityLabel={`${extra} more`}
+        accessibilityLabel={labels.moreCount(extra)}
         disabled={!onPressMore}
         onPress={onPressMore}
         hitSlop={px < 44 ? Math.ceil((44 - px) / 2) : undefined}
@@ -771,7 +787,9 @@ function luminance(hex: string) {
 }
 
 function contrast(a: string, b: string) {
-  const [x, y] = [luminance(a), luminance(b)].sort((p, q) => q - p);
+  const la = luminance(a);
+  const lb = luminance(b);
+  const [x, y] = la >= lb ? [la, lb] : [lb, la];
   return (x + 0.05) / (y + 0.05);
 }
 

package/registry/avatar/files/src/lib/kit.tsx

@@ -1,5 +1,14 @@
-import React, { createContext, useContext, useMemo } from 'react';
-import { Platform, useColorScheme, useWindowDimensions, type TextStyle, type ViewStyle } from 'react-native';
+import React, { createContext, useContext, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import {
+  PanResponder,
+  Platform,
+  useColorScheme,
+  useWindowDimensions,
+  type GestureResponderHandlers,
+  type PanResponderCallbacks,
+  type TextStyle,
+  type ViewStyle,
+} from 'react-native';
 
 /**
  * ExpoKit design tokens. Every component reads them through useKit(), so one
@@ -9,9 +18,9 @@ import { Platform, useColorScheme, useWindowDimensions, type TextStyle, type Vie
 
 /**
  * Bumped whenever components start using a new kit API (2: radius.scale / radius.capsule,
- * 3: useLayout / shadow). The CLI won't keep an edited kit.tsx older than the component being added needs.
+ * 3: useLayout / shadow, 4: labels, 5: visible labels such as Cancel / Done / Today, AM / PM, usePanResponder / useLatest). The CLI won't keep an edited kit.tsx older than the component being added needs.
  */
-export const KIT_VERSION = 3;
+export const KIT_VERSION = 5;
 
 export type ColorScheme = 'light' | 'dark';
 
@@ -60,10 +69,298 @@ export interface Theme {
   space: (n: number) => number;
   /** The same soft shadow on iOS, Android and web: `style={[styles.card, shadow('md')]}`. */
   shadow: (level: ShadowLevel, color?: string) => ViewStyle;
-  font: { family?: string; mono: string };
+  font: { family?: string | undefined; mono: string };
   text: Record<'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl', TextStyle>;
+  /** Text the kit shows or speaks on its own (buttons, placeholders, screen-reader names). Translate with <KitProvider labels={...}>. */
+  labels: Labels;
 }
 
+/**
+ * Every string the kit shows or speaks on its own: button text and placeholders (Cancel, Done, Today,
+ * Search…) and what screen readers say (close buttons, grabbers, hints). A prop on a component, like
+ * `cancelLabel` or `placeholder`, still wins over these.
+ * Pass a partial map to <KitProvider labels={...}>; keys you leave out stay English.
+ * Functions get the dynamic part, so word order can change per language.
+ */
+export interface Labels {
+  close: string;
+  dismiss: string;
+  closeSheet: string;
+  sheetGrabber: string;
+  sheetResizeHint: string;
+  sheetResizeOrCloseHint: string;
+  navigationDrawer: string;
+  closeDrawer: string;
+  closeMenu: string;
+  switchAccount: string;
+  openActions: string;
+  closeActions: string;
+  action: string;
+  loading: string;
+  clearSearch: string;
+  cancelSearch: string;
+  clearField: (field: string) => string;
+  back: string;
+  previous: string;
+  next: string;
+  goToToday: string;
+  goToSlide: (n: number) => string;
+  showAllCards: string;
+  expandNotification: string;
+  collapseNotification: string;
+  moreCount: (n: number) => string;
+  peopleCount: (n: number) => string;
+  namesAndMore: (names: string, n: number) => string;
+  newCount: (badge: string) => string;
+  remove: (item: string) => string;
+  selectedCount: (n: number) => string;
+  noneSelected: string;
+  notSet: string;
+  date: string;
+  time: string;
+  hour: string;
+  minute: string;
+  hours: (n: string) => string;
+  minutes: (n: number) => string;
+  booked: string;
+  unavailable: string;
+  timeDialHint: string;
+  flipCalendarHint: string;
+  increase: string;
+  decrease: string;
+  increaseItem: (item: string) => string;
+  decreaseItem: (item: string) => string;
+  range: string;
+  rangeMinimum: (name: string) => string;
+  rangeMaximum: (name: string) => string;
+  ratingStars: string;
+  ratingHearts: string;
+  showPassword: string;
+  hidePassword: string;
+  passwordStrength: (level: string) => string;
+  ruleMet: (rule: string) => string;
+  ruleUnmet: (rule: string) => string;
+  stepOf: (step: number, total: number, label: string) => string;
+  allStepsComplete: string;
+  stepCurrent: string;
+  stepCompleted: string;
+  stepNeedsAttention: string;
+  stepNotStarted: string;
+  goBackToStep: string;
+  activateCodeField: string;
+  qrCodeFor: (value: string) => string;
+  undoStroke: string;
+  signaturePad: string;
+  signaturePadSigned: string;
+  flipToBack: string;
+  flipToFront: string;
+  revealHint: string;
+  confirmHint: string;
+  prizeWheel: string;
+  spinHint: string;
+  prizes: (n: number, list: string) => string;
+  orbReveal: string;
+  orbBack: string;
+  // Visible text
+  cancel: string;
+  done: string;
+  doneCount: (n: number) => string;
+  doneDays: (n: number) => string;
+  clear: string;
+  continue: string;
+  delete: string;
+  failed: string;
+  search: string;
+  noResults: string;
+  noOptions: string;
+  nothingMatches: (query: string) => string;
+  selectPlaceholder: string;
+  selectDate: string;
+  selectDates: string;
+  pickStartDate: string;
+  pickEndDate: string;
+  selectTime: string;
+  setTime: (time: string) => string;
+  /** Clock periods, shown on 12-hour pickers and times. */
+  am: string;
+  pm: string;
+  /** Read for the AM / PM column. */
+  amPm: string;
+  morning: string;
+  afternoon: string;
+  evening: string;
+  slotsOpen: (n: number) => string;
+  full: string;
+  today: string;
+  tomorrow: string;
+  nextMonday: string;
+  inAWeek: string;
+  inAMonth: string;
+  next7Days: string;
+  nextWeekend: string;
+  thisMonth: string;
+  last7Days: string;
+  last30Days: string;
+  chooseOneOrMore: string;
+  /** After a rolling count, as in "2 selected". */
+  selectedSuffix: string;
+  chooseMonth: string;
+  chooseYear: string;
+  backToDays: string;
+  dayAndWeek: (day: number, week: number) => string;
+  daysLeft: (n: number) => string;
+  /** Too short, Weak, Okay, Strong, Very strong. */
+  passwordLevels: [string, string, string, string, string];
+  passwordsMatch: string;
+  passwordsDontMatch: string;
+  showQrCode: string;
+  copy: string;
+  copied: string;
+  slideToConfirm: string;
+  confirmed: string;
+  like: string;
+  nope: string;
+  swipeRight: string;
+  swipeLeft: string;
+}
+
+export const defaultLabels: Labels = {
+  close: 'Close',
+  dismiss: 'Dismiss',
+  closeSheet: 'Close sheet',
+  sheetGrabber: 'Sheet grabber',
+  sheetResizeHint: 'Swipe up or down to resize',
+  sheetResizeOrCloseHint: 'Swipe up or down to resize or close',
+  navigationDrawer: 'Navigation drawer',
+  closeDrawer: 'Close drawer',
+  closeMenu: 'Close menu',
+  switchAccount: 'Switch account',
+  openActions: 'Open actions',
+  closeActions: 'Close actions',
+  action: 'Action',
+  loading: 'Loading',
+  clearSearch: 'Clear search',
+  cancelSearch: 'Cancel search',
+  clearField: (field) => `Clear ${field}`,
+  back: 'Back',
+  previous: 'Previous',
+  next: 'Next',
+  goToToday: 'Go to today',
+  goToSlide: (n) => `Go to slide ${n}`,
+  showAllCards: 'Shows all cards',
+  expandNotification: 'Expands the notification',
+  collapseNotification: 'Collapses the notification',
+  moreCount: (n) => `${n} more`,
+  peopleCount: (n) => `${n} people`,
+  namesAndMore: (names, n) => `${names} and ${n} more`,
+  newCount: (badge) => `${badge} new`,
+  remove: (item) => `Remove ${item}`,
+  selectedCount: (n) => `${n} selected`,
+  noneSelected: 'None selected',
+  notSet: 'Not set',
+  date: 'Date',
+  time: 'Time',
+  hour: 'Hour',
+  minute: 'Minute',
+  hours: (n) => `${n} hours`,
+  minutes: (n) => `${n} minutes`,
+  booked: 'booked',
+  unavailable: 'unavailable',
+  timeDialHint: 'Drag around the dial, or swipe up or down to adjust.',
+  flipCalendarHint: 'Swipe up to turn to the next day, down for the previous one.',
+  increase: 'Increase',
+  decrease: 'Decrease',
+  increaseItem: (item) => `Increase ${item}`,
+  decreaseItem: (item) => `Decrease ${item}`,
+  range: 'Range',
+  rangeMinimum: (name) => `${name} minimum`,
+  rangeMaximum: (name) => `${name} maximum`,
+  ratingStars: 'Rating, stars',
+  ratingHearts: 'Rating, hearts',
+  showPassword: 'Show password',
+  hidePassword: 'Hide password',
+  passwordStrength: (level) => `Password strength: ${level}`,
+  ruleMet: (rule) => `${rule}: done`,
+  ruleUnmet: (rule) => `${rule}: not yet`,
+  stepOf: (step, total, label) => `Step ${step} of ${total}, ${label}`,
+  allStepsComplete: 'All steps complete',
+  stepCurrent: 'current',
+  stepCompleted: 'completed',
+  stepNeedsAttention: 'needs attention',
+  stepNotStarted: 'not started',
+  goBackToStep: 'Goes back to this step',
+  activateCodeField: 'Activates the code field',
+  qrCodeFor: (value) => `QR code for ${value}`,
+  undoStroke: 'Undo last stroke',
+  signaturePad: 'Signature pad, draw your signature',
+  signaturePadSigned: 'Signature pad, signed',
+  flipToBack: 'Tap to flip to the back.',
+  flipToFront: 'Showing the back. Tap to flip to the front.',
+  revealHint: 'Double-tap to reveal',
+  confirmHint: 'Double tap to confirm',
+  prizeWheel: 'Prize wheel',
+  spinHint: 'Spins the wheel for a prize',
+  prizes: (n, list) => `${n} prizes: ${list}`,
+  orbReveal: 'Reveal',
+  orbBack: 'Glass orb, drag down to go back',
+  cancel: 'Cancel',
+  done: 'Done',
+  doneCount: (n) => `Done · ${n}`,
+  doneDays: (n) => `Done · ${n} days`,
+  clear: 'Clear',
+  continue: 'Continue',
+  delete: 'Delete',
+  failed: 'Failed',
+  search: 'Search',
+  noResults: 'No results',
+  noOptions: 'No options',
+  nothingMatches: (query) => `Nothing matches “${query}”.`,
+  selectPlaceholder: 'Select…',
+  selectDate: 'Select a date',
+  selectDates: 'Select dates',
+  pickStartDate: 'Pick a start date',
+  pickEndDate: 'pick an end date',
+  selectTime: 'Select a time',
+  setTime: (time) => `Set ${time}`,
+  am: 'AM',
+  pm: 'PM',
+  amPm: 'AM or PM',
+  morning: 'Morning',
+  afternoon: 'Afternoon',
+  evening: 'Evening',
+  slotsOpen: (n) => `${n} open`,
+  full: 'Full',
+  today: 'Today',
+  tomorrow: 'Tomorrow',
+  nextMonday: 'Next Monday',
+  inAWeek: 'In a week',
+  inAMonth: 'In a month',
+  next7Days: 'Next 7 days',
+  nextWeekend: 'Next weekend',
+  thisMonth: 'This month',
+  last7Days: 'Last 7 days',
+  last30Days: 'Last 30 days',
+  chooseOneOrMore: 'Choose one or more',
+  selectedSuffix: 'selected',
+  chooseMonth: 'choose month',
+  chooseYear: 'choose year',
+  backToDays: 'back to days',
+  dayAndWeek: (day, week) => `Day ${day} · Week ${week}`,
+  daysLeft: (n) => `${n} left`,
+  passwordLevels: ['Too short', 'Weak', 'Okay', 'Strong', 'Very strong'],
+  passwordsMatch: 'Passwords match',
+  passwordsDontMatch: "Passwords don't match",
+  showQrCode: 'Show QR Code',
+  copy: 'Copy',
+  copied: 'Copied',
+  slideToConfirm: 'Slide to confirm',
+  confirmed: 'Confirmed',
+  like: 'LIKE',
+  nope: 'NOPE',
+  swipeRight: 'Right',
+  swipeLeft: 'Left',
+};
+
 const light: Colors = {
   background: '#ffffff',
   foreground: '#09090b',
@@ -149,20 +446,27 @@ function build(scheme: ColorScheme, overrides?: ThemeOverrides): Theme {
       xl: { fontSize: 22, lineHeight: 28, fontWeight: '400', letterSpacing: -0.3 },
       xxl: { fontSize: 30, lineHeight: 36, fontWeight: '400', letterSpacing: -0.8 },
     },
+    labels: overrides?.labels ? { ...defaultLabels, ...overrides.labels } : defaultLabels,
   };
 }
 
 export interface ThemeOverrides {
   /** Brand colour used for focus rings, selected states and accent buttons. */
-  accent?: string;
+  accent?: string | undefined;
+
   /** Base corner radius in points (default 12). */
-  radius?: number;
-  fontFamily?: string;
+  radius?: number | undefined;
+
+  fontFamily?: string | undefined;
+
   /** Override any token per scheme. */
-  colors?: Partial<Record<ColorScheme, Partial<Colors>>>;
+  colors?: Partial<Record<ColorScheme, Partial<Colors>>> | undefined;
+
+  /** Screen-reader strings in your language, e.g. { close: "बंद करें" }. Keys you leave out stay English. */
+  labels?: Partial<Labels> | undefined;
 }
 
-const KitContext = createContext<{ scheme?: ColorScheme; overrides?: ThemeOverrides } | null>(null);
+const KitContext = createContext<{ scheme?: ColorScheme | undefined; overrides?: ThemeOverrides | undefined } | null>(null);
 
 export function KitProvider({
   scheme,
@@ -172,7 +476,7 @@ export function KitProvider({
   const value = useMemo(
     () => ({ scheme: scheme === 'system' ? undefined : scheme, overrides }),
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [scheme, overrides.accent, overrides.radius, overrides.fontFamily, overrides.colors]
+    [scheme, overrides.accent, overrides.radius, overrides.fontFamily, overrides.colors, overrides.labels]
   );
   return <KitContext.Provider value={value}>{children}</KitContext.Provider>;
 }
@@ -318,3 +622,51 @@ export function isTextNode(node: React.ReactNode): node is string | number | (st
   if (typeof node === 'string' || typeof node === 'number') return true;
   return Array.isArray(node) && node.length > 0 && node.every((n) => typeof n === 'string' || typeof n === 'number');
 }
+
+/**
+ * A ref that always holds the latest `value`, for gesture and timer callbacks that must not go stale.
+ * Read `.current` only inside callbacks and effects, never while rendering.
+ */
+export function useLatest<T>(value: T): React.MutableRefObject<T> {
+  const ref = useRef(value);
+  useLayoutEffect(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+
+const panKeys = [
+  'onStartShouldSetPanResponder',
+  'onStartShouldSetPanResponderCapture',
+  'onMoveShouldSetPanResponder',
+  'onMoveShouldSetPanResponderCapture',
+  'onPanResponderGrant',
+  'onPanResponderStart',
+  'onPanResponderMove',
+  'onPanResponderEnd',
+  'onPanResponderRelease',
+  'onPanResponderReject',
+  'onPanResponderTerminate',
+] as const;
+
+/**
+ * PanResponder handlers that always call the latest `config`, created once. Write the callbacks inline:
+ * they may read refs and props freely, and nothing is recreated between renders, so a drag in progress
+ * is never cut off. Spread the result: `<View {...pan} />`.
+ */
+export function usePanResponder(config: PanResponderCallbacks): GestureResponderHandlers {
+  const latest = useLatest(config);
+  const [handlers] = useState(() => {
+    const forward: Record<string, (...args: never[]) => unknown> = {};
+    for (const key of panKeys) {
+      forward[key] = (...args) => (latest.current[key] as ((...a: never[]) => unknown) | undefined)?.(...args);
+    }
+    // React Native's defaults when these are left out are `true`, so keep them when the config has none.
+    forward.onPanResponderTerminationRequest = (...args) =>
+      (latest.current.onPanResponderTerminationRequest as ((...a: never[]) => boolean) | undefined)?.(...args) ?? true;
+    forward.onShouldBlockNativeResponder = (...args) =>
+      (latest.current.onShouldBlockNativeResponder as ((...a: never[]) => boolean) | undefined)?.(...args) ?? true;
+    return PanResponder.create(forward as PanResponderCallbacks).panHandlers;
+  });
+  return handlers;
+}

package/registry/avatar.json

@@ -4,6 +4,7 @@
   "title": "Avatar",
   "description": "Photo that fades in over soft tinted initials (hue hashed from the name, ink picked for contrast), presence dots, notification badges and a verified seal cut into the edge, a gapped story ring that cross-fades to “seen”, and an AvatarGroup with cut-out borders, a +N chip and a staggered spring-in.",
   "tier": "free",
+  "aliases": [],
   "dependencies": [
     "react-native-svg",
     "expo-haptics"