@squad-sports/react-native 1.3.1

package/src/state/permissions.ts

@@ -0,0 +1,43 @@
+/**
+ * Device permissions atoms.
+ * Ported from squad-demo/src/atoms/permissions.ts.
+ */
+import { atom, DefaultValue, selector } from 'recoil';
+
+export type PermissionStatus = 'granted' | 'denied' | 'undetermined' | 'limited';
+
+type AllPermissionsState = {
+  microphone: PermissionStatus | null;
+  contacts: PermissionStatus | null;
+  camera: PermissionStatus | null;
+  images: PermissionStatus | null;
+  notifications: PermissionStatus | null;
+};
+
+const permissionsAtom = atom<AllPermissionsState>({
+  key: 'squad-sdk:permissions',
+  default: {
+    microphone: null,
+    contacts: null,
+    camera: null,
+    images: null,
+    notifications: null,
+  },
+});
+
+function makePermissionSelector(field: keyof AllPermissionsState) {
+  return selector<PermissionStatus | null>({
+    key: `squad-sdk:permissions:${field}`,
+    get: ({ get }) => get(permissionsAtom)[field],
+    set: ({ get, set }, newValue) => {
+      if (newValue instanceof DefaultValue) return;
+      set(permissionsAtom, { ...get(permissionsAtom), [field]: newValue });
+    },
+  });
+}
+
+export const microphonePermissions = makePermissionSelector('microphone');
+export const contactsPermissions = makePermissionSelector('contacts');
+export const cameraPermissions = makePermissionSelector('camera');
+export const imagesPermissions = makePermissionSelector('images');
+export const notificationsPermissions = makePermissionSelector('notifications');

package/src/state/session.ts

