@squad-sports/react-native 1.3.1

package/src/state/sync/polls.ts

@@ -0,0 +1,37 @@
+/**
+ * Poll sync atoms.
+ * Ported from squad-demo/src/atoms/sync/polls.ts.
+ */
+import { atom, atomFamily } from 'recoil';
+import type { PollFeed, PollResponse, PollResponseReaction } from '@squad-sports/core';
+import { type CrdtArray } from './crdt';
+
+// Initial poll feed from API
+export const reInitialPollFeed = atom<PollFeed | null>({
+  key: 'squad-sdk:polls:active:initial:v2',
+  default: null,
+});
+
+// Real-time poll updates
+export const rePollUpdates = atom<CrdtArray<string, unknown>>({
+  key: 'squad-sdk:poll-feed:updates:v2',
+  default: new Map(),
+});
+
+// Poll response updates per poll
+export const rePollResponseUpdates = atomFamily<CrdtArray<string, PollResponse>, string>({
+  key: 'squad-sdk:poll:responses:updates:v2',
+  default: new Map(),
+});
+
+// Poll response reaction updates
+export const rePollResponseReactionsUpdates = atomFamily<CrdtArray<string, PollResponseReaction>, string>({
+  key: 'squad-sdk:poll:response:reactions:updates',
+  default: new Map(),
+});
+
+// Poll nudge updates
+export const rePollNudgesUpdates = atomFamily<CrdtArray<string, unknown>, string>({
+  key: 'squad-sdk:poll:nudges:updates',
+  default: new Map(),
+});

package/src/state/sync/refresh.ts

@@ -0,0 +1,24 @@
+/**
+ * Refresh trigger atom.
+ * Ported from squad-demo/src/atoms/sync/refresh.ts.
+ */
+import { atom } from 'recoil';
+import { DependableSelector } from './dependable';
+
+export const reLastRefreshed = atom<number>({
+  key: 'squad-sdk:last-refreshed',
+  default: Date.now(),
+});
+
+export const reRefresh = new DependableSelector<number>({
+  key: 'squad-sdk:refresh',
+  get: ({ get }) => get(reLastRefreshed),
+  set: ({ set }, newValue) => {
+    set(reLastRefreshed, typeof newValue === 'number' ? newValue : Date.now());
+  },
+});
+
+export const reRefreshing = atom<boolean>({
+  key: 'squad-sdk:refreshing',
+  default: false,
+});

package/src/state/sync/squad-v2.ts

@@ -0,0 +1,25 @@
+/**
+ * Squad/connections sync atoms.
+ * Ported from squad-demo/src/atoms/sync/squad-v2.ts.
+ */
+import { atom } from 'recoil';
+import type { Squad, Connection } from '@squad-sports/core';
+import { type CrdtArray } from './crdt';
+
+// Initial connections from API
+export const reInitialConnections = atom<Squad | null>({
+  key: 'squad-sdk:squad:initial',
+  default: null,
+});
+
+// Real-time connection updates
+export const reConnectionUpdates = atom<CrdtArray<string, Connection>>({
+  key: 'squad-sdk:squad:updates',
+  default: new Map(),
+});
+
+// Connection by user ID
+export const reConnectionWithUser = atom<Map<string, Connection>>({
+  key: 'squad-sdk:squad:connectionByUser',
+  default: new Map(),
+});

package/src/state/ui.ts

@@ -0,0 +1,36 @@
+/**
+ * UI state atoms.
+ * Ported from squad-demo/src/atoms/loading-overlay.ts + keyboard.ts + networkBannerState.ts + networkStateAtom.ts.
+ */
+import { atom } from 'recoil';
+
+// Loading overlay
+export const loadingOverlayVisible = atom<boolean>({
+  key: 'squad-sdk:loading-overlay:visible',
+  default: false,
+});
+
+export const loadingOverlayText = atom<string>({
+  key: 'squad-sdk:loading-overlay:text',
+  default: '',
+});
+
+// Keyboard
+export const aKeyboardOpen = atom<boolean>({
+  key: 'squad-sdk:keyboard:open',
+  default: false,
+});
+
+// Network banner
+export const networkBannerVisible = atom<boolean>({
+  key: 'squad-sdk:network:bannerVisible',
+  default: false,
+});
+
+export const networkStateAtom = atom<{
+  isConnected: boolean;
+  isInternetReachable: boolean | null;
+}>({
+  key: 'squad-sdk:network:state',
+  default: { isConnected: true, isInternetReachable: true },
+});

