@ethora/chat-component-rn 26.7.10 → 26.8.1

package/src/helpers/persistCrypto.ts

@@ -1,127 +0,0 @@
-import CryptoJS from 'crypto-js';
-import { secureGet, secureSet } from './secureKeyValue';
-
-// AES-256-CBC at rest for the bulk persisted state (message history +
-// room list) that `roomStore/persistence.ts` writes to AsyncStorage.
-// This is envelope encryption, not a SecureStore write of the payload
-// itself: expo-secure-store has historically capped a single value's
-// size on Android (chunking exists in newer releases, but the payload
-// here is unbounded — up to MESSAGE_LIMIT messages per room, times
-// every room), so only the small symmetric KEY goes through the
-// platform Keychain/Keystore (`secureKeyValue.ts`); the ciphertext
-// itself stays in plain AsyncStorage, unreadable without that key.
-const CIPHER_KEY_STORE_KEY = 'ethora_history_cipher_key';
-const ENVELOPE_VERSION = 1;
-const KEY_BYTES = 32; // AES-256
-const IV_BYTES = 16; // one AES block
-
-interface Envelope {
-  v: number;
-  iv: string; // base64
-  ct: string; // base64 ciphertext
-}
-
-/**
- * `crypto-js`'s own `WordArray.random()` falls back to `Math.random()`
- * when it can't detect a browser `window.crypto` — not safe for key/IV
- * material. `react-native-get-random-values` (a REQUIRED peer
- * dependency, imported at the top of `main.ts`/`index.js` before
- * anything else in the SDK runs) polyfills the real thing onto
- * `global.crypto.getRandomValues` instead; source bytes from that and
- * hand them to crypto-js as a WordArray rather than trust its default.
- */
-const randomWordArray = (byteLength: number): CryptoJS.lib.WordArray => {
-  const bytes = new Uint8Array(byteLength);
-  (global as any).crypto.getRandomValues(bytes);
-  const words: number[] = [];
-  for (let i = 0; i < bytes.length; i += 4) {
-    words.push(
-      ((bytes[i] || 0) << 24) |
-        ((bytes[i + 1] || 0) << 16) |
-        ((bytes[i + 2] || 0) << 8) |
-        (bytes[i + 3] || 0)
-    );
-  }
-  return CryptoJS.lib.WordArray.create(words, byteLength);
-};
-
-let cachedKeyPromise: Promise<CryptoJS.lib.WordArray> | null = null;
-
-/**
- * One AES-256 key per install, generated on first use and persisted
- * through the SecureStore/Keychain bridge. Reused across logins on
- * purpose: the ciphertext it protects is deleted wholesale on logout
- * (`clearPersistedState`), so there is no cross-account data for a
- * stable key to expose — only the encrypted blob of whoever is
- * currently logged in ever exists on disk at a given time.
- */
-const loadOrCreateKey = (): Promise<CryptoJS.lib.WordArray> => {
-  if (cachedKeyPromise) {return cachedKeyPromise;}
-  cachedKeyPromise = (async () => {
-    const existing = await secureGet(CIPHER_KEY_STORE_KEY);
-    if (existing) {
-      return CryptoJS.enc.Base64.parse(existing);
-    }
-    const key = randomWordArray(KEY_BYTES);
-    await secureSet(CIPHER_KEY_STORE_KEY, CryptoJS.enc.Base64.stringify(key));
-    return key;
-  })();
-  return cachedKeyPromise;
-};
-
-/** Encrypt a JSON-serialisable payload for storage. Returns the string to persist. */
-export async function encryptForPersist(plaintext: string): Promise<string> {
-  const key = await loadOrCreateKey();
-  const iv = randomWordArray(IV_BYTES);
-  const encrypted = CryptoJS.AES.encrypt(plaintext, key, {
-    iv,
-    mode: CryptoJS.mode.CBC,
-    padding: CryptoJS.pad.Pkcs7,
-  });
-  const envelope: Envelope = {
-    v: ENVELOPE_VERSION,
-    iv: CryptoJS.enc.Base64.stringify(iv),
-    ct: encrypted.ciphertext.toString(CryptoJS.enc.Base64),
-  };
-  return JSON.stringify(envelope);
-}
-
-/**
- * Decrypt a value previously written by `encryptForPersist`. Returns
- * null (never throws) for anything that isn't a valid envelope for the
- * current key — including a plaintext blob from a pre-encryption
- * install: the app just re-hydrates that room/history from the server,
- * same as any other empty-cache cold start.
- */
-export async function decryptFromPersist(
-  stored: string
-): Promise<string | null> {
-  try {
-    const envelope = JSON.parse(stored) as Partial<Envelope>;
-    if (
-      !envelope ||
-      envelope.v !== ENVELOPE_VERSION ||
-      !envelope.iv ||
-      !envelope.ct
-    ) {
-      return null;
-    }
-    const key = await loadOrCreateKey();
-    const iv = CryptoJS.enc.Base64.parse(envelope.iv);
-    const ciphertext = CryptoJS.enc.Base64.parse(envelope.ct);
-    const decrypted = CryptoJS.AES.decrypt(
-      { ciphertext } as CryptoJS.lib.CipherParams,
-      key,
-      { iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }
-    );
-    const plaintext = decrypted.toString(CryptoJS.enc.Utf8);
-    return plaintext || null;
-  } catch {
-    return null;
-  }
-}
-
-/** Test seam only. */
-export const __resetPersistCryptoKeyForTests = (): void => {
-  cachedKeyPromise = null;
-};

