@squad-sports/react-native 1.3.1

package/src/squad-line/useSquadLine.ts

@@ -0,0 +1,80 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useApiClient } from '../SquadProvider';
+import { SquadLineClient, type CallState, type CallInfo } from './SquadLineClient';
+
+/**
+ * React hook for Squad Line voice calling.
+ * Wraps SquadLineClient for easy consumption in components.
+ */
+export function useSquadLine() {
+  const apiClient = useApiClient();
+  const [callState, setCallState] = useState<CallState>('idle');
+  const [currentCall, setCurrentCall] = useState<CallInfo | null>(null);
+  const [isMuted, setIsMuted] = useState(false);
+  const [isSpeakerOn, setIsSpeakerOn] = useState(false);
+  const [incomingCall, setIncomingCall] = useState<CallInfo | null>(null);
+
+  const client = SquadLineClient.getInstance(apiClient);
+
+  useEffect(() => {
+    const onCallStateChanged = (state: CallState) => setCallState(state);
+    const onMuteChanged = (muted: boolean) => setIsMuted(muted);
+    const onSpeakerChanged = (speaker: boolean) => setIsSpeakerOn(speaker);
+    const onIncomingCall = (info: CallInfo) => setIncomingCall(info);
+    const onConnected = (info: CallInfo) => {
+      setCurrentCall(info);
+      setIncomingCall(null);
+    };
+    const onDisconnected = () => {
+      setCurrentCall(null);
+      setIncomingCall(null);
+    };
+
+    client.on('callStateChanged', onCallStateChanged);
+    client.on('muteChanged', onMuteChanged);
+    client.on('speakerChanged', onSpeakerChanged);
+    client.on('incomingCall', onIncomingCall);
+    client.on('connected', onConnected);
+    client.on('disconnected', onDisconnected);
+
+    return () => {
+      client.off('callStateChanged', onCallStateChanged);
+      client.off('muteChanged', onMuteChanged);
+      client.off('speakerChanged', onSpeakerChanged);
+      client.off('incomingCall', onIncomingCall);
+      client.off('connected', onConnected);
+      client.off('disconnected', onDisconnected);
+    };
+  }, [client]);
+
+  const makeCall = useCallback(
+    (connectionId: string, title: string, calleeIdentity?: string) =>
+      client.makeCall(connectionId, title, calleeIdentity),
+    [client],
+  );
+
+  const endCall = useCallback(() => client.endCall(), [client]);
+  const acceptCall = useCallback(() => client.acceptCall(), [client]);
+  const rejectCall = useCallback(() => client.rejectCall(), [client]);
+  const toggleMute = useCallback(() => client.toggleMute(), [client]);
+  const toggleSpeaker = useCallback(() => client.toggleSpeaker(), [client]);
+  const sendReaction = useCallback(
+    (emoji: string, imageUrl?: string) => client.sendReaction(emoji, imageUrl),
+    [client],
+  );
+
+  return {
+    callState,
+    currentCall,
+    incomingCall,
+    isMuted,
+    isSpeakerOn,
+    makeCall,
+    endCall,
+    acceptCall,
+    rejectCall,
+    toggleMute,
+    toggleSpeaker,
+    sendReaction,
+  };
+}

package/src/state/audio.ts

@@ -0,0 +1,38 @@
+/**
+ * Audio playback/recording atoms.
+ * Ported from squad-demo/src/atoms/audio.ts.
+ */
+import { atom, atomFamily } from 'recoil';
+
+export type AudioStatus = {
+  isPlaying: boolean;
+  isLoaded: boolean;
+  durationMs: number;
+  positionMs: number;
+};
+
+export const playerForRecorder = atomFamily<unknown | null, string>({
+  key: 'squad-sdk:audio:recorder:player',
+  default: null,
+});
+
+export const statusForAudioDevice = atomFamily<AudioStatus | null, string | null>({
+  key: 'squad-sdk:audio:device:status',
+  default: null,
+});
+
+export const positionForAudioPlayer = atomFamily<number, string | null>({
+  key: 'squad-sdk:audio:device:progress',
+  default: 0,
+});
+
+// Global audio state
+export const isAudioRecording = atom<boolean>({
+  key: 'squad-sdk:audio:isRecording',
+  default: false,
+});
+
+export const activeAudioPlayerId = atom<string | null>({
+  key: 'squad-sdk:audio:activePlayerId',
+  default: null,
+});