package/src/state/user.ts

@@ -0,0 +1,46 @@
+/**
+ * User state atoms.
+ * Ported from squad-demo/src/atoms/user.ts + user-tag.ts + sync/user-v2.ts.
+ */
+import { atom, atomFamily, selectorFamily } from 'recoil';
+import type { User } from '@squad-sports/core';
+import { type CrdtArray, type CrdtArrayItem } from './sync/crdt';
+
+// Logged-in user cache
+export const reUserCache = atom<User | null>({
+  key: 'squad-sdk:user:cache',
+  default: null,
+});
+
+export const reLoggedInUserLoaded = atom<boolean>({
+  key: 'squad-sdk:user:loaded',
+  default: false,
+});
+
+// Per-user updates from SSE
+export const userUpdates = atomFamily<CrdtArrayItem<User> | null, string>({
+  key: 'squad-sdk:user:updates',
+  default: null,
+});
+
+// User by ID (selector family)
+export const reUser = selectorFamily<User | null, string>({
+  key: 'squad-sdk:user:byId',
+  get: (id) => ({ get }) => {
+    const cache = get(reUserCache);
+    if (cache?.id === id) return cache;
+    return null; // Would need API call for other users
+  },
+});
+
+// User tag
+export const reUserTag = atom<string | null>({
+  key: 'squad-sdk:user:tag',
+  default: null,
+});
+
+// Sophia (AI assistant)
+export const reSophiaUser = atom<User | null>({
+  key: 'squad-sdk:user:sophia',
+  default: null,
+});

package/src/state/wallet.ts

@@ -0,0 +1,26 @@
+/**
+ * Wallet and coupon atoms.
+ * Ported from squad-demo/src/atoms/wallet.ts.
+ */
+import { atom } from 'recoil';
+import type { Wallet, Coupons, Brands } from '@squad-sports/core';
+
+export const reWallet = atom<Wallet | null>({
+  key: 'squad-sdk:wallet:data',
+  default: null,
+});
+
+export const reCoupons = atom<Coupons | null>({
+  key: 'squad-sdk:wallet:coupons',
+  default: null,
+});
+
+export const reBrands = atom<Brands | null>({
+  key: 'squad-sdk:wallet:brands',
+  default: null,
+});
+
+export const reWalletRefresh = atom<number>({
+  key: 'squad-sdk:wallet:refresh',
+  default: 0,
+});

package/src/storage/SecureStorage.ts