package/src/helpers/pickImageAsset.ts

@@ -1,68 +0,0 @@
-import { Alert, Linking } from 'react-native';
-import * as ImagePicker from 'expo-image-picker';
-
-/**
- * A picked image in the shape React Native's FormData understands.
- *
- * NOT a web `File`: RN streams a multipart part straight from a `file://`
- * uri and has no usable Blob/File/atob path. Screens ported from the web
- * client used to carry base64 -> Blob -> File helpers that could never
- * have run here.
- */
-export interface PickedImage {
-  uri: string;
-  type: string;
-  name: string;
-}
-
-/**
- * Ask for library permission, open the picker, and normalise the result.
- *
- * Returns `null` for every non-error outcome — permission refused, user
- * cancelled — so call sites can simply keep their current value.
- *
- * Exists because the avatar pickers are wired to `onPress`, which hands
- * the callback a SyntheticEvent. Storing that event as "the image" (what
- * two screens used to do) rendered a pooled event as an <Image source>
- * and then crashed with "Property is not configurable" when React tried
- * to release it — on top of never letting the user pick anything.
- */
-export const pickImageAsset = async (): Promise<PickedImage | null> => {
-  try {
-    // expo-image-picker owns the permission prompt internally and
-    // returns a `granted` flag.
-    const perm = await ImagePicker.requestMediaLibraryPermissionsAsync();
-    if (!perm.granted) {
-      Alert.alert(
-        'Permission required',
-        'Photo library permission is needed to select images.',
-        [
-          { text: 'Cancel', style: 'cancel' },
-          { text: 'Open Settings', onPress: () => Linking.openSettings() },
-        ]
-      );
-      return null;
-    }
-
-    const result = await ImagePicker.launchImageLibraryAsync({
-      mediaTypes: ['images'],
-      allowsEditing: true,
-      aspect: [1, 1],
-      quality: 0.8,
-    });
-    if (result.canceled || !result.assets?.[0]) {
-      return null;
-    }
-
-    const asset = result.assets[0];
-    const originalName = asset.fileName || asset.uri.split('/').pop();
-    return {
-      uri: asset.uri,
-      type: asset.mimeType || 'image/jpeg',
-      name: originalName || `image_${Date.now()}.jpg`,
-    };
-  } catch (error) {
-    console.error('Failed to pick an image:', error);
-    return null;
-  }
-};

package/src/helpers/pushPayload.ts