package/src/state/client.ts

@@ -0,0 +1,26 @@
+/**
+ * API client selectors.
+ * Ported from squad-demo/src/atoms/client.ts.
+ */
+import { selector } from 'recoil';
+import { reActiveAccessToken } from './session';
+import { configApp } from './features';
+
+// Preferred API environment
+export const rePreferredApiEnvironment = selector<string>({
+  key: 'squad-sdk:client:preferredApiEnvironment',
+  get: ({ get }) => {
+    const config = get(configApp);
+    return config.apiEnvironments[0]?.squadApiBaseUrl ?? 'https://api-release.withyoursquad.com';
+  },
+});
+
+// Client selector that creates API client from current token + environment
+export const reAnyClient = selector<{ baseUrl: string; accessToken: string | null }>({
+  key: 'squad-sdk:client:any',
+  get: ({ get }) => {
+    const accessToken = get(reActiveAccessToken);
+    const baseUrl = get(rePreferredApiEnvironment);
+    return { baseUrl, accessToken };
+  },
+});

package/src/state/communities.ts

@@ -0,0 +1,45 @@
+/**
+ * Community atoms.
+ * Ported from squad-demo/src/atoms/communities.ts + community-reactions.ts + community-selection.ts + onboarding-community.ts.
+ */
+import { atom, selector, selectorFamily } from 'recoil';
+import type { Community, Communities } from '@squad-sports/core';
+
+export const reAllCommunities = atom<Community[]>({
+  key: 'squad-sdk:communities:all',
+  default: [],
+});
+
+export const reAllCommunitiesByGroups = atom<unknown | undefined>({
+  key: 'squad-sdk:communities:byGroup',
+  default: undefined,
+});
+
+export const reCommunityById = selectorFamily<Community | null, string>({
+  key: 'squad-sdk:communities:byId',
+  get: (id) => ({ get }) => {
+    return get(reAllCommunities).find(c => c.id === id) ?? null;
+  },
+});
+
+export const reCommunitiesRefresh = atom<number>({
+  key: 'squad-sdk:communities:refresh',
+  default: 0,
+});
+
+export const reUserCommunity = atom<Community | null>({
+  key: 'squad-sdk:communities:userCommunity',
+  default: null,
+});
+
+// Community reactions
+export const reCommunityReactions = atom<Map<string, unknown[]>>({
+  key: 'squad-sdk:communities:reactions',
+  default: new Map(),
+});
+
+// Onboarding community selection
+export const reOnboardingSelectedCommunity = atom<Community | null>({
+  key: 'squad-sdk:onboarding:selectedCommunity',
+  default: null,
+});

package/src/state/contacts.ts

@@ -0,0 +1,28 @@
+/**
+ * Device contacts atoms.
+ * Ported from squad-demo/src/atoms/contacts.ts.
+ */
+import { atom } from 'recoil';
+
+export interface DeviceContact {
+  id: string;
+  name: string;
+  phoneNumbers: string[];
+  emails: string[];
+  imageUri?: string;
+}
+
+export const deviceContacts = atom<DeviceContact[]>({
+  key: 'squad-sdk:contacts:device',
+  default: [],
+});
+
+export const contactsLoaded = atom<boolean>({
+  key: 'squad-sdk:contacts:loaded',
+  default: false,
+});
+
+export const contactsOnSquad = atom<string[]>({
+  key: 'squad-sdk:contacts:onSquad',
+  default: [],
+});