@@ -0,0 +1,223 @@
+/**
+ * Auth/Session atoms.
+ * Ported from squad-demo/src/atoms/session.ts.
+ *
+ * Uses SecureStorageAdapter for all auth key persistence so that
+ * sensitive values (tokens, user IDs, email, phone) are stored in
+ * encrypted storage (expo-secure-store) rather than plain AsyncStorage.
+ */
+import { atom, type AtomEffect } from 'recoil';
+import { SecureStorageAdapter } from '../storage/SecureStorage';
+
+// --- Shared secure storage instance for Recoil effects ---
+const secureStorage = new SecureStorageAdapter();
+
+// --- Storage hydration tracking ---
+
+const storageHydrationComplete = new Map<string, boolean>();
+const storageLoadingPromises = new Map<string, Promise<string | null>>();
+const CRITICAL_STORAGE_KEYS = ['SQUAD_SDK_AUTH_TOKEN', 'SQUAD_SDK_AUTH_USER_ID'];
+
+function markStorageKeyLoaded(key: string) {
+  storageHydrationComplete.set(key, true);
+}
+
+/**
+ * Secure storage persistence effect.
+ * Uses SecureStorageAdapter which routes sensitive keys through
+ * expo-secure-store and non-sensitive keys through AsyncStorage.
+ */
+function secureStorageEffect(storageKey: string): AtomEffect<string | null> {
+  return ({ setSelf, onSet, trigger }) => {
+    let isInitialLoad = true;
+
+    if (trigger === 'get') {
+      // Dedup concurrent loads
+      if (storageLoadingPromises.has(storageKey)) {
+        storageLoadingPromises.get(storageKey)!.then(val => {
+          setSelf(val);
+          isInitialLoad = false;
+          markStorageKeyLoaded(storageKey);
+        });
+        return;
+      }
+
+      const loadingPromise = secureStorage.getItem(storageKey).catch(() => null);
+
+      storageLoadingPromises.set(storageKey, loadingPromise);
+
+      loadingPromise.then(val => {
+        setSelf(val);
+        storageLoadingPromises.delete(storageKey);
+        markStorageKeyLoaded(storageKey);
+        isInitialLoad = false;
+      });
+    }
+
+    onSet(async newValue => {
+      try {
+        if (!newValue && !isInitialLoad) {
+          await secureStorage.removeItem(storageKey);
+        } else if (newValue) {
+          await secureStorage.setItem(storageKey, newValue);
+        }
+      } catch {}
+      setSelf(newValue);
+    });
+  };
+}
+
+function secureStorageObjectEffect<T>(storageKey: string): AtomEffect<T> {
+  return ({ setSelf, onSet, trigger }) => {
+    let isInitialLoad = true;
+
+    if (trigger === 'get') {
+      (async () => {
+        try {
+          const val = await secureStorage.getItem(storageKey);
+          if (val) {
+            const parsed = JSON.parse(val);
+            if (parsed && typeof parsed === 'object') {
+              setSelf(parsed);
+            }
+          }
+        } catch {}
+        isInitialLoad = false;
+      })();
+    }
+
+    onSet(async newValue => {
+      if (!isInitialLoad && newValue && typeof newValue === 'object') {
+        try {
+          await secureStorage.setItem(storageKey, JSON.stringify(newValue));
+        } catch {}
+      }
+      setSelf(newValue);
+    });
+  };
+}
+
+function secureStorageArrayEffect<T>(storageKey: string): AtomEffect<T[]> {
+  return ({ setSelf, onSet, trigger }) => {
+    let isInitialLoad = true;
+
+    if (trigger === 'get') {
+      (async () => {
+        try {
+          const val = await secureStorage.getItem(storageKey);
+          if (val) setSelf(JSON.parse(val));
+        } catch {}
+        isInitialLoad = false;
+      })();
+    }
+
+    onSet(async newValue => {
+      try {
+        if ((!newValue || (newValue as T[]).length === 0) && !isInitialLoad) {
+          await secureStorage.removeItem(storageKey);
+        } else if (newValue) {
+          await secureStorage.setItem(storageKey, JSON.stringify(newValue));
+        }
+      } catch {}
+      setSelf(newValue);
+    });
+  };
+}
+
+// --- Session atoms ---
+
+export const reActivePhoneNumber = atom<string | null>({
+  key: 'squad-sdk:auth:phone',
+  default: null,
+  effects: [secureStorageEffect('SQUAD_SDK_AUTH_PHONE')],
+});
+
+export const reActiveEmail = atom<string | null>({
+  key: 'squad-sdk:auth:email',
+  default: null,
+  effects: [secureStorageEffect('SQUAD_SDK_AUTH_EMAIL')],
+});
+
+export const reActiveCode = atom<string | null>({
+  key: 'squad-sdk:auth:code',
+  default: null,
+});
+
+export const reActiveAccessToken = atom<string | null>({
+  key: 'squad-sdk:session:activeAccessToken',
+  default: null,
+  effects: [secureStorageEffect('SQUAD_SDK_AUTH_TOKEN')],
+});
+
+export const reActiveUserId = atom<string | null>({
+  key: 'squad-sdk:session:activeUserId',
+  default: null,
+  effects: [secureStorageEffect('SQUAD_SDK_AUTH_USER_ID')],
+});
+
+export const reUserRefresh = atom<number>({
+  key: 'squad-sdk:session:userRefresh',
+  default: 0,
+});
+
+export const reAuthHydrated = atom<boolean>({
+  key: 'squad-sdk:auth:hydrated',
+  default: false,
+  effects: [
+    ({ setSelf, trigger }) => {
+      if (trigger === 'get') {
+        const check = async () => {
+          await new Promise<void>(r => setTimeout(() => r(), 50));
+          const maxWait = 2000;
+          const start = Date.now();
+          while (Date.now() - start < maxWait) {
+            if (CRITICAL_STORAGE_KEYS.every(k => storageHydrationComplete.get(k))) {
+              setSelf(true);
+              return;
+            }
+            await new Promise<void>(r => setTimeout(() => r(), 50));
+          }
+          setSelf(true); // Timeout — proceed anyway
+        };
+        check();
+      }
+    },
+  ],
+});
+
+export const reActiveCommunityId = atom<string | null>({
+  key: 'squad-sdk:session:activeCommunityId',
+  default: null,
+  effects: [secureStorageEffect('SQUAD_SDK_AUTH_COMMUNITY_ID')],
+});
+
+export const reActivePartnerId = atom<string | null>({
+  key: 'squad-sdk:session:activePartnerId',
+  default: null,
+  effects: [secureStorageEffect('SQUAD_SDK_AUTH_PARTNER_ID')],
+});
+
+export const rePendingNavigation = atom<{
+  hasPendingInviter: boolean;
+  inviterId?: string;
+}>({
+  key: 'squad-sdk:session:pendingNavigation',
+  default: { hasPendingInviter: false },
+  effects: [secureStorageObjectEffect('SQUAD_SDK_PENDING_NAVIGATION')],
+});
+
+export type AttemptedVerification = { key: string; timestamp: number };
+export const ATTEMPTED_VERIFICATION_WINDOW_MS = 10 * 60 * 1000;
+
+export const reAttemptedVerifications = atom<AttemptedVerification[]>({
+  key: 'squad-sdk:auth:attempted-verifications',
+  default: [],
+  effects: [secureStorageArrayEffect('SQUAD_SDK_ATTEMPTED_VERIFICATIONS')],
+});
+
+export function pruneExpiredAttemptedVerifications(
+  entries: AttemptedVerification[],
+  now: number = Date.now(),
+): AttemptedVerification[] {
+  return entries.filter(e => now - e.timestamp < ATTEMPTED_VERIFICATION_WINDOW_MS);
+}