@@ -1,62 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { store } from '../roomStore';
-import {
-  clearPendingNotificationJid,
-  setCurrentRoom,
-  setPendingNotificationJid,
-} from '../roomStore/roomsSlice';
-import { handleCallPush } from './incomingCallFromPush';
-import { normalizeRoomJid } from './normalizeRoomJid';
-
-export type PushPayloadOutcome = 'call' | 'room' | 'pending' | 'unknown';
-
-export const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
-export const PENDING_NOTIFICATION_TTL_MS = 5 * 60 * 1000;
-
-export const readPendingJid = async (): Promise<string | null> => {
-  try {
-    const raw = await AsyncStorage.getItem(PENDING_NOTIFICATION_JID_KEY);
-    if (!raw) {return null;}
-    if (raw.startsWith('{')) {
-      const { jid, at } = JSON.parse(raw) as { jid?: string; at?: number };
-      if (!jid || !at || Date.now() - at > PENDING_NOTIFICATION_TTL_MS) {
-        await AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY);
-        return null;
-      }
-      return jid;
-    }
-    return raw;
-  } catch {
-    return null;
-  }
-};
-
-export const openRoomFromPush = (jid: string): 'room' | 'pending' => {
-  const state = store.getState();
-  const conference = state.chatSettingStore?.config?.xmppSettings?.conference;
-  const full = normalizeRoomJid(jid, conference);
-
-  AsyncStorage.setItem(
-    PENDING_NOTIFICATION_JID_KEY,
-    JSON.stringify({ jid: full, at: Date.now() })
-  ).catch(() => undefined);
-  if (state.rooms?.rooms?.[full]) {
-    store.dispatch(clearPendingNotificationJid());
-    store.dispatch(setCurrentRoom({ roomJID: full }));
-    return 'room';
-  }
-  store.dispatch(setPendingNotificationJid(full));
-  return 'pending';
-};
-
-export const handlePushPayload = (
-  data: Record<string, unknown> | null | undefined
-): PushPayloadOutcome => {
-  if (!data) {return 'unknown';}
-  if (handleCallPush(data as Record<string, any>)) {return 'call';}
-  const jid = data.jid ?? data.chatJid ?? data.roomJid ?? data.roomJID;
-  if (typeof jid === 'string' && jid) {
-    return openRoomFromPush(jid);
-  }
-  return 'unknown';
-};

package/src/helpers/secureFileUrl.ts