@@ -0,0 +1,77 @@
+import type { StorageAdapter } from '@squad-sports/core';
+
+/**
+ * Secure storage adapter for React Native.
+ * Uses expo-secure-store (encrypted) when available, falls back to AsyncStorage.
+ * Sensitive keys (tokens, user IDs) are always stored securely.
+ */
+export class SecureStorageAdapter implements StorageAdapter {
+  private secureStore: any = null;
+  private asyncStorage: any = null;
+  private initialized = false;
+
+  private static readonly SECURE_KEYS = new Set([
+    'SQUAD_SDK_AUTH_TOKEN',
+    'SQUAD_SDK_AUTH_USER_ID',
+    'SQUAD_SDK_AUTH_EMAIL',
+    'SQUAD_SDK_AUTH_PHONE',
+    'SQUAD_SDK_AUTH_COMMUNITY_ID',
+    'SQUAD_SDK_AUTH_PARTNER_ID',
+  ]);
+
+  private async init(): Promise<void> {
+    if (this.initialized) return;
+    try {
+      this.secureStore = (await import('expo-secure-store'));
+    } catch {
+      // expo-secure-store not available
+    }
+    try {
+      this.asyncStorage = (await import('@react-native-async-storage/async-storage')).default;
+    } catch {
+      // AsyncStorage not available
+    }
+    this.initialized = true;
+  }
+
+  private isSecureKey(key: string): boolean {
+    return SecureStorageAdapter.SECURE_KEYS.has(key);
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    await this.init();
+    if (this.isSecureKey(key) && this.secureStore) {
+      try {
+        return await this.secureStore.getItemAsync(key);
+      } catch {
+        // Fall through to AsyncStorage
+      }
+    }
+    return this.asyncStorage?.getItem(key) ?? null;
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    await this.init();
+    if (this.isSecureKey(key) && this.secureStore) {
+      try {
+        await this.secureStore.setItemAsync(key, value);
+        return;
+      } catch {
+        // Fall through to AsyncStorage
+      }
+    }
+    await this.asyncStorage?.setItem(key, value);
+  }
+
+  async removeItem(key: string): Promise<void> {
+    await this.init();
+    if (this.isSecureKey(key) && this.secureStore) {
+      try {
+        await this.secureStore.deleteItemAsync(key);
+      } catch {}
+    }
+    try {
+      await this.asyncStorage?.removeItem(key);
+    } catch {}
+  }
+}

package/src/theme/ThemeContext.tsx