package/src/state/device-info.ts

@@ -0,0 +1,22 @@
+/**
+ * Device info atoms.
+ * Ported from squad-demo/src/atoms/device-info.ts.
+ */
+import { atom } from 'recoil';
+
+export const reDeviceInfo = atom<{
+  platform: string;
+  osVersion: string;
+  appVersion: string;
+  deviceModel: string;
+  pushToken: string | null;
+}>({
+  key: 'squad-sdk:device:info',
+  default: {
+    platform: '',
+    osVersion: '',
+    appVersion: '',
+    deviceModel: '',
+    pushToken: null,
+  },
+});

package/src/state/events.ts

@@ -0,0 +1,16 @@
+/**
+ * Event atoms.
+ * Ported from squad-demo/src/atoms/events.ts.
+ */
+import { atom } from 'recoil';
+import type { Events } from '@squad-sports/core';
+
+export const reActiveEvents = atom<Events | null>({
+  key: 'squad-sdk:events:active',
+  default: null,
+});
+
+export const reEventsRefresh = atom<number>({
+  key: 'squad-sdk:events:refresh',
+  default: 0,
+});

package/src/state/features.ts

@@ -0,0 +1,57 @@
+/**
+ * Feature flag and config atoms.
+ * Ported from squad-demo/src/atoms/features.ts + config-app.ts + config-squad.ts + developer-access.ts + app-store.ts.
+ */
+import { atom, selector } from 'recoil';
+
+// Feature flags
+export const featureFlags = atom<Record<string, boolean>>({
+  key: 'squad-sdk:features:flags',
+  default: {
+    squadLine: true,
+    freestyle: true,
+    messaging: true,
+    polls: true,
+    events: true,
+    wallet: true,
+  },
+});
+
+// App config
+export interface ApiEnvironment {
+  squadApiBaseUrl: string;
+  name: string;
+}
+
+export const configApp = atom<{
+  apiEnvironments: ApiEnvironment[];
+}>({
+  key: 'squad-sdk:config:app',
+  default: {
+    apiEnvironments: [{ squadApiBaseUrl: 'https://api-release.withyoursquad.com', name: 'production' }],
+  },
+});
+
+// Developer access
+export const developerAccessEnabled = atom<boolean>({
+  key: 'squad-sdk:developer:access',
+  default: false,
+});
+
+// App store version
+export const reLatestAppStoreVersion = atom<string | null>({
+  key: 'squad-sdk:appStore:latestVersion',
+  default: null,
+});
+
+// Session count
+export const sessionCount = atom<number>({
+  key: 'squad-sdk:session:count',
+  default: 0,
+});
+
+// Prerelease
+export const rePrereleaseEnabled = atom<boolean>({
+  key: 'squad-sdk:features:prerelease',
+  default: false,
+});

package/src/state/index.ts