@@ -1,103 +0,0 @@
-import { store } from '../roomStore';
-import { getCurrentBaseURL } from '../networking/apiClient';
-import { refreshAuthTokens } from '../networking/authRefresh';
-
-const SECURE_FILES_HOST_PREFIX = 'secure-files.';
-const SECURE_MEDIA_PATH_PREFIX = '/secure-media/';
-
-const FILE_TOKEN_PARAM = 'ft';
-
-export const resolveFileUrl = (url?: string | null): string => {
-  if (!url) {return '';}
-  // Any scheme at all — http(s), data, file, content, blob.
-  if (/^[a-z][a-z0-9+.-]*:/i.test(url)) {return url;}
-  if (!url.startsWith('/')) {return url;}
-
-  const base = getCurrentBaseURL().replace(/\/+$/, '');
-  return base ? `${base}${url}` : url;
-};
-
-export const isSecureFileUrl = (url?: string | null): boolean => {
-  if (!url) {return false;}
-
-  const path = url.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, '');
-  if (path.startsWith(SECURE_MEDIA_PATH_PREFIX)) {return true;}
-
-  const match = /^https?:\/\/(?:[^@/]+@)?([^:/?#]+)/i.exec(url);
-  if (!match) {return false;}
-  return match[1].toLowerCase().startsWith(SECURE_FILES_HOST_PREFIX);
-};
-
-export const appendFileToken = (
-  url: string | null | undefined,
-  fileToken: string | null | undefined
-): string => {
-  if (!url) {return '';}
-
-  const resolved = resolveFileUrl(url);
-  if (!fileToken || !isSecureFileUrl(resolved)) {return resolved;}
-  url = resolved;
-
-  const hashIndex = url.indexOf('#');
-  const hash = hashIndex === -1 ? '' : url.slice(hashIndex);
-  const withoutHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
-
-  const queryIndex = withoutHash.indexOf('?');
-  const base = queryIndex === -1 ? withoutHash : withoutHash.slice(0, queryIndex);
-  const query = queryIndex === -1 ? '' : withoutHash.slice(queryIndex + 1);
-
-  const params = query
-    .split('&')
-    .filter(Boolean)
-    .filter((pair) => pair.split('=')[0] !== FILE_TOKEN_PARAM);
-
-  params.push(`${FILE_TOKEN_PARAM}=${encodeURIComponent(fileToken)}`);
-
-  return `${base}?${params.join('&')}${hash}`;
-};
-
-export const withFileToken = (url?: string | null): string =>
-  appendFileToken(
-    url,
-    store.getState().chatSettingStore?.user?.fileToken || ''
-  );
-
-const RECOVERY_COOLDOWN_MS = 30_000;
-let recoveryInFlight: Promise<boolean> | null = null;
-let lastRecoveryAt = 0;
-
-export const requestFileTokenRecovery = (): Promise<boolean> => {
-  if (recoveryInFlight) {return recoveryInFlight;}
-
-  const now = Date.now();
-  if (now - lastRecoveryAt < RECOVERY_COOLDOWN_MS) {
-    return Promise.resolve(false);
-  }
-  lastRecoveryAt = now;
-
-  const state = store.getState();
-  const refreshConfig = state.chatSettingStore?.config?.refreshTokens;
-  const user = state.chatSettingStore?.user;
-
-  if (!refreshConfig?.enabled) {return Promise.resolve(false);}
-
-  const run = async (): Promise<boolean> => {
-    if (!refreshConfig.refreshFunction && !user?.refreshToken) {return false;}
-
-    const tokens = await refreshAuthTokens();
-    return Boolean(tokens.fileToken);
-  };
-
-  recoveryInFlight = run()
-    .catch(() => false)
-    .finally(() => {
-      recoveryInFlight = null;
-    });
-
-  return recoveryInFlight;
-};
-
-export const __resetFileTokenRecoveryForTests = (): void => {
-  recoveryInFlight = null;
-  lastRecoveryAt = 0;
-};

package/src/helpers/secureKeyValue.ts

@@ -1,80 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { loadSecureStore } from './secureStoreRuntime';
-import { pushLog } from '../utils/devLogger';
-
-// Fallback keys are prefixed and namespaced away from every other
-// AsyncStorage key this SDK writes, so a host that never installs
-// expo-secure-store can still be told apart from one that used to lack
-// it and has since added it (see `secureSet`'s stale-fallback cleanup).
-const FALLBACK_PREFIX = '@ethora/secure-fallback:';
-
-let warnedFallback = false;
-const warnFallbackOnce = () => {
-  if (warnedFallback) {return;}
-  warnedFallback = true;
-  pushLog(
-    'warn',
-    'expo-secure-store is not installed — auth tokens, the XMPP ' +
-      'password, and the message-history cipher key are falling back ' +
-      'to plain AsyncStorage instead of the platform Keychain/Keystore. ' +
-      'Add the optional peer dependency `expo-secure-store` to your app ' +
-      'to store them securely.'
-  );
-};
-
-/**
- * Small-value secure KV store: platform Keychain/Keystore via
- * expo-secure-store when the host has it installed, plain (but still
- * namespaced) AsyncStorage otherwise. NOT for bulk data — see
- * `persistCrypto.ts`'s size note on why message history goes through
- * AES instead of straight into this store.
- */
-export async function secureGet(key: string): Promise<string | null> {
-  const store = loadSecureStore();
-  if (store) {
-    try {
-      return await store.getItemAsync(key);
-    } catch (e) {
-      pushLog('warn', `secureStore: getItemAsync(${key}) failed`, e);
-      return null;
-    }
-  }
-  warnFallbackOnce();
-  return AsyncStorage.getItem(FALLBACK_PREFIX + key);
-}
-
-export async function secureSet(key: string, value: string): Promise<void> {
-  const store = loadSecureStore();
-  if (store) {
-    try {
-      await store.setItemAsync(key, value);
-      // Clean up a stale plaintext fallback copy from before this host
-      // added expo-secure-store — otherwise it sits on disk forever.
-      AsyncStorage.removeItem(FALLBACK_PREFIX + key).catch(() => undefined);
-      return;
-    } catch (e) {
-      pushLog('warn', `secureStore: setItemAsync(${key}) failed`, e);
-      return;
-    }
-  }
-  warnFallbackOnce();
-  await AsyncStorage.setItem(FALLBACK_PREFIX + key, value);
-}
-
-export async function secureRemove(key: string): Promise<void> {
-  const store = loadSecureStore();
-  if (store) {
-    try {
-      await store.deleteItemAsync(key);
-    } catch {
-      // Key may simply not exist — deleteItemAsync throwing here isn't
-      // actionable either way.
-    }
-  }
-  await AsyncStorage.removeItem(FALLBACK_PREFIX + key).catch(() => undefined);
-}
-
-/** Test seam only. */
-export const __resetSecureKeyValueWarningForTests = (): void => {
-  warnedFallback = false;
-};

package/src/helpers/secureStoreRuntime.ts

@@ -1,62 +0,0 @@
-/**
- * Optional-dependency bridge for `expo-secure-store` — the Keychain
- * (iOS) / Keystore-backed EncryptedSharedPreferences (Android) API.
- *
- * Mirrors `components/VideoCalls/livekitRuntime.ts`: a plain top-level
- * `import ... from 'expo-secure-store'` is not allowed anywhere in the
- * SDK, since Metro resolves imports at bundle time and a host that
- * hasn't added this optional peer dependency would fail to build over
- * a feature it never opted into. Everything goes through
- * `loadSecureStore()`, which requires the module lazily and returns
- * null when it isn't installed — callers fall back to plain
- * AsyncStorage rather than crash (see `secureKeyValue.ts`).
- */
-
-export interface SecureStoreRuntime {
-  getItemAsync: (key: string) => Promise<string | null>;
-  setItemAsync: (key: string, value: string) => Promise<void>;
-  deleteItemAsync: (key: string) => Promise<void>;
-}
-
-let cached: SecureStoreRuntime | null | undefined;
-
-/**
- * Resolve the SecureStore runtime, or null when the optional native
- * package isn't installed in the host app. Result is memoised
- * (including the failure) so a missing dependency doesn't re-throw on
- * every read/write.
- */
-export const loadSecureStore = (): SecureStoreRuntime | null => {
-  if (cached !== undefined) {
-    return cached;
-  }
-
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const mod = require('expo-secure-store');
-    if (
-      typeof mod?.getItemAsync !== 'function' ||
-      typeof mod?.setItemAsync !== 'function' ||
-      typeof mod?.deleteItemAsync !== 'function'
-    ) {
-      cached = null;
-    } else {
-      cached = {
-        getItemAsync: mod.getItemAsync,
-        setItemAsync: mod.setItemAsync,
-        deleteItemAsync: mod.deleteItemAsync,
-      };
-    }
-  } catch {
-    cached = null;
-  }
-
-  return cached;
-};
-
-export const isSecureStoreAvailable = (): boolean => loadSecureStore() !== null;
-
-/** Test seam only. */
-export const __resetSecureStoreRuntimeForTests = (): void => {
-  cached = undefined;
-};