@@ -0,0 +1,159 @@
+import React, { createContext, useContext, useMemo, useState, useCallback } from 'react';
+
+/**
+ * Theme interface ported from squad-demo/src/theme/theme.tsx.
+ */
+export interface Theme {
+  screenBackground: string;
+  screenBackgroundTransparency: string;
+  bottomSheetHandleIndicator: string;
+  offWhiteTransparency?: string;
+  recordingButtons?: string;
+  emojiKeyboardHeader: string;
+  buttonColor: string;
+  buttonText: string;
+  primaryColor: string;
+  secondaryColor: string;
+  tertiaryColor: string;
+  isDarkMode: boolean;
+}
+
+export interface ColorScheme {
+  primaryTextColor: string;
+  disabledGrey: string;
+  primaryGreyColor: string;
+  secondaryGrey: string;
+  primaryWhiteColor: string;
+  secondaryTextColor: string;
+  transparentBGWhite: string;
+  transparentBGBlack: string;
+  errorColor: string;
+  backgroundWhite: string;
+  backgroundBlack: string;
+  primaryPurple: string;
+}
+
+export const Colors = {
+  blackBackground: '#1D1D1D',
+  squadCircle: '#FAFAFA',
+  transparent: 'rgba(0,0,0,0)',
+  black: '#0A0A0A',
+  white: '#ffffff',
+  gray1: '#151515',
+  gray2: '#212121',
+  gray3: '#353535',
+  gray4: '#444444',
+  gray5: '#3D3D3D',
+  gray6: '#8A8A8A',
+  gray7: '#DFE5EB',
+  gray8: '#DCDCDC',
+  gray9: '#111111',
+  gray10: '#8A8A8A',
+  gray11: '#D9D9D9',
+  gray12: '#0B0B0B',
+  purple1: '#6E82E7',
+  purple2: '#2E46C9',
+  purple3: '#566BD7',
+  orange1: '#FF955C',
+  orange2: '#E9785C',
+  green: '#11EC0F',
+  gold: '#D1C282',
+  apricot: '#FF955C',
+  red: '#FF4478',
+  blue: 'rgb(0,98,255)',
+  lightGray: '#F2F2F2',
+} as const;
+
+const baseThemeColors: ColorScheme = {
+  primaryTextColor: Colors.gray1,
+  disabledGrey: Colors.gray11,
+  primaryGreyColor: Colors.gray6,
+  secondaryGrey: Colors.gray5,
+  primaryWhiteColor: Colors.white,
+  secondaryTextColor: Colors.gray2,
+  transparentBGWhite: 'rgba(0,0,0, 0.05)',
+  transparentBGBlack: 'rgba(255,255,255, 0.05)',
+  errorColor: Colors.orange1,
+  backgroundWhite: '#F5F6F8',
+  backgroundBlack: '#000000',
+  primaryPurple: Colors.purple1,
+};
+
+export const defaultTheme: Theme = {
+  screenBackground: Colors.gray9,
+  screenBackgroundTransparency: 'rgba(17,17,17, 0.8)',
+  bottomSheetHandleIndicator: 'rgba(255, 255, 255, 0.14)',
+  emojiKeyboardHeader: '#5F5E5F',
+  buttonColor: Colors.purple1,
+  buttonText: Colors.black,
+  primaryColor: Colors.black,
+  secondaryColor: Colors.gray2,
+  tertiaryColor: Colors.purple1,
+  isDarkMode: true,
+};
+
+/**
+ * Build a theme from community colors, falling back to defaults.
+ */
+export function buildCommunityTheme(
+  primaryColor?: string,
+  secondaryColor?: string,
+): Theme {
+  return {
+    ...defaultTheme,
+    primaryColor: primaryColor ?? defaultTheme.primaryColor,
+    secondaryColor: secondaryColor ?? defaultTheme.secondaryColor,
+    buttonColor: primaryColor ?? defaultTheme.buttonColor,
+    tertiaryColor: secondaryColor ?? defaultTheme.tertiaryColor,
+  };
+}
+
+// --- Context ---
+
+interface ThemeContextValue {
+  theme: Theme;
+  colors: typeof Colors;
+  baseThemeColors: ColorScheme;
+  switchTheme: (theme: Theme) => void;
+}
+
+const ThemeCtx = createContext<ThemeContextValue>({
+  theme: defaultTheme,
+  colors: Colors,
+  baseThemeColors,
+  switchTheme: () => {},
+});
+
+export function useTheme(): ThemeContextValue {
+  return useContext(ThemeCtx);
+}
+
+interface ThemeProviderProps {
+  children: React.ReactNode;
+  communityColor?: string;
+  communitySecondaryColor?: string;
+}
+
+export function ThemeProvider({
+  children,
+  communityColor,
+  communitySecondaryColor,
+}: ThemeProviderProps) {
+  const initialTheme = useMemo(
+    () => buildCommunityTheme(communityColor, communitySecondaryColor),
+    [communityColor, communitySecondaryColor],
+  );
+
+  const [theme, setTheme] = useState<Theme>(initialTheme);
+
+  const switchTheme = useCallback((newTheme: Theme) => {
+    setTheme(newTheme);
+  }, []);
+
+  const value = useMemo(
+    () => ({ theme, colors: Colors, baseThemeColors, switchTheme }),
+    [theme, switchTheme],
+  );
+
+  return <ThemeCtx.Provider value={value}>{children}</ThemeCtx.Provider>;
+}