@@ -0,0 +1,121 @@
+/**
+ * State management — all Recoil atoms.
+ * Complete port from squad-demo/src/atoms/.
+ */
+
+// CRDT
+export { compileCrdt, compileCrdtSingle } from './sync/crdt';
+export type { CrdtArray, CrdtArrayItem, CrdtArrayOperation } from './sync/crdt';
+
+// Dependable
+export { DependableAtom, DependableSelector, DependableAtomFamily } from './sync/dependable';
+
+// Refresh
+export { reLastRefreshed, reRefresh, reRefreshing } from './sync/refresh';
+
+// Offline
+export { isOnlineAtom, pendingActionsAtom, offlineCacheAtom, shouldUseOfflineDataSelector } from './sync/offline-support';
+export type { QueuedOfflineAction, OfflineActionType } from './sync/offline-support';
+
+// Session / Auth
+export {
+  reActivePhoneNumber, reActiveEmail, reActiveCode,
+  reActiveAccessToken, reActiveUserId, reUserRefresh,
+  reAuthHydrated, rePendingNavigation, reAttemptedVerifications,
+  pruneExpiredAttemptedVerifications, ATTEMPTED_VERIFICATION_WINDOW_MS,
+} from './session';
+export type { AttemptedVerification } from './session';
+
+// Permissions
+export {
+  microphonePermissions, contactsPermissions, cameraPermissions,
+  imagesPermissions, notificationsPermissions,
+} from './permissions';
+export type { PermissionStatus } from './permissions';
+
+// Modal queue
+export { default as modalQueue, ModalQueueItem, ModalType, topModalAtom } from './modal-queue';
+export { DialogKey, ToastKey, BottomSheetKey } from './modal-keys';
+export type { ModalKey, DialogProps, ToastProps, BottomSheetProps } from './modal-keys';
+export type { ModalQueueOptions } from './modal-queue';
+
+// Communities
+export {
+  reAllCommunities, reAllCommunitiesByGroups, reCommunityById,
+  reCommunitiesRefresh, reUserCommunity, reCommunityReactions,
+  reOnboardingSelectedCommunity,
+} from './communities';
+
+// Navigation
+export { currentStack, navigationState, reOnboardingStep, rePostOnboardingLoadingActive } from './navigation';
+export type { ScreenName, OnboardingStep } from './navigation';
+
+// Audio
+export {
+  playerForRecorder, statusForAudioDevice, positionForAudioPlayer,
+  isAudioRecording, activeAudioPlayerId,
+} from './audio';
+export type { AudioStatus } from './audio';
+
+// UI
+export {
+  loadingOverlayVisible, loadingOverlayText,
+  aKeyboardOpen, networkBannerVisible, networkStateAtom,
+} from './ui';
+
+// Features / Config
+export {
+  featureFlags, configApp, developerAccessEnabled,
+  reLatestAppStoreVersion, sessionCount, rePrereleaseEnabled,
+} from './features';
+export type { ApiEnvironment } from './features';
+
+// Contacts
+export { deviceContacts, contactsLoaded, contactsOnSquad } from './contacts';
+export type { DeviceContact } from './contacts';
+
+// Wallet
+export { reWallet, reCoupons, reBrands, reWalletRefresh } from './wallet';
+
+// SOTD
+export { reSquaddieOfTheDay, reSOTDAnimationShown, reSOTDIntroShown } from './squaddie-of-the-day';
+
+// User
+export {
+  reUserCache, reLoggedInUserLoaded, userUpdates,
+  reUser, reUserTag, reSophiaUser,
+} from './user';
+
+// Client
+export { rePreferredApiEnvironment, reAnyClient } from './client';
+
+// Sync — Squad
+export { reInitialConnections, reConnectionUpdates, reConnectionWithUser } from './sync/squad-v2';
+
+// Sync — Feed
+export {
+  reInitialFeed, feedUpdates, feedExpiryTickAtom,
+  freestyleReactionUpdates, reFreestylePrompts, reFreestyleCreating,
+} from './sync/feed-v2';
+
+// Sync — Messages
+export {
+  reInitialConversationState, reConnectionMessages, reMessageReaction,
+  reMessageSendStatus, reMessagePrompts,
+} from './sync/messages';
+export type { FailedMessageInfo } from './sync/messages';
+
+// Sync — Polls
+export {
+  reInitialPollFeed, rePollUpdates, rePollResponseUpdates,
+  rePollResponseReactionsUpdates, rePollNudgesUpdates,
+} from './sync/polls';
+
+// Events
+export { reActiveEvents, reEventsRefresh } from './events';
+
+// Invitations
+export { reInvitationCode, reInvitationCodeLoaded } from './invitations';
+
+// Device info
+export { reDeviceInfo } from './device-info';

package/src/state/invitations.ts