package/src/helpers/secureUserStorage.ts

@@ -1,80 +0,0 @@
-import { User } from '../types/types';
-import { asyncLocalStorage } from '../hooks/useLocalStorage';
-import { localStorageConstants } from './constants/LOCAL_STORAGE';
-import { secureGet, secureSet, secureRemove } from './secureKeyValue';
-
-// Keychain (iOS) / Keystore-backed EncryptedSharedPreferences (Android)
-// keys for the four live bearer credentials on `User`. Deliberately one
-// key per field rather than one JSON blob: expo-secure-store historically
-// caps a single value's size on Android, and four short JWTs each stay
-// comfortably under that ceiling where one combined blob might not.
-const SECRET_KEYS = {
-  token: 'ethora_auth_token',
-  refreshToken: 'ethora_auth_refresh_token',
-  xmppPassword: 'ethora_auth_xmpp_password',
-  fileToken: 'ethora_auth_file_token',
-} as const;
-
-type SecretField = keyof typeof SECRET_KEYS;
-const SECRET_FIELDS = Object.keys(SECRET_KEYS) as SecretField[];
-
-/**
- * Persisted-user storage, split across two backends behind the exact
- * same `{ get, set, remove }` shape `asyncLocalStorage<User>(...)`
- * already exposed — every existing call site swaps in by changing only
- * the constructor call, `get()`/`set()`/`remove()` keep returning/taking
- * a complete `User`.
- *
- * The four live credentials (REST access + refresh token, XMPP
- * password, secure-media fileToken) never touch plain AsyncStorage:
- * they go through `secureGet`/`secureSet`/`secureRemove` (platform
- * Keychain/Keystore, falling back to namespaced AsyncStorage only when
- * the host hasn't installed the optional `expo-secure-store` peer dep).
- * Everything else on `User` — name, avatar, ids, xmppUsername, wallet
- * address, none of it a bearer credential — keeps living under the
- * existing `ETHORA_USER` AsyncStorage key, unchanged.
- */
-export function secureUserStorage() {
-  const get = async (): Promise<User | null> => {
-    const profile = await asyncLocalStorage<User>(
-      localStorageConstants.ETHORA_USER
-    ).get();
-    if (!profile) {return null;}
-
-    const secretValues = await Promise.all(
-      SECRET_FIELDS.map((field) => secureGet(SECRET_KEYS[field]))
-    );
-
-    const merged: User = { ...profile };
-    SECRET_FIELDS.forEach((field, i) => {
-      (merged as any)[field] = secretValues[i] || '';
-    });
-    return merged;
-  };
-
-  const set = async (user: User): Promise<void> => {
-    const profile: any = { ...user };
-    for (const field of SECRET_FIELDS) {
-      profile[field] = '';
-    }
-
-    await Promise.all([
-      asyncLocalStorage<User>(localStorageConstants.ETHORA_USER).set(profile),
-      ...SECRET_FIELDS.map((field) => {
-        const value = user?.[field] as string | undefined;
-        return value
-          ? secureSet(SECRET_KEYS[field], value)
-          : secureRemove(SECRET_KEYS[field]);
-      }),
-    ]);
-  };
-
-  const remove = async (): Promise<void> => {
-    await Promise.all([
-      asyncLocalStorage(localStorageConstants.ETHORA_USER).remove(),
-      ...SECRET_FIELDS.map((field) => secureRemove(SECRET_KEYS[field])),
-    ]);
-  };
-
-  return { get, set, remove };
-}