package/src/state/squaddie-of-the-day.ts

@@ -0,0 +1,21 @@
+/**
+ * Squaddie of the Day atoms.
+ * Ported from squad-demo/src/atoms/squaddie-of-the-day.ts + sotd-animation.ts.
+ */
+import { atom } from 'recoil';
+import type { SquaddieOfTheDay } from '@squad-sports/core';
+
+export const reSquaddieOfTheDay = atom<SquaddieOfTheDay | null>({
+  key: 'squad-sdk:sotd:data',
+  default: null,
+});
+
+export const reSOTDAnimationShown = atom<boolean>({
+  key: 'squad-sdk:sotd:animationShown',
+  default: false,
+});
+
+export const reSOTDIntroShown = atom<boolean>({
+  key: 'squad-sdk:sotd:introShown',
+  default: false,
+});

package/src/state/sync/crdt.ts

@@ -0,0 +1,70 @@
+/**
+ * CRDT (Conflict-free Replicated Data Type) implementation.
+ * Ported from squad-demo/src/atoms/sync/crdt.ts.
+ *
+ * Merges initial server state with local real-time updates,
+ * supporting insert, update, and delete operations.
+ */
+
+export type CrdtArrayOperation = 'insert' | 'update' | 'delete';
+
+export type CrdtArrayItem<ValueType> = {
+  operation: CrdtArrayOperation;
+  value: ValueType;
+};
+
+export type CrdtArray<KeyType, ValueType> = Map<KeyType, CrdtArrayItem<ValueType>>;
+
+/**
+ * Compile a CRDT array by merging initial server data with local updates.
+ * - 'update' operations replace the initial item
+ * - 'delete' operations remove the item
+ * - 'insert' operations add new items not in the initial set
+ */
+export function compileCrdt<KeyType, ValueType>(
+  initial: Array<ValueType>,
+  updates: CrdtArray<KeyType, ValueType>,
+  keyFrom: (value: ValueType) => KeyType,
+): Array<ValueType> {
+  const existing = new Map<KeyType, boolean>();
+
+  return [
+    ...initial
+      .map(item => {
+        const key = keyFrom(item);
+        const update = updates.get(key);
+        existing.set(key, true);
+
+        if (update?.operation === 'update') {
+          return update.value;
+        }
+        return item;
+      })
+      .filter(item => {
+        const key = keyFrom(item);
+        const update = updates.get(key);
+        existing.set(key, true);
+        return update?.operation !== 'delete';
+      }),
+    ...Array.from(updates.entries())
+      .filter(([key, { operation }]) => !existing.get(key) && operation !== 'delete')
+      .map(([_, { value }]) => value),
+  ];
+}
+
+/**
+ * Compile a single CRDT value (for individual items, not arrays).
+ */
+export function compileCrdtSingle<ValueType>(
+  initial: ValueType,
+  update: CrdtArrayItem<ValueType> | null,
+): ValueType | undefined {
+  if (!update) return initial;
+
+  switch (update.operation) {
+    case 'update': return update.value;
+    case 'delete': return undefined;
+    case 'insert': return initial;
+    default: return initial;
+  }
+}