@@ -0,0 +1,16 @@
+/**
+ * Invitation atoms.
+ * Ported from squad-demo/src/atoms/invitations.ts + live/invitation-code.ts.
+ */
+import { atom } from 'recoil';
+import type { InvitationCode } from '@squad-sports/core';
+
+export const reInvitationCode = atom<InvitationCode | null>({
+  key: 'squad-sdk:invitations:code',
+  default: null,
+});
+
+export const reInvitationCodeLoaded = atom<boolean>({
+  key: 'squad-sdk:invitations:loaded',
+  default: false,
+});

package/src/state/modal-keys.ts

@@ -0,0 +1,63 @@
+/**
+ * Modal key definitions for dialogs, toasts, and bottom sheets.
+ * Ported from squad-demo/src/atoms/modal-keys.ts.
+ */
+
+export enum DialogKey {
+  blockConfirmation = 'block-confirmation',
+  deleteConfirmation = 'delete-confirmation',
+  flagConfirmation = 'flag-confirmation',
+  micPermissions = 'mic-permissions',
+  cameraPermissions = 'camera-permissions',
+  imagesPermissions = 'images-permissions',
+  notificationPermissions = 'notification-permissions',
+  unblockConfirmation = 'unblock-confirmation',
+  SOTDIntroduction = 'sotd-introduction',
+  SOTDBlocked = 'sotd-blocked',
+  progressCongratulation = 'progress-congratulation',
+  collectEmail = 'collect-email',
+  noConnection = 'no-connection',
+  removeFromSquad = 'remove-from-squad',
+}
+
+export enum ToastKey {
+  success = 'success',
+  error = 'error',
+  info = 'info',
+  busy = 'busy',
+  networkBanner = 'network-banner',
+}
+
+export enum BottomSheetKey {
+  squadLineInvitation = 'squad-line-invitation',
+  help = 'help',
+  quickTip = 'quick-tip',
+  sophiaIntroduction = 'sophia-introduction',
+  SOTD = 'SOTD',
+  upgradeHardLock = 'upgrade-hard-lock',
+  upgradeSoftLock = 'upgrade-soft-lock',
+  addFreestyleReaction = 'add-freestyle-reaction',
+  selectCommunity = 'select-community',
+  removeOrBlock = 'remove-or-block',
+  addPollReaction = 'add-poll-reaction',
+  filterPollSummation = 'filter-poll-summation',
+  pollReactions = 'poll-reactions',
+  inviteFeatureIntroduction = 'invite-feature-introduction',
+  sotdSelectingFriend = 'SOTD-selecting-friend',
+  errorInfo = 'error-info',
+  inviteContact = 'invite-contact',
+  inviteErrorSquadMaxed = 'invite-error-squad-maxed',
+  inviteErrorOtherSquadMaxed = 'invite-error-other-squad-maxed',
+  requestItemMenu = 'request-item-menu',
+  sotdIntroduction = 'sotd-introduction-selecting',
+  selectTeam = 'select-team',
+  viewAllAttendees = 'events-view-all-attendees',
+  redeemWalletCode = 'redeem-wallet-code',
+  couponShareSheet = 'coupon-share-sheet',
+  couponInternalShareSheet = 'coupon-internal-share-sheet',
+}
+
+export type DialogProps = Record<string, any>;
+export type ToastProps = Record<string, any>;
+export type BottomSheetProps = Record<string, any> & { onDismiss?: () => void };
+export type ModalKey = DialogKey | ToastKey | BottomSheetKey;

package/src/state/modal-queue.ts