package/src/helpers/shallowEqual.ts

@@ -1,33 +0,0 @@
-/**
- * One-level shallow equality for plain objects. Used to avoid re-dispatching
- * config into redux on every render just because the host passed a fresh
- * object literal with the same values (e.g. `<Chat config={{...}} />`
- * re-created inline) — reference equality alone would fire far too often,
- * and a deep/JSON comparison risks throwing on non-serializable fields
- * (functions, React elements) that configs legitimately carry.
- */
-export function shallowEqual(a: unknown, b: unknown): boolean {
-  if (a === b) {return true;}
-  if (
-    typeof a !== 'object' ||
-    typeof b !== 'object' ||
-    a === null ||
-    b === null
-  ) {
-    return false;
-  }
-  const aKeys = Object.keys(a as Record<string, unknown>);
-  const bKeys = Object.keys(b as Record<string, unknown>);
-  if (aKeys.length !== bKeys.length) {return false;}
-  for (const key of aKeys) {
-    if (
-      (a as Record<string, unknown>)[key] !==
-      (b as Record<string, unknown>)[key]
-    ) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export default shallowEqual;

package/src/helpers/sheetGestures.ts

@@ -1,25 +0,0 @@
-/** @format */
-
-/**
- * Shared thresholds for the drag-to-dismiss gesture on bottom sheets (the
- * attach sheet, the profile headers, the room-list menu). Kept in one
- * place so a pull feels identical wherever the user does it — and so the
- * numbers are unit-testable without a touch event.
- */
-
-/** Drag past this many points and letting go dismisses the sheet. */
-export const DISMISS_DISTANCE = 90;
-/** …or flick faster than this, however short the drag. */
-export const DISMISS_VELOCITY = 0.8;
-
-/**
- * Claim a drag only once it is clearly a downward pull, so a tap on a row
- * still registers and a horizontal swipe stays with whatever scrolls
- * sideways inside the sheet.
- */
-export const shouldClaimVerticalDrag = (dy: number, dx: number) =>
-  dy > 6 && Math.abs(dy) > Math.abs(dx) * 1.5;
-
-/** Far enough / fast enough to let go of the sheet. */
-export const shouldDismissOnDrag = (dy: number, vy: number) =>
-  dy > DISMISS_DISTANCE || vy > DISMISS_VELOCITY;

package/src/hooks/useFileToken.ts

@@ -1,7 +0,0 @@
-import { useSelector } from 'react-redux';
-import { RootState } from '../roomStore';
-
-export const useFileToken = (): string =>
-  useSelector(
-    (state: RootState) => state.chatSettingStore.user?.fileToken || ''
-  );