@kesha-antonov/react-native-chat 5.0.0 → 6.0.0

package/lib/components/roundNotePlayers.js

@@ -0,0 +1,230 @@
+/*
+ * Round note players that outlive their rows.
+ *
+ * The list virtualizes: scroll far enough from a playing round note and its
+ * row unmounts, which used to release its expo-video player and cut the note
+ * off mid-sentence. It should keep playing and float in a corner
+ * until its message is back on screen. So players live
+ * here, keyed by message id: a row borrows its note's player while mounted,
+ * and a note that is current when its row goes away is handed to a detached
+ * session that keeps driving the same player - the floating note shows it and
+ * the "now playing" bar keeps controlling it. When the row mounts again it
+ * takes the session back and carries on from where the player is.
+ */
+
+/** The subset of expo-video's `VideoPlayer` used here. */
+
+/** A detached note, waiting for its row to come back or for playback to end. */
+
+/**
+ * How long a player with no rows lingers before it is released. A row that
+ * unmounts and mounts straight back (React's strict effects, a list re-render)
+ * picks up the same player instead of creating a new one.
+ */
+export const NOTE_PLAYER_GRACE_MS = 500;
+const releasePlayer = player => {
+  try {
+    player.pause();
+  } catch {
+    // already torn down
+  }
+  try {
+    player.release?.();
+  } catch {
+    // already torn down
+  }
+};
+export const createNotePlayerCache = (graceMs = NOTE_PLAYER_GRACE_MS) => {
+  const entries = new Map();
+  let active = true;
+  const cancelTimer = entry => {
+    if (entry.releaseTimer != null) {
+      clearTimeout(entry.releaseTimer);
+      entry.releaseTimer = null;
+    }
+  };
+  const scheduleRelease = (key, entry) => {
+    cancelTimer(entry);
+    if (entry.refs > 0 || entry.isKept) return;
+    entry.releaseTimer = setTimeout(() => {
+      entry.releaseTimer = null;
+      if (entry.refs > 0 || entry.isKept || entries.get(key) !== entry) return;
+      entries.delete(key);
+      releasePlayer(entry.player);
+    }, graceMs);
+  };
+  return {
+    get(key, create) {
+      const existing = entries.get(key);
+      if (existing) return existing.player;
+      const entry = {
+        player: create(),
+        refs: 0,
+        isKept: false,
+        detached: null,
+        releaseTimer: null
+      };
+      entries.set(key, entry);
+      // Created by a render that may never commit: release it unless a row
+      // retains it in time.
+      scheduleRelease(key, entry);
+      return entry.player;
+    },
+    retain(key) {
+      const entry = entries.get(key);
+      if (!entry) return;
+      entry.refs += 1;
+      cancelTimer(entry);
+    },
+    release(key) {
+      const entry = entries.get(key);
+      if (!entry) return;
+      entry.refs = Math.max(0, entry.refs - 1);
+      scheduleRelease(key, entry);
+    },
+    keep(key, isKept) {
+      const entry = entries.get(key);
+      if (!entry || entry.isKept === isKept) return;
+      entry.isKept = isKept;
+      scheduleRelease(key, entry);
+    },
+    setDetached(key, detached) {
+      const entry = entries.get(key);
+      if (entry) entry.detached = detached;
+    },
+    takeDetached(key) {
+      const entry = entries.get(key);
+      const detached = entry?.detached ?? null;
+      if (entry) entry.detached = null;
+      return detached;
+    },
+    setActive(isActive) {
+      active = isActive;
+      if (isActive) return;
+      for (const [key, entry] of [...entries]) {
+        const detached = entry.detached;
+        entry.detached = null;
+        try {
+          detached?.end();
+        } catch {
+          // keep tearing the rest down
+        }
+        entry.isKept = false;
+        if (entry.refs === 0) {
+          cancelTimer(entry);
+          entries.delete(key);
+          releasePlayer(entry.player);
+        }
+      }
+    },
+    isActive() {
+      return active;
+    }
+  };
+};
+
+/** What a detached note needs from the chat around it. */
+
+/**
+ * Keeps a current round note going after its row unmounted. The player stays
+ * as the row left it, playing or paused; this answers the "now playing" bar
+ * and the floating note, stops when another note starts, and on the note's
+ * natural end resets the player and hands over to the next note, as the row
+ * would have.
+ */
+export const detachRoundNote = (key, player, isPlaying, host) => {
+  const claimId = `detached-round:${String(key)}`;
+  let playing = isPlaying;
+  let isOver = false;
+
+  // Only while playing: on iOS a rate set on a paused player starts it.
+  const unsubscribeRate = host.subscribeRate(rate => {
+    if (!playing) return;
+    try {
+      player.playbackRate = rate;
+    } catch {
+      // already torn down
+    }
+  });
+  let endSubscription;
+  const detach = () => {
+    isOver = true;
+    endSubscription?.remove?.();
+    unsubscribeRate();
+    host.unclaim(claimId);
+    host.cache.setDetached(key, null);
+  };
+  const end = () => {
+    if (isOver) return;
+    detach();
+    // Back to rest, so a row that mounts later shows the first frame.
+    // The rate first: set after the pause, it would start the player again.
+    try {
+      player.playbackRate = 1;
+      player.pause();
+      player.muted = true;
+      player.currentTime = 0;
+    } catch {
+      // already torn down
+    }
+    host.report(null);
+    host.cache.keep(key, false);
+  };
+  const pause = () => {
+    try {
+      player.pause();
+    } catch {
+      // already torn down
+    }
+    playing = false;
+    publish();
+  };
+  const toggle = () => {
+    if (isOver) return;
+    if (playing) {
+      pause();
+      return;
+    }
+    try {
+      player.playbackRate = host.getRate();
+      player.play();
+    } catch {
+      return;
+    }
+    playing = true;
+    host.claim(claimId, onStop);
+    publish();
+  };
+
+  // Another note starting ends this one (`cleanupPlayer`); a recording only
+  // pauses it, and it stays current.
+  const onStop = reason => {
+    if (reason === 'replaced') end();else pause();
+  };
+  const publish = () => {
+    if (!isOver) host.report({
+      isPlaying: playing,
+      toggle,
+      stop: end
+    });
+  };
+  endSubscription = player.addListener?.('playToEnd', () => {
+    if (isOver) return;
+    end();
+    host.onEnded();
+  });
+
+  // A paused note keeps its claim too, so a later note still ends it.
+  host.claim(claimId, onStop);
+  publish();
+  const detached = {
+    adopt() {
+      if (!isOver) detach();
+      return playing;
+    },
+    end
+  };
+  host.cache.setDetached(key, detached);
+  return detached;
+};
+//# sourceMappingURL=roundNotePlayers.js.map