@@ -0,0 +1,104 @@
+/**
+ * Modal queue system for managing dialog/toast/bottom sheet display.
+ * Ported from squad-demo/src/atoms/modal-queue.ts.
+ */
+import EventEmitter from 'eventemitter3';
+import { atomFamily } from 'recoil';
+import { type ModalKey, type DialogProps, DialogKey, ToastKey, BottomSheetKey } from './modal-keys';
+
+export const enum ModalType {
+  Dialog = 'dialog',
+  Toast = 'toast',
+  BottomSheet = 'bottomSheet',
+}
+
+export type ModalQueueOptions = Partial<{
+  animationType: 'none' | 'slide' | 'fade';
+  dismissable: boolean;
+}>;
+
+export class ModalQueueItem {
+  key: ModalKey;
+  keyType: ModalType;
+  options: ModalQueueOptions;
+  private props?: DialogProps;
+
+  constructor(key: ModalKey, props?: DialogProps, options: ModalQueueOptions = {}) {
+    this.key = key;
+    this.options = options;
+    this.props = props;
+    this.keyType = ModalQueueItem.getTypeForKey(key);
+  }
+
+  get isDismissable(): boolean {
+    if (typeof this.options.dismissable === 'boolean') return this.options.dismissable;
+    return this.keyType === ModalType.BottomSheet;
+  }
+
+  getProps<T extends DialogProps>(): T {
+    return (this.props ?? {}) as T;
+  }
+
+  static getTypeForKey(key: ModalKey): ModalType {
+    if (Object.values(DialogKey).includes(key as DialogKey)) return ModalType.Dialog;
+    if (Object.values(ToastKey).includes(key as ToastKey)) return ModalType.Toast;
+    return ModalType.BottomSheet;
+  }
+}
+
+class ModalQueue {
+  private queue: ModalQueueItem[] = [];
+  private emitter = new EventEmitter();
+
+  push(key: ModalKey, props?: DialogProps, options?: ModalQueueOptions): void {
+    const item = new ModalQueueItem(key, props, options);
+    this.queue.push(item);
+    this.emitter.emit('change', this.queue);
+  }
+
+  pop(): ModalQueueItem | undefined {
+    const item = this.queue.shift();
+    this.emitter.emit('change', this.queue);
+    return item;
+  }
+
+  peek(): ModalQueueItem | undefined {
+    return this.queue[0];
+  }
+
+  dismiss(key?: ModalKey): void {
+    if (key) {
+      this.queue = this.queue.filter(item => item.key !== key);
+    } else {
+      this.queue.shift();
+    }
+    this.emitter.emit('change', this.queue);
+  }
+
+  clear(): void {
+    this.queue = [];
+    this.emitter.emit('change', this.queue);
+  }
+
+  get length(): number {
+    return this.queue.length;
+  }
+
+  get isEmpty(): boolean {
+    return this.queue.length === 0;
+  }
+
+  onChange(callback: (queue: ModalQueueItem[]) => void): () => void {
+    this.emitter.on('change', callback);
+    return () => this.emitter.off('change', callback);
+  }
+}
+
+const modalQueue = new ModalQueue();
+export default modalQueue;
+
+// Recoil atom for top modal (used by renderers)
+export const topModalAtom = atomFamily<ModalQueueItem | null, string>({
+  key: 'squad-sdk:modal:top',
+  default: null,
+});

package/src/state/navigation.ts

@@ -0,0 +1,34 @@
+/**
+ * Navigation atoms.
+ * Ported from squad-demo/src/atoms/navigation.ts + onboarding.ts + post-onboarding.ts.
+ */
+import { atom } from 'recoil';
+
+export type ScreenName = string;
+
+export const currentStack = atom<ScreenName[]>({
+  key: 'squad-sdk:navigation:currentStack',
+  default: [],
+});
+
+export const navigationState = atom<'auth' | 'onboarding' | 'main'>({
+  key: 'squad-sdk:navigation:state',
+  default: 'auth',
+});
+
+// Onboarding step tracking
+export type OnboardingStep =
+  | 'welcome'
+  | 'teamSelect'
+  | 'accountSetup'
+  | 'complete';
+
+export const reOnboardingStep = atom<OnboardingStep>({
+  key: 'squad-sdk:onboarding:step',
+  default: 'welcome',
+});
+
+export const rePostOnboardingLoadingActive = atom<boolean>({
+  key: 'squad-sdk:onboarding:postLoadingActive',
+  default: false,
+});