package/src/state/sync/dependable.ts

@@ -0,0 +1,213 @@
+/**
+ * DependableAtom — wrapper for Recoil atoms that provides subscribable
+ * change notifications outside of Recoil's update tree.
+ *
+ * Ported from squad-demo/src/atoms/sync/dependable.ts.
+ *
+ * Used sparingly for top-level state (API calls) that needs to be
+ * refreshable with propagated changes.
+ */
+
+import {
+  atom,
+  AtomEffect,
+  atomFamily,
+  DefaultValue,
+  type Loadable,
+  type ReadWriteSelectorOptions,
+  type RecoilState,
+  type RecoilValue,
+  selector,
+  selectorFamily,
+  type SerializableParam,
+  type WrappedValue,
+} from 'recoil';
+import EventEmitter from 'eventemitter3';
+
+type RecoilSetSelfFn<T> = (
+  param:
+    | T
+    | DefaultValue
+    | Promise<T | DefaultValue>
+    | WrappedValue<T>
+    | ((param: T | DefaultValue) => T | DefaultValue | WrappedValue<T>),
+) => void;
+
+export type AtomEffectParams<T> = {
+  setSelf: RecoilSetSelfFn<T>;
+  getPromise: <S>(recoilValue: RecoilValue<S>) => Promise<S>;
+  getLoadable: <S>(recoilValue: RecoilValue<S>) => Loadable<S>;
+  onSet: (param: (newValue: T, oldValue: T | DefaultValue, isReset: boolean) => void) => void;
+};
+
+type DependableAtomEffect<T, ReturnType> = (
+  param: {
+    subscribeToLoadable: <S>(
+      callback: ((value: T) => Loadable<void>) | ((value: T) => void),
+    ) => void;
+    subscribeToPromise: <S>(
+      callback: ((value: T) => Promise<void>) | ((value: T) => void),
+    ) => void;
+  } & AtomEffectParams<ReturnType>,
+) => void | (() => void);
+
+// --- Base class ---
+
+class Dependable<T> {
+  private emitter: EventEmitter;
+  protected state: RecoilState<T>;
+
+  constructor(state: RecoilState<T>) {
+    this.emitter = new EventEmitter();
+    this.state = state;
+  }
+
+  getEffect<S>(createEffect: DependableAtomEffect<T, S>) {
+    return (({ getPromise, getLoadable, ...atomTools }: any) =>
+      createEffect({
+        ...atomTools,
+        getPromise,
+        getLoadable,
+        subscribeToLoadable: this.subscribeToLoadable(getLoadable),
+        subscribeToPromise: this.subscribeToPromise(getPromise),
+      })) as unknown as AtomEffect<S>;
+  }
+
+  protected addListener(callback: (_value: T) => void) {
+    this.emitter.on('change', callback);
+  }
+
+  protected removeListener(callback: (_value: T) => void) {
+    this.emitter.off('change', callback);
+  }
+
+  protected emitChange(newValue: T) {
+    this.emitter.emit('change', newValue);
+  }
+
+  private subscribeToPromise(getPromise: (recoilValue: RecoilValue<T>) => Promise<T>) {
+    return (callback: (_value: T) => void) => {
+      getPromise(this.state).then(result => {
+        callback(result);
+        this.addListener(callback);
+        return () => this.removeListener(callback);
+      });
+    };
+  }
+
+  private subscribeToLoadable(getLoadable: (recoilValue: RecoilValue<T>) => Loadable<T>) {
+    return (callback: (_value: T) => void) => {
+      const loadable = getLoadable(this.state);
+      if (loadable.state === 'hasValue') {
+        callback(loadable.contents);
+      }
+      this.addListener(callback);
+      return () => this.removeListener(callback);
+    };
+  }
+}
+
+// --- Family base class ---
+
+class DependableFamily<T, ParamType extends SerializableParam> {
+  private emitter: EventEmitter;
+  protected state: (param: ParamType) => RecoilState<T>;
+
+  constructor(state: (param: ParamType) => RecoilState<T>) {
+    this.emitter = new EventEmitter();
+    this.state = state;
+  }
+
+  protected emitChange(param: ParamType, newValue: T) {
+    this.emitter.emit(`change:${JSON.stringify(param)}`, newValue);
+  }
+
+  private addListener(param: ParamType, callback: (_value: T) => void) {
+    this.emitter.on(`change:${JSON.stringify(param)}`, callback);
+  }
+
+  private removeListener(param: ParamType, callback: (_value: T) => void) {
+    this.emitter.off(`change:${JSON.stringify(param)}`, callback);
+  }
+}
+
+// --- Public classes ---
+
+export class DependableAtom<T> extends Dependable<T> {
+  constructor({
+    key,
+    effects,
+    ...props
+  }: {
+    key: string;
+    default?: T;
+    effects: DependableAtomEffect<any, T>[];
+  }) {
+    super(
+      atom<T>({
+        key,
+        ...props,
+        effects: [
+          ({ onSet }) => {
+            onSet(newValue => {
+              this.emitChange(newValue);
+            });
+          },
+          ...effects,
+        ] as AtomEffect<T>[],
+      }),
+    );
+  }
+
+  get atom() {
+    return this.state;
+  }
+}
+
+export class DependableSelector<T> extends Dependable<T> {
+  constructor({ key, set, get }: ReadWriteSelectorOptions<T>) {
+    super(
+      selector<T>({
+        key,
+        get,
+        set: (opts, newValue) => {
+          if (newValue instanceof DefaultValue) return;
+          this.emitChange(newValue);
+          set(opts, newValue);
+        },
+      }),
+    );
+  }
+
+  get selector() {
+    return this.state;
+  }
+}
+
+export class DependableAtomFamily<T, ParamType extends SerializableParam> extends DependableFamily<T, ParamType> {
+  constructor(params: {
+    key: string;
+    default?: (param: ParamType) => T;
+    effects: ((param: ParamType) => AtomEffect<T>)[];
+  }) {
+    super(
+      atomFamily<T, ParamType>({
+        key: params.key,
+        default: params.default,
+        effects: (param: ParamType) =>
+          [
+            ({ onSet }: any) => {
+              onSet((newValue: T) => {
+                this.emitChange(param, newValue);
+              });
+            },
+            ...params.effects.map(effect => effect(param)),
+          ] as AtomEffect<T>[],
+      }),
+    );
+  }
+
+  get atomFamily() {
+    return this.state;
+  }
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Feed sync atoms.
+ * Ported from squad-demo/src/atoms/sync/feed-v2.ts.
+ */
+import { atom, atomFamily, selector } from 'recoil';
+import type { Feed, Freestyle, FreestyleReaction } from '@squad-sports/core';
+import { type CrdtArray } from './crdt';
+
+// Initial feed from API
+export const reInitialFeed = atom<Feed | null>({
+  key: 'squad-sdk:feed:initial:v2',
+  default: null,
+});
+
+// Real-time feed updates
+export const feedUpdates = atom<CrdtArray<string, Freestyle>>({
+  key: 'squad-sdk:feed:updates',
+  default: new Map(),
+});
+
+// Feed expiry tick (refreshes every 60s)
+export const feedExpiryTickAtom = atom<number>({
+  key: 'squad-sdk:feed:expiry-tick',
+  default: 0,
+});
+
+// Freestyle reactions per freestyle
+export const freestyleReactionUpdates = atomFamily<CrdtArray<string, FreestyleReaction>, string>({
+  key: 'squad-sdk:freestyle:reactions',
+  default: new Map(),
+});
+
+// Freestyle-specific state
+export const reFreestylePrompts = atom<unknown[]>({
+  key: 'squad-sdk:freestyle:prompts',
+  default: [],
+});
+
+export const reFreestyleCreating = atom<boolean>({
+  key: 'squad-sdk:freestyle:creating',
+  default: false,
+});

package/src/state/sync/messages.ts

@@ -0,0 +1,44 @@
+/**
+ * Message sync atoms.
+ * Ported from squad-demo/src/atoms/sync/messages.ts + message-prompts.ts.
+ */
+import { atom, atomFamily } from 'recoil';
+import type { Conversation, Message, MessageReaction } from '@squad-sports/core';
+
+// Conversation per connection (initial from API)
+export const reInitialConversationState = atomFamily<Conversation | null, string>({
+  key: 'squad-sdk:connection:messages:initial',
+  default: null,
+});
+
+// Messages per connection (compiled with real-time updates)
+export const reConnectionMessages = atomFamily<Message[], string>({
+  key: 'squad-sdk:connection:messages',
+  default: [],
+});
+
+// Message reactions
+export const reMessageReaction = atomFamily<MessageReaction | null, string>({
+  key: 'squad-sdk:message-reaction',
+  default: null,
+});
+
+// Failed message tracking
+export interface FailedMessageInfo {
+  messageId: string;
+  connectionId: string;
+  error: string;
+  timestamp: number;
+  retryCount: number;
+}
+
+export const reMessageSendStatus = atom<Map<string, FailedMessageInfo>>({
+  key: 'squad-sdk:messages:send-status',
+  default: new Map(),
+});
+
+// Message prompts
+export const reMessagePrompts = atom<unknown[]>({
+  key: 'squad-sdk:messages:prompts',
+  default: [],
+});

package/src/state/sync/offline-support.ts

@@ -0,0 +1,42 @@
+/**
+ * Offline support atoms.
+ * Ported from squad-demo/src/atoms/sync/offline-support.ts.
+ */
+import { atom } from 'recoil';
+
+export type OfflineActionType =
+  | 'message:create'
+  | 'freestyle:create'
+  | 'poll:response'
+  | 'connection:invite'
+  | 'message:reaction'
+  | 'freestyle:reaction'
+  | 'user:update';
+
+export interface QueuedOfflineAction {
+  id: string;
+  type: OfflineActionType;
+  payload: unknown;
+  createdAt: number;
+  attempts: number;
+}
+
+export const isOnlineAtom = atom<boolean>({
+  key: 'squad-sdk:network:isOnline',
+  default: true,
+});
+
+export const pendingActionsAtom = atom<QueuedOfflineAction[]>({
+  key: 'squad-sdk:offline:pendingActions',
+  default: [],
+});
+
+export const offlineCacheAtom = atom<Map<string, { data: unknown; timestamp: number }>>({
+  key: 'squad-sdk:offline:cache',
+  default: new Map(),
+});
+
+export const shouldUseOfflineDataSelector = atom<boolean>({
+  key: 'squad-sdk:offline:shouldUseOfflineData',
+  default: false,
+});