package/lib/components/roundNotePlayers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundNotePlayers.js","names":["NOTE_PLAYER_GRACE_MS","releasePlayer","player","pause","release","createNotePlayerCache","graceMs","entries","Map","active","cancelTimer","entry","releaseTimer","clearTimeout","scheduleRelease","key","refs","isKept","setTimeout","get","delete","create","existing","detached","set","retain","Math","max","keep","setDetached","takeDetached","setActive","isActive","end","detachRoundNote","isPlaying","host","claimId","String","playing","isOver","unsubscribeRate","subscribeRate","rate","playbackRate","endSubscription","detach","remove","unclaim","cache","muted","currentTime","report","publish","toggle","getRate","play","claim","onStop","reason","stop","addListener","onEnded","adopt"],"sources":["../../src/components/roundNotePlayers.ts"],"sourcesContent":["/*\n * Round note players that outlive their rows.\n *\n * The list virtualizes: scroll far enough from a playing round note and its\n * row unmounts, which used to release its expo-video player and cut the note\n * off mid-sentence. It should keep playing and float in a corner\n * until its message is back on screen. So players live\n * here, keyed by message id: a row borrows its note's player while mounted,\n * and a note that is current when its row goes away is handed to a detached\n * session that keeps driving the same player - the floating note shows it and\n * the \"now playing\" bar keeps controlling it. When the row mounts again it\n * takes the session back and carries on from where the player is.\n */\n\n/** The subset of expo-video's `VideoPlayer` used here. */\nexport interface NotePlayer {\n  play: () => void\n  pause: () => void\n  release?: () => void\n  playing?: boolean\n  muted: boolean\n  loop: boolean\n  currentTime: number\n  playbackRate: number\n  duration?: number\n  /** `idle`, `loading`, `readyToPlay` or `error`. */\n  status?: string\n  /** Seconds buffered ahead. */\n  bufferedPosition?: number\n  addListener?: (event: string, listener: (payload?: any) => void) => { remove?: () => void } | undefined\n}\n\n/** A detached note, waiting for its row to come back or for playback to end. */\nexport interface DetachedRound {\n  /** The row is back: stop driving the player and say whether it was playing. */\n  adopt: () => boolean\n  /** End it: playback stops and the player can be released. */\n  end: () => void\n}\n\ninterface Entry {\n  player: NotePlayer\n  refs: number\n  /** Kept alive past its last row because the note is current. */\n  isKept: boolean\n  detached: DetachedRound | null\n  releaseTimer: ReturnType<typeof setTimeout> | null\n}\n\n/**\n * How long a player with no rows lingers before it is released. A row that\n * unmounts and mounts straight back (React's strict effects, a list re-render)\n * picks up the same player instead of creating a new one.\n */\nexport const NOTE_PLAYER_GRACE_MS = 500\n\nconst releasePlayer = (player: NotePlayer) => {\n  try {\n    player.pause()\n  } catch {\n    // already torn down\n  }\n  try {\n    player.release?.()\n  } catch {\n    // already torn down\n  }\n}\n\nexport interface NotePlayerCache {\n  /** The player for `key`, creating it on first use. Call during render. */\n  get: (key: string | number, create: () => NotePlayer) => NotePlayer\n  /** A mounted row holds the player. */\n  retain: (key: string | number) => void\n  /** The row unmounted. The player goes once no row holds it and it is not kept. */\n  release: (key: string | number) => void\n  /** Keep the player alive past its rows while the note is current. */\n  keep: (key: string | number, isKept: boolean) => void\n  setDetached: (key: string | number, detached: DetachedRound | null) => void\n  /** Hands a detached note back to its row, if there is one. */\n  takeDetached: (key: string | number) => DetachedRound | null\n  /**\n   * The chat mounts (`true`) or goes away (`false`). Going away ends every\n   * detached note and drops the players no row holds; rows unmounting with it\n   * then stop their notes instead of detaching them.\n   */\n  setActive: (isActive: boolean) => void\n  isActive: () => boolean\n}\n\nexport const createNotePlayerCache = (graceMs = NOTE_PLAYER_GRACE_MS): NotePlayerCache => {\n  const entries = new Map<string | number, Entry>()\n  let active = true\n\n  const cancelTimer = (entry: Entry) => {\n    if (entry.releaseTimer != null) {\n      clearTimeout(entry.releaseTimer)\n      entry.releaseTimer = null\n    }\n  }\n\n  const scheduleRelease = (key: string | number, entry: Entry) => {\n    cancelTimer(entry)\n    if (entry.refs > 0 || entry.isKept)\n      return\n\n    entry.releaseTimer = setTimeout(() => {\n      entry.releaseTimer = null\n      if (entry.refs > 0 || entry.isKept || entries.get(key) !== entry)\n        return\n\n      entries.delete(key)\n      releasePlayer(entry.player)\n    }, graceMs)\n  }\n\n  return {\n    get (key, create) {\n      const existing = entries.get(key)\n      if (existing)\n        return existing.player\n\n      const entry: Entry = { player: create(), refs: 0, isKept: false, detached: null, releaseTimer: null }\n      entries.set(key, entry)\n      // Created by a render that may never commit: release it unless a row\n      // retains it in time.\n      scheduleRelease(key, entry)\n      return entry.player\n    },\n    retain (key) {\n      const entry = entries.get(key)\n      if (!entry)\n        return\n\n      entry.refs += 1\n      cancelTimer(entry)\n    },\n    release (key) {\n      const entry = entries.get(key)\n      if (!entry)\n        return\n\n      entry.refs = Math.max(0, entry.refs - 1)\n      scheduleRelease(key, entry)\n    },\n    keep (key, isKept) {\n      const entry = entries.get(key)\n      if (!entry || entry.isKept === isKept)\n        return\n\n      entry.isKept = isKept\n      scheduleRelease(key, entry)\n    },\n    setDetached (key, detached) {\n      const entry = entries.get(key)\n      if (entry)\n        entry.detached = detached\n    },\n    takeDetached (key) {\n      const entry = entries.get(key)\n      const detached = entry?.detached ?? null\n      if (entry)\n        entry.detached = null\n      return detached\n    },\n    setActive (isActive) {\n      active = isActive\n      if (isActive)\n        return\n\n      for (const [key, entry] of [...entries]) {\n        const detached = entry.detached\n        entry.detached = null\n        try {\n          detached?.end()\n        } catch {\n          // keep tearing the rest down\n        }\n        entry.isKept = false\n        if (entry.refs === 0) {\n          cancelTimer(entry)\n          entries.delete(key)\n          releasePlayer(entry.player)\n        }\n      }\n    },\n    isActive () {\n      return active\n    },\n  }\n}\n\n/** What a detached note needs from the chat around it. */\nexport interface DetachedRoundHost {\n  cache: NotePlayerCache\n  claim: (id: string, stop: (reason: 'replaced' | 'paused') => void) => void\n  unclaim: (id: string) => void\n  getRate: () => number\n  subscribeRate: (listener: (rate: number) => void) => () => void\n  /** Publish the note's state, or `null` once it is over. */\n  report: (state: { isPlaying: boolean, toggle: () => void, stop: () => void } | null) => void\n  /** It reached its end on its own: auto-play the next note. */\n  onEnded: () => void\n}\n\n/**\n * Keeps a current round note going after its row unmounted. The player stays\n * as the row left it, playing or paused; this answers the \"now playing\" bar\n * and the floating note, stops when another note starts, and on the note's\n * natural end resets the player and hands over to the next note, as the row\n * would have.\n */\nexport const detachRoundNote = (\n  key: string | number,\n  player: NotePlayer,\n  isPlaying: boolean,\n  host: DetachedRoundHost\n): DetachedRound => {\n  const claimId = `detached-round:${String(key)}`\n  let playing = isPlaying\n  let isOver = false\n\n  // Only while playing: on iOS a rate set on a paused player starts it.\n  const unsubscribeRate = host.subscribeRate(rate => {\n    if (!playing)\n      return\n\n    try {\n      player.playbackRate = rate\n    } catch {\n      // already torn down\n    }\n  })\n  let endSubscription: { remove?: () => void } | undefined\n\n  const detach = () => {\n    isOver = true\n    endSubscription?.remove?.()\n    unsubscribeRate()\n    host.unclaim(claimId)\n    host.cache.setDetached(key, null)\n  }\n\n  const end = () => {\n    if (isOver)\n      return\n\n    detach()\n    // Back to rest, so a row that mounts later shows the first frame.\n    // The rate first: set after the pause, it would start the player again.\n    try {\n      player.playbackRate = 1\n      player.pause()\n      player.muted = true\n      player.currentTime = 0\n    } catch {\n      // already torn down\n    }\n    host.report(null)\n    host.cache.keep(key, false)\n  }\n\n  const pause = () => {\n    try {\n      player.pause()\n    } catch {\n      // already torn down\n    }\n    playing = false\n    publish()\n  }\n\n  const toggle = () => {\n    if (isOver)\n      return\n\n    if (playing) {\n      pause()\n      return\n    }\n\n    try {\n      player.playbackRate = host.getRate()\n      player.play()\n    } catch {\n      return\n    }\n    playing = true\n    host.claim(claimId, onStop)\n    publish()\n  }\n\n  // Another note starting ends this one (`cleanupPlayer`); a recording only\n  // pauses it, and it stays current.\n  const onStop = (reason: 'replaced' | 'paused') => {\n    if (reason === 'replaced')\n      end()\n    else\n      pause()\n  }\n\n  const publish = () => {\n    if (!isOver)\n      host.report({ isPlaying: playing, toggle, stop: end })\n  }\n\n  endSubscription = player.addListener?.('playToEnd', () => {\n    if (isOver)\n      return\n\n    end()\n    host.onEnded()\n  })\n\n  // A paused note keeps its claim too, so a later note still ends it.\n  host.claim(claimId, onStop)\n  publish()\n\n  const detached: DetachedRound = {\n    adopt () {\n      if (!isOver)\n        detach()\n      return playing\n    },\n    end,\n  }\n  host.cache.setDetached(key, detached)\n  return detached\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAkBA;;AAiBA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,oBAAoB,GAAG,GAAG;AAEvC,MAAMC,aAAa,GAAIC,MAAkB,IAAK;EAC5C,IAAI;IACFA,MAAM,CAACC,KAAK,CAAC,CAAC;EAChB,CAAC,CAAC,MAAM;IACN;EAAA;EAEF,IAAI;IACFD,MAAM,CAACE,OAAO,GAAG,CAAC;EACpB,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ,CAAC;AAuBD,OAAO,MAAMC,qBAAqB,GAAGA,CAACC,OAAO,GAAGN,oBAAoB,KAAsB;EACxF,MAAMO,OAAO,GAAG,IAAIC,GAAG,CAAyB,CAAC;EACjD,IAAIC,MAAM,GAAG,IAAI;EAEjB,MAAMC,WAAW,GAAIC,KAAY,IAAK;IACpC,IAAIA,KAAK,CAACC,YAAY,IAAI,IAAI,EAAE;MAC9BC,YAAY,CAACF,KAAK,CAACC,YAAY,CAAC;MAChCD,KAAK,CAACC,YAAY,GAAG,IAAI;IAC3B;EACF,CAAC;EAED,MAAME,eAAe,GAAGA,CAACC,GAAoB,EAAEJ,KAAY,KAAK;IAC9DD,WAAW,CAACC,KAAK,CAAC;IAClB,IAAIA,KAAK,CAACK,IAAI,GAAG,CAAC,IAAIL,KAAK,CAACM,MAAM,EAChC;IAEFN,KAAK,CAACC,YAAY,GAAGM,UAAU,CAAC,MAAM;MACpCP,KAAK,CAACC,YAAY,GAAG,IAAI;MACzB,IAAID,KAAK,CAACK,IAAI,GAAG,CAAC,IAAIL,KAAK,CAACM,MAAM,IAAIV,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC,KAAKJ,KAAK,EAC9D;MAEFJ,OAAO,CAACa,MAAM,CAACL,GAAG,CAAC;MACnBd,aAAa,CAACU,KAAK,CAACT,MAAM,CAAC;IAC7B,CAAC,EAAEI,OAAO,CAAC;EACb,CAAC;EAED,OAAO;IACLa,GAAGA,CAAEJ,GAAG,EAAEM,MAAM,EAAE;MAChB,MAAMC,QAAQ,GAAGf,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC;MACjC,IAAIO,QAAQ,EACV,OAAOA,QAAQ,CAACpB,MAAM;MAExB,MAAMS,KAAY,GAAG;QAAET,MAAM,EAAEmB,MAAM,CAAC,CAAC;QAAEL,IAAI,EAAE,CAAC;QAAEC,MAAM,EAAE,KAAK;QAAEM,QAAQ,EAAE,IAAI;QAAEX,YAAY,EAAE;MAAK,CAAC;MACrGL,OAAO,CAACiB,GAAG,CAACT,GAAG,EAAEJ,KAAK,CAAC;MACvB;MACA;MACAG,eAAe,CAACC,GAAG,EAAEJ,KAAK,CAAC;MAC3B,OAAOA,KAAK,CAACT,MAAM;IACrB,CAAC;IACDuB,MAAMA,CAAEV,GAAG,EAAE;MACX,MAAMJ,KAAK,GAAGJ,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC;MAC9B,IAAI,CAACJ,KAAK,EACR;MAEFA,KAAK,CAACK,IAAI,IAAI,CAAC;MACfN,WAAW,CAACC,KAAK,CAAC;IACpB,CAAC;IACDP,OAAOA,CAAEW,GAAG,EAAE;MACZ,MAAMJ,KAAK,GAAGJ,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC;MAC9B,IAAI,CAACJ,KAAK,EACR;MAEFA,KAAK,CAACK,IAAI,GAAGU,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEhB,KAAK,CAACK,IAAI,GAAG,CAAC,CAAC;MACxCF,eAAe,CAACC,GAAG,EAAEJ,KAAK,CAAC;IAC7B,CAAC;IACDiB,IAAIA,CAAEb,GAAG,EAAEE,MAAM,EAAE;MACjB,MAAMN,KAAK,GAAGJ,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC;MAC9B,IAAI,CAACJ,KAAK,IAAIA,KAAK,CAACM,MAAM,KAAKA,MAAM,EACnC;MAEFN,KAAK,CAACM,MAAM,GAAGA,MAAM;MACrBH,eAAe,CAACC,GAAG,EAAEJ,KAAK,CAAC;IAC7B,CAAC;IACDkB,WAAWA,CAAEd,GAAG,EAAEQ,QAAQ,EAAE;MAC1B,MAAMZ,KAAK,GAAGJ,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC;MAC9B,IAAIJ,KAAK,EACPA,KAAK,CAACY,QAAQ,GAAGA,QAAQ;IAC7B,CAAC;IACDO,YAAYA,CAAEf,GAAG,EAAE;MACjB,MAAMJ,KAAK,GAAGJ,OAAO,CAACY,GAAG,CAACJ,GAAG,CAAC;MAC9B,MAAMQ,QAAQ,GAAGZ,KAAK,EAAEY,QAAQ,IAAI,IAAI;MACxC,IAAIZ,KAAK,EACPA,KAAK,CAACY,QAAQ,GAAG,IAAI;MACvB,OAAOA,QAAQ;IACjB,CAAC;IACDQ,SAASA,CAAEC,QAAQ,EAAE;MACnBvB,MAAM,GAAGuB,QAAQ;MACjB,IAAIA,QAAQ,EACV;MAEF,KAAK,MAAM,CAACjB,GAAG,EAAEJ,KAAK,CAAC,IAAI,CAAC,GAAGJ,OAAO,CAAC,EAAE;QACvC,MAAMgB,QAAQ,GAAGZ,KAAK,CAACY,QAAQ;QAC/BZ,KAAK,CAACY,QAAQ,GAAG,IAAI;QACrB,IAAI;UACFA,QAAQ,EAAEU,GAAG,CAAC,CAAC;QACjB,CAAC,CAAC,MAAM;UACN;QAAA;QAEFtB,KAAK,CAACM,MAAM,GAAG,KAAK;QACpB,IAAIN,KAAK,CAACK,IAAI,KAAK,CAAC,EAAE;UACpBN,WAAW,CAACC,KAAK,CAAC;UAClBJ,OAAO,CAACa,MAAM,CAACL,GAAG,CAAC;UACnBd,aAAa,CAACU,KAAK,CAACT,MAAM,CAAC;QAC7B;MACF;IACF,CAAC;IACD8B,QAAQA,CAAA,EAAI;MACV,OAAOvB,MAAM;IACf;EACF,CAAC;AACH,CAAC;;AAED;;AAaA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMyB,eAAe,GAAGA,CAC7BnB,GAAoB,EACpBb,MAAkB,EAClBiC,SAAkB,EAClBC,IAAuB,KACL;EAClB,MAAMC,OAAO,GAAG,kBAAkBC,MAAM,CAACvB,GAAG,CAAC,EAAE;EAC/C,IAAIwB,OAAO,GAAGJ,SAAS;EACvB,IAAIK,MAAM,GAAG,KAAK;;EAElB;EACA,MAAMC,eAAe,GAAGL,IAAI,CAACM,aAAa,CAACC,IAAI,IAAI;IACjD,IAAI,CAACJ,OAAO,EACV;IAEF,IAAI;MACFrC,MAAM,CAAC0C,YAAY,GAAGD,IAAI;IAC5B,CAAC,CAAC,MAAM;MACN;IAAA;EAEJ,CAAC,CAAC;EACF,IAAIE,eAAoD;EAExD,MAAMC,MAAM,GAAGA,CAAA,KAAM;IACnBN,MAAM,GAAG,IAAI;IACbK,eAAe,EAAEE,MAAM,GAAG,CAAC;IAC3BN,eAAe,CAAC,CAAC;IACjBL,IAAI,CAACY,OAAO,CAACX,OAAO,CAAC;IACrBD,IAAI,CAACa,KAAK,CAACpB,WAAW,CAACd,GAAG,EAAE,IAAI,CAAC;EACnC,CAAC;EAED,MAAMkB,GAAG,GAAGA,CAAA,KAAM;IAChB,IAAIO,MAAM,EACR;IAEFM,MAAM,CAAC,CAAC;IACR;IACA;IACA,IAAI;MACF5C,MAAM,CAAC0C,YAAY,GAAG,CAAC;MACvB1C,MAAM,CAACC,KAAK,CAAC,CAAC;MACdD,MAAM,CAACgD,KAAK,GAAG,IAAI;MACnBhD,MAAM,CAACiD,WAAW,GAAG,CAAC;IACxB,CAAC,CAAC,MAAM;MACN;IAAA;IAEFf,IAAI,CAACgB,MAAM,CAAC,IAAI,CAAC;IACjBhB,IAAI,CAACa,KAAK,CAACrB,IAAI,CAACb,GAAG,EAAE,KAAK,CAAC;EAC7B,CAAC;EAED,MAAMZ,KAAK,GAAGA,CAAA,KAAM;IAClB,IAAI;MACFD,MAAM,CAACC,KAAK,CAAC,CAAC;IAChB,CAAC,CAAC,MAAM;MACN;IAAA;IAEFoC,OAAO,GAAG,KAAK;IACfc,OAAO,CAAC,CAAC;EACX,CAAC;EAED,MAAMC,MAAM,GAAGA,CAAA,KAAM;IACnB,IAAId,MAAM,EACR;IAEF,IAAID,OAAO,EAAE;MACXpC,KAAK,CAAC,CAAC;MACP;IACF;IAEA,IAAI;MACFD,MAAM,CAAC0C,YAAY,GAAGR,IAAI,CAACmB,OAAO,CAAC,CAAC;MACpCrD,MAAM,CAACsD,IAAI,CAAC,CAAC;IACf,CAAC,CAAC,MAAM;MACN;IACF;IACAjB,OAAO,GAAG,IAAI;IACdH,IAAI,CAACqB,KAAK,CAACpB,OAAO,EAAEqB,MAAM,CAAC;IAC3BL,OAAO,CAAC,CAAC;EACX,CAAC;;EAED;EACA;EACA,MAAMK,MAAM,GAAIC,MAA6B,IAAK;IAChD,IAAIA,MAAM,KAAK,UAAU,EACvB1B,GAAG,CAAC,CAAC,MAEL9B,KAAK,CAAC,CAAC;EACX,CAAC;EAED,MAAMkD,OAAO,GAAGA,CAAA,KAAM;IACpB,IAAI,CAACb,MAAM,EACTJ,IAAI,CAACgB,MAAM,CAAC;MAAEjB,SAAS,EAAEI,OAAO;MAAEe,MAAM;MAAEM,IAAI,EAAE3B;IAAI,CAAC,CAAC;EAC1D,CAAC;EAEDY,eAAe,GAAG3C,MAAM,CAAC2D,WAAW,GAAG,WAAW,EAAE,MAAM;IACxD,IAAIrB,MAAM,EACR;IAEFP,GAAG,CAAC,CAAC;IACLG,IAAI,CAAC0B,OAAO,CAAC,CAAC;EAChB,CAAC,CAAC;;EAEF;EACA1B,IAAI,CAACqB,KAAK,CAACpB,OAAO,EAAEqB,MAAM,CAAC;EAC3BL,OAAO,CAAC,CAAC;EAET,MAAM9B,QAAuB,GAAG;IAC9BwC,KAAKA,CAAA,EAAI;MACP,IAAI,CAACvB,MAAM,EACTM,MAAM,CAAC,CAAC;MACV,OAAOP,OAAO;IAChB,CAAC;IACDN;EACF,CAAC;EACDG,IAAI,CAACa,KAAK,CAACpB,WAAW,CAACd,GAAG,EAAEQ,QAAQ,CAAC;EACrC,OAAOA,QAAQ;AACjB,CAAC","ignoreList":[]}

package/lib/components/sendFlight.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The send flights, for a voice note and a round one: the take's
+ * circle in the composer flies into the message that has just been sent, and
+ * that message's own button / note stays hidden until it lands.
+ *
+ * The composer and the message list never meet, so this tiny store hands the
+ * landing spot from one to the other. The source (the record button, the
+ * camera circle) expects a flight when it sends; the just-sent message lands
+ * with its target in window coordinates; the source flies there and reports
+ * back when it has arrived.
+ */
+export type SendFlightKind = 'voice' | 'round';
+/** A voice note's play button: its centre, radius and fill. */
+export interface VoiceFlightTarget {
+    x: number;
+    y: number;
+    radius: number;
+    color: string;
+    /** The play glyph's colour, so the flight can draw it in as it lands. */
+    iconColor?: string;
+}
+/** A round note in the list: its top-left corner and diameter. */
+export interface RoundFlightTarget {
+    x: number;
+    y: number;
+    size: number;
+}
+interface TargetFor {
+    voice: VoiceFlightTarget;
+    round: RoundFlightTarget;
+}
+/**
+ * A message counts as the flight's target only this soon after the send:
+ * the take still has to be written and the list has to lay the row out.
+ */
+export declare const SEND_FLIGHT_EXPECT_MS = 1500;
+/** The source waits this long for a target before playing its own exit. */
+export declare const SEND_FLIGHT_WAIT_MS = 500;
+/**
+ * A landed target shows itself anyway after this long, in case the source
+ * went away mid-flight without reporting back.
+ */
+export declare const SEND_FLIGHT_SAFETY_MS = 1500;
+/** `VoiceMessageEnterTransition`: 220ms of linear progress. */
+export declare const VOICE_FLIGHT_MS = 220;
+/** The record circle's blobs are gone by 60% of it (`step1Time`). */
+export declare const VOICE_FLIGHT_BLOB_SHARE = 0.6;
+/** The round note flight: 300ms, then a 100ms crossfade. */
+export declare const ROUND_FLIGHT_MS = 300;
+export declare const ROUND_FLIGHT_FADE_MS = 100;
+/** The landed button fades in under the flight's disc, which then goes. */
+export declare const SEND_FLIGHT_REVEAL_MS = 120;
+type Listener<T> = (value: T) => void;
+/** The source has sent a take and will fly its circle into the new message. */
+export declare function expectSendFlight(kind: SendFlightKind, now?: number): void;
+/**
+ * A flight is on its way and nothing has landed yet, so a just-sent message
+ * can start hidden instead of flashing for the frame its measure takes.
+ */
+export declare function isSendFlightExpected(kind: SendFlightKind, now?: number): boolean;
+/**
+ * A just-sent message offers itself as the flight's target. Returns true when
+ * a flight was expected: the caller then hides its button / note until
+ * `onSendFlightFinished` fires. Only the first message to land is taken.
+ */
+export declare function landSendFlight<K extends SendFlightKind>(kind: K, target: TargetFor[K], now?: number): boolean;
+/**
+ * The source listens for its target. Fires at once when one has already
+ * landed (the row can lay out before the source subscribes).
+ */
+export declare function onSendFlightTarget<K extends SendFlightKind>(kind: K, listener: Listener<TargetFor[K]>): () => void;
+/**
+ * The source gave up waiting and plays its own exit, so a message landing
+ * late is not hidden for a flight that will never come.
+ */
+export declare function abandonSendFlight(kind: SendFlightKind): void;
+/** The flight has arrived: the target shows its own button / note again. */
+export declare function finishSendFlight(kind: SendFlightKind): void;
+/** The target listens for the flight's arrival. */
+export declare function onSendFlightFinished(kind: SendFlightKind, listener: () => void): () => void;
+/** Test-only: forget every flight and listener. */
+export declare function resetSendFlights(): void;
+/** The default cubic bezier (0.25, 0.1, 0.25, 1). */
+export declare const easeDefault: (t: number) => number;
+/** Ease-out quint (0.23, 1, 0.32, 1). */
+export declare const easeOutQuint: (t: number) => number;
+export {};
+//# sourceMappingURL=sendFlight.d.ts.map

package/lib/components/sendFlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendFlight.d.ts","sourceRoot":"","sources":["../../src/components/sendFlight.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,CAAA;AAE9C,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,IAAI,EAAE,MAAM,CAAA;CACb;AAED,UAAU,SAAS;IACjB,KAAK,EAAE,iBAAiB,CAAA;IACxB,KAAK,EAAE,iBAAiB,CAAA;CACzB;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAA;AACzC,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,MAAM,CAAA;AACtC;;;GAGG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,MAAM,CAAA;AAClC,qEAAqE;AACrE,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAC1C,4DAA4D;AAC5D,eAAO,MAAM,eAAe,MAAM,CAAA;AAClC,eAAO,MAAM,oBAAoB,MAAM,CAAA;AACvC,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;AAsBrC,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAE,IAAI,EAAE,cAAc,EAAE,GAAG,SAAa,QAIvE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,GAAG,SAAa,WAG3E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,cAAc,EAAG,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,SAAa,WAQxG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EAAG,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAQtG;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAE,IAAI,EAAE,cAAc,QAItD;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAE,IAAI,EAAE,cAAc,QAOrD;AAED,mDAAmD;AACnD,wBAAgB,oBAAoB,CAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,IAAI,cAM/E;AAED,mDAAmD;AACnD,wBAAgB,gBAAgB,SAQ/B;AAYD,qDAAqD;AACrD,eAAO,MAAM,WAAW,MAPR,MAAM,KAAK,MAO+C,CAAA;AAC1E,yCAAyC;AACzC,eAAO,MAAM,YAAY,MATT,MAAM,KAAK,MAS8C,CAAA"}

package/lib/components/sendFlight.js

@@ -0,0 +1,146 @@
+import { Easing } from 'react-native-reanimated';
+
+/**
+ * The send flights, for a voice note and a round one: the take's
+ * circle in the composer flies into the message that has just been sent, and
+ * that message's own button / note stays hidden until it lands.
+ *
+ * The composer and the message list never meet, so this tiny store hands the
+ * landing spot from one to the other. The source (the record button, the
+ * camera circle) expects a flight when it sends; the just-sent message lands
+ * with its target in window coordinates; the source flies there and reports
+ * back when it has arrived.
+ */
+
+/** A voice note's play button: its centre, radius and fill. */
+
+/** A round note in the list: its top-left corner and diameter. */
+
+/**
+ * A message counts as the flight's target only this soon after the send:
+ * the take still has to be written and the list has to lay the row out.
+ */
+export const SEND_FLIGHT_EXPECT_MS = 1500;
+/** The source waits this long for a target before playing its own exit. */
+export const SEND_FLIGHT_WAIT_MS = 500;
+/**
+ * A landed target shows itself anyway after this long, in case the source
+ * went away mid-flight without reporting back.
+ */
+export const SEND_FLIGHT_SAFETY_MS = 1500;
+
+/** `VoiceMessageEnterTransition`: 220ms of linear progress. */
+export const VOICE_FLIGHT_MS = 220;
+/** The record circle's blobs are gone by 60% of it (`step1Time`). */
+export const VOICE_FLIGHT_BLOB_SHARE = 0.6;
+/** The round note flight: 300ms, then a 100ms crossfade. */
+export const ROUND_FLIGHT_MS = 300;
+export const ROUND_FLIGHT_FADE_MS = 100;
+/** The landed button fades in under the flight's disc, which then goes. */
+export const SEND_FLIGHT_REVEAL_MS = 120;
+const createSlot = () => ({
+  expectedAt: null,
+  target: null,
+  targetListeners: new Set(),
+  finishedListeners: new Set()
+});
+const slots = {
+  voice: createSlot(),
+  round: createSlot()
+};
+
+/** The source has sent a take and will fly its circle into the new message. */
+export function expectSendFlight(kind, now = Date.now()) {
+  const slot = slots[kind];
+  slot.expectedAt = now;
+  slot.target = null;
+}
+
+/**
+ * A flight is on its way and nothing has landed yet, so a just-sent message
+ * can start hidden instead of flashing for the frame its measure takes.
+ */
+export function isSendFlightExpected(kind, now = Date.now()) {
+  const slot = slots[kind];
+  return slot.expectedAt != null && !slot.target && now - slot.expectedAt <= SEND_FLIGHT_EXPECT_MS;
+}
+
+/**
+ * A just-sent message offers itself as the flight's target. Returns true when
+ * a flight was expected: the caller then hides its button / note until
+ * `onSendFlightFinished` fires. Only the first message to land is taken.
+ */
+export function landSendFlight(kind, target, now = Date.now()) {
+  const slot = slots[kind];
+  if (slot.expectedAt == null || slot.target || now - slot.expectedAt > SEND_FLIGHT_EXPECT_MS) return false;
+  slot.target = target;
+  slot.targetListeners.forEach(listener => listener(target));
+  return true;
+}
+
+/**
+ * The source listens for its target. Fires at once when one has already
+ * landed (the row can lay out before the source subscribes).
+ */
+export function onSendFlightTarget(kind, listener) {
+  const slot = slots[kind];
+  slot.targetListeners.add(listener);
+  if (slot.target) listener(slot.target);
+  return () => {
+    slot.targetListeners.delete(listener);
+  };
+}
+
+/**
+ * The source gave up waiting and plays its own exit, so a message landing
+ * late is not hidden for a flight that will never come.
+ */
+export function abandonSendFlight(kind) {
+  const slot = slots[kind];
+  slot.expectedAt = null;
+  slot.target = null;
+}
+
+/** The flight has arrived: the target shows its own button / note again. */
+export function finishSendFlight(kind) {
+  const slot = slots[kind];
+  slot.expectedAt = null;
+  slot.target = null;
+  const listeners = Array.from(slot.finishedListeners);
+  slot.finishedListeners.clear();
+  listeners.forEach(listener => listener());
+}
+
+/** The target listens for the flight's arrival. */
+export function onSendFlightFinished(kind, listener) {
+  const slot = slots[kind];
+  slot.finishedListeners.add(listener);
+  return () => {
+    slot.finishedListeners.delete(listener);
+  };
+}
+
+/** Test-only: forget every flight and listener. */
+export function resetSendFlights() {
+  Object.keys(slots).forEach(kind => {
+    const slot = slots[kind];
+    slot.expectedAt = null;
+    slot.target = null;
+    slot.targetListeners.clear();
+    slot.finishedListeners.clear();
+  });
+}
+
+// Reanimated's Jest mock returns a non-function from `bezierFn`, hence the
+// linear stand-ins.
+const bezierOr = fn => typeof fn === 'function' ? fn : t => {
+  'worklet';
+
+  return t;
+};
+
+/** The default cubic bezier (0.25, 0.1, 0.25, 1). */
+export const easeDefault = bezierOr(Easing.bezierFn?.(0.25, 0.1, 0.25, 1));
+/** Ease-out quint (0.23, 1, 0.32, 1). */
+export const easeOutQuint = bezierOr(Easing.bezierFn?.(0.23, 1, 0.32, 1));
+//# sourceMappingURL=sendFlight.js.map

package/lib/components/sendFlight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendFlight.js","names":["Easing","SEND_FLIGHT_EXPECT_MS","SEND_FLIGHT_WAIT_MS","SEND_FLIGHT_SAFETY_MS","VOICE_FLIGHT_MS","VOICE_FLIGHT_BLOB_SHARE","ROUND_FLIGHT_MS","ROUND_FLIGHT_FADE_MS","SEND_FLIGHT_REVEAL_MS","createSlot","expectedAt","target","targetListeners","Set","finishedListeners","slots","voice","round","expectSendFlight","kind","now","Date","slot","isSendFlightExpected","landSendFlight","forEach","listener","onSendFlightTarget","add","delete","abandonSendFlight","finishSendFlight","listeners","Array","from","clear","onSendFlightFinished","resetSendFlights","Object","keys","bezierOr","fn","t","easeDefault","bezierFn","easeOutQuint"],"sources":["../../src/components/sendFlight.ts"],"sourcesContent":["import { Easing } from 'react-native-reanimated'\n\n/**\n * The send flights, for a voice note and a round one: the take's\n * circle in the composer flies into the message that has just been sent, and\n * that message's own button / note stays hidden until it lands.\n *\n * The composer and the message list never meet, so this tiny store hands the\n * landing spot from one to the other. The source (the record button, the\n * camera circle) expects a flight when it sends; the just-sent message lands\n * with its target in window coordinates; the source flies there and reports\n * back when it has arrived.\n */\n\nexport type SendFlightKind = 'voice' | 'round'\n\n/** A voice note's play button: its centre, radius and fill. */\nexport interface VoiceFlightTarget {\n  x: number\n  y: number\n  radius: number\n  color: string\n  /** The play glyph's colour, so the flight can draw it in as it lands. */\n  iconColor?: string\n}\n\n/** A round note in the list: its top-left corner and diameter. */\nexport interface RoundFlightTarget {\n  x: number\n  y: number\n  size: number\n}\n\ninterface TargetFor {\n  voice: VoiceFlightTarget\n  round: RoundFlightTarget\n}\n\n/**\n * A message counts as the flight's target only this soon after the send:\n * the take still has to be written and the list has to lay the row out.\n */\nexport const SEND_FLIGHT_EXPECT_MS = 1500\n/** The source waits this long for a target before playing its own exit. */\nexport const SEND_FLIGHT_WAIT_MS = 500\n/**\n * A landed target shows itself anyway after this long, in case the source\n * went away mid-flight without reporting back.\n */\nexport const SEND_FLIGHT_SAFETY_MS = 1500\n\n/** `VoiceMessageEnterTransition`: 220ms of linear progress. */\nexport const VOICE_FLIGHT_MS = 220\n/** The record circle's blobs are gone by 60% of it (`step1Time`). */\nexport const VOICE_FLIGHT_BLOB_SHARE = 0.6\n/** The round note flight: 300ms, then a 100ms crossfade. */\nexport const ROUND_FLIGHT_MS = 300\nexport const ROUND_FLIGHT_FADE_MS = 100\n/** The landed button fades in under the flight's disc, which then goes. */\nexport const SEND_FLIGHT_REVEAL_MS = 120\n\ntype Listener<T> = (value: T) => void\n\ninterface Slot<K extends SendFlightKind> {\n  /** When the take was sent; null while no flight is expected. */\n  expectedAt: number | null\n  target: TargetFor[K] | null\n  targetListeners: Set<Listener<TargetFor[K]>>\n  finishedListeners: Set<() => void>\n}\n\nconst createSlot = <K extends SendFlightKind>(): Slot<K> => ({\n  expectedAt: null,\n  target: null,\n  targetListeners: new Set(),\n  finishedListeners: new Set(),\n})\n\nconst slots: { [K in SendFlightKind]: Slot<K> } = {\n  voice: createSlot<'voice'>(),\n  round: createSlot<'round'>(),\n}\n\n/** The source has sent a take and will fly its circle into the new message. */\nexport function expectSendFlight (kind: SendFlightKind, now = Date.now()) {\n  const slot = slots[kind]\n  slot.expectedAt = now\n  slot.target = null\n}\n\n/**\n * A flight is on its way and nothing has landed yet, so a just-sent message\n * can start hidden instead of flashing for the frame its measure takes.\n */\nexport function isSendFlightExpected (kind: SendFlightKind, now = Date.now()) {\n  const slot = slots[kind]\n  return slot.expectedAt != null && !slot.target && now - slot.expectedAt <= SEND_FLIGHT_EXPECT_MS\n}\n\n/**\n * A just-sent message offers itself as the flight's target. Returns true when\n * a flight was expected: the caller then hides its button / note until\n * `onSendFlightFinished` fires. Only the first message to land is taken.\n */\nexport function landSendFlight<K extends SendFlightKind> (kind: K, target: TargetFor[K], now = Date.now()) {\n  const slot = slots[kind] as unknown as Slot<K>\n  if (slot.expectedAt == null || slot.target || now - slot.expectedAt > SEND_FLIGHT_EXPECT_MS)\n    return false\n\n  slot.target = target\n  slot.targetListeners.forEach(listener => listener(target))\n  return true\n}\n\n/**\n * The source listens for its target. Fires at once when one has already\n * landed (the row can lay out before the source subscribes).\n */\nexport function onSendFlightTarget<K extends SendFlightKind> (kind: K, listener: Listener<TargetFor[K]>) {\n  const slot = slots[kind] as unknown as Slot<K>\n  slot.targetListeners.add(listener)\n  if (slot.target)\n    listener(slot.target)\n  return () => {\n    slot.targetListeners.delete(listener)\n  }\n}\n\n/**\n * The source gave up waiting and plays its own exit, so a message landing\n * late is not hidden for a flight that will never come.\n */\nexport function abandonSendFlight (kind: SendFlightKind) {\n  const slot = slots[kind]\n  slot.expectedAt = null\n  slot.target = null\n}\n\n/** The flight has arrived: the target shows its own button / note again. */\nexport function finishSendFlight (kind: SendFlightKind) {\n  const slot = slots[kind]\n  slot.expectedAt = null\n  slot.target = null\n  const listeners = Array.from(slot.finishedListeners)\n  slot.finishedListeners.clear()\n  listeners.forEach(listener => listener())\n}\n\n/** The target listens for the flight's arrival. */\nexport function onSendFlightFinished (kind: SendFlightKind, listener: () => void) {\n  const slot = slots[kind]\n  slot.finishedListeners.add(listener)\n  return () => {\n    slot.finishedListeners.delete(listener)\n  }\n}\n\n/** Test-only: forget every flight and listener. */\nexport function resetSendFlights () {\n  (Object.keys(slots) as SendFlightKind[]).forEach(kind => {\n    const slot = slots[kind]\n    slot.expectedAt = null\n    slot.target = null\n    slot.targetListeners.clear()\n    slot.finishedListeners.clear()\n  })\n}\n\n// Reanimated's Jest mock returns a non-function from `bezierFn`, hence the\n// linear stand-ins.\nconst bezierOr = (fn: unknown) =>\n  typeof fn === 'function'\n    ? fn as (t: number) => number\n    : (t: number) => {\n      'worklet'\n      return t\n    }\n\n/** The default cubic bezier (0.25, 0.1, 0.25, 1). */\nexport const easeDefault = bezierOr(Easing.bezierFn?.(0.25, 0.1, 0.25, 1))\n/** Ease-out quint (0.23, 1, 0.32, 1). */\nexport const easeOutQuint = bezierOr(Easing.bezierFn?.(0.23, 1, 0.32, 1))\n"],"mappings":"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","ignoreList":[]}

package/lib/components/viewOnce.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A view-once note plays a single time. Once it has
+ * started, finishing it - at its end, or by being stopped - spends it, and the
+ * app is told exactly once so it can remove the message. A pause does not
+ * spend it: the note is still being listened to.
+ */
+export interface ViewOnceTracker {
+    /** Playback started. Returns false for a spent note, which must not play. */
+    start: () => boolean;
+    /** The note ended or was stopped; spends it if it had started. */
+    end: () => boolean;
+    hasStarted: () => boolean;
+    isSpent: () => boolean;
+}
+export declare const createViewOnceTracker: (isViewOnce: boolean, onEnd: () => void) => ViewOnceTracker;
+/**
+ * View-once state for one player. `onStart` gates playback; `onEnd` spends the
+ * note. A note that started and then unmounts (scrolled away, chat closed)
+ * counts as ended too, as closing a view-once player does.
+ */
+export declare const useViewOnce: <TMessage>(message: TMessage | undefined, messageId: string | number | undefined, isViewOnce: boolean, onViewOnceEnd: ((message: TMessage) => void) | undefined) => {
+    hasStarted: boolean;
+    isSpent: boolean;
+    onStart: () => boolean;
+    onEnd: () => void;
+};
+//# sourceMappingURL=viewOnce.d.ts.map

package/lib/components/viewOnce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewOnce.d.ts","sourceRoot":"","sources":["../../src/components/viewOnce.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,KAAK,EAAE,MAAM,OAAO,CAAA;IACpB,kEAAkE;IAClE,GAAG,EAAE,MAAM,OAAO,CAAA;IAClB,UAAU,EAAE,MAAM,OAAO,CAAA;IACzB,OAAO,EAAE,MAAM,OAAO,CAAA;CACvB;AAID,eAAO,MAAM,qBAAqB,GAAI,YAAY,OAAO,EAAE,OAAO,MAAM,IAAI,KAAG,eAsB9E,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,EAClC,SAAS,QAAQ,GAAG,SAAS,EAC7B,WAAW,MAAM,GAAG,MAAM,GAAG,SAAS,EACtC,YAAY,OAAO,EACnB,eAAe,CAAC,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,CAAC,GAAG,SAAS;;;;;CA+CzD,CAAA"}