package/src/types/modules.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Type declarations for optional peer dependencies.
+ * These modules are dynamically imported and may not be installed in all environments.
+ */
+
+declare module 'expo-image-manipulator' {
+  export enum SaveFormat {
+    JPEG = 'jpeg',
+    PNG = 'png',
+    WEBP = 'webp',
+  }
+
+  export interface ImageResult {
+    uri: string;
+    width: number;
+    height: number;
+    base64?: string;
+  }
+
+  export interface Action {
+    resize?: { width?: number; height?: number };
+    rotate?: number;
+    flip?: { vertical?: boolean; horizontal?: boolean };
+    crop?: { originX: number; originY: number; width: number; height: number };
+  }
+
+  export interface SaveOptions {
+    compress?: number;
+    format?: SaveFormat;
+    base64?: boolean;
+  }
+
+  export function manipulateAsync(
+    uri: string,
+    actions: Action[],
+    saveOptions?: SaveOptions,
+  ): Promise<ImageResult>;
+}
+
+declare module 'expo-notifications' {
+  export interface PermissionResponse {
+    status: string;
+    granted: boolean;
+    expires: string;
+    canAskAgain: boolean;
+    ios?: Record<string, unknown>;
+  }
+
+  export interface ExpoPushToken {
+    type: string;
+    data: string;
+  }
+
+  export function getPermissionsAsync(): Promise<PermissionResponse>;
+  export function requestPermissionsAsync(): Promise<PermissionResponse>;
+  export function getExpoPushTokenAsync(options?: { projectId?: string }): Promise<ExpoPushToken>;
+  export function addNotificationResponseReceivedListener(
+    listener: (response: any) => void,
+  ): { remove: () => void };
+  export function addNotificationReceivedListener(
+    listener: (notification: any) => void,
+  ): { remove: () => void };
+}
+
+declare module 'expo-camera' {
+  export class Camera {
+    static requestCameraPermissionsAsync(): Promise<{ status: string; granted: boolean }>;
+    static getCameraPermissionsAsync(): Promise<{ status: string; granted: boolean }>;
+  }
+
+  export interface CameraProps {
+    type?: any;
+    onBarCodeScanned?: (data: { type: string; data: string }) => void;
+    style?: any;
+    children?: any;
+  }
+
+  export default class CameraComponent extends React.Component<CameraProps> {}
+}
+
+declare module 'expo-clipboard' {
+  export function setStringAsync(text: string): Promise<void>;
+  export function getStringAsync(): Promise<string>;
+  export function hasStringAsync(): Promise<boolean>;
+}
+
+declare module '@react-native-community/netinfo' {
+  export interface NetInfoState {
+    type: string;
+    isConnected: boolean | null;
+    isInternetReachable: boolean | null;
+    details: Record<string, unknown> | null;
+  }
+
+  export type NetInfoChangeHandler = (state: NetInfoState) => void;
+
+  interface NetInfoStatic {
+    addEventListener(listener: NetInfoChangeHandler): () => void;
+    fetch(): Promise<NetInfoState>;
+  }
+
+  const NetInfo: NetInfoStatic;
+  export default NetInfo;
+}
+
+declare module 'expo-secure-store' {
+  export function getItemAsync(key: string): Promise<string | null>;
+  export function setItemAsync(key: string, value: string): Promise<void>;
+  export function deleteItemAsync(key: string): Promise<void>;
+}
+
+declare module '@twilio/voice-react-native-sdk' {
+  export class Voice {
+    register(token: string): Promise<void>;
+    connect(token: string, options?: Record<string, unknown>): Promise<any>;
+    on(event: string, handler: (...args: any[]) => void): this;
+    off(event: string, handler: (...args: any[]) => void): this;
+  }
+}
+
+declare module 'react-native-date-picker' {
+  import type { ComponentType } from 'react';
+
+  interface DatePickerProps {
+    date: Date;
+    onDateChange: (date: Date) => void;
+    mode?: 'date' | 'time' | 'datetime';
+    open?: boolean;
+    onConfirm?: (date: Date) => void;
+    onCancel?: () => void;
+    [key: string]: any;
+  }
+
+  const DatePicker: ComponentType<DatePickerProps>;
+  export default DatePicker;
+}
+
+declare module 'react-native-sse' {
+  interface EventSourceOptions {
+    headers?: Record<string, string>;
+    method?: string;
+    body?: string;
+    pollingInterval?: number;
+  }
+
+  type EventSourceListener = (event: { type: string; data?: string; lastEventId?: string }) => void;
+
+  class EventSource {
+    constructor(url: string, options?: EventSourceOptions);
+    addEventListener(type: string, listener: EventSourceListener): void;
+    removeEventListener(type: string, listener: EventSourceListener): void;
+    close(): void;
+    readonly readyState: number;
+    static readonly CONNECTING: number;
+    static readonly OPEN: number;
+    static readonly CLOSED: number;
+  }
+
+  export default EventSource;
+}
+
+// Augment Blob to include arrayBuffer (available in newer environments)
+interface Blob {
+  arrayBuffer(): Promise<ArrayBuffer>;
+}