@unif/react-native-design 0.24.0 → 0.25.0

package/src/components/ui/Toast/store.ts

@@ -17,6 +17,18 @@ import type { ToastEntry } from './types';
  *
  * `leaseId` 单调递增,同一 entry 被重新投递(Host 重挂)也会拿到新的 leaseId ——
  * 仅比较 entry.id 不足以区分「同一条消息的两次投递」。
+ *
+ * **栈式 owner**(与 Confirm 同构):后挂载的 Host 接管投递,前任入栈挂起并收到 clear,
+ * 接管者卸载后自动归还。RN `Modal` 是独立 native window,根 Host 渲染的 toast 会被
+ * Modal 物理盖住,只有「Modal 内自挂一个 Host」能显示 —— 旧的 first-wins 把这条唯一
+ * 正解判成恒惰性死码。
+ *
+ * 两个方向对在途 toast 的处理**刻意不同**:
+ * - **接管**(有人挂到我上面)→ 在途 toast **丢弃**。它属于「已经被盖住的过去」,
+ *   搬到接管者身上重放没有意义。
+ * - **归还**(接管者卸载、我恢复)→ 在途 toast **整条交回、立即重投**。
+ *   「Modal 内操作成功 → toast → 关窗」是最常见的一条路径,那条 toast 刚发出、用户
+ *   一眼都还没看到;丢掉的话比不挂内层 Host 还糟。不追剩余时长,重投 = 完整重播一遍。
  */
 
 export type ToastDelivery = {
@@ -27,27 +39,49 @@ export type ToastDelivery = {
 
 export type ToastSubscriber = (delivery: ToastDelivery) => void;
 
+/**
+ * owner 被接管 / 归还时的撤回通知 —— 对应 Confirm 的 `clear` 事件。
+ *
+ * 没有它,挂起中的 Host 会把最后一条 toast **冻在屏幕上**:store 已丢弃那次投递,
+ * Host 自己的退场 timer 过不了 `isCurrent` CAS,永远走不到清 UI 那一步。
+ */
+export type ToastClearSubscriber = () => void;
+
 export type ToastHostLease = {
   readonly ownerToken: symbol;
+  /** Host 卸载。幂等:重复调用、或本 owner 已被摘掉,都是无副作用的 no-op。 */
   release(): void;
 };
 
 export type ToastStore = {
   publish(entry: ToastEntry): void;
-  registerHost(subscriber: ToastSubscriber): ToastHostLease | null;
+  /**
+   * 挂载 Host。已有 owner 时走接管(不再拒绝);返回 `null` 只剩一种含义 ——
+   * 补投 pending 时 subscriber 抛错,这个 owner 当场就被作废了。
+   */
+  registerHost(
+    subscriber: ToastSubscriber,
+    onClear?: ToastClearSubscriber
+  ): ToastHostLease | null;
   complete(ownerToken: symbol, leaseId: number, entryId: number): boolean;
   isCurrent(delivery: ToastDelivery): boolean;
   pendingEntry(): ToastEntry | null;
   currentDelivery(): ToastDelivery | null;
 };
 
-type Owner = { token: symbol; subscriber: ToastSubscriber | null };
+type Owner = {
+  token: symbol;
+  subscriber: ToastSubscriber | null;
+  onClear: ToastClearSubscriber | null;
+};
 
 export function createToastStore(log: Logger): ToastStore {
   let pending: ToastEntry | null = null;
   let delivered: ToastDelivery | null = null;
   let owner: Owner | null = null;
   let leaseCounter = 0;
+  /** 被接管而挂起的前任,栈顶 = 最近一个。当前 owner 卸载时从这里恢复。 */
+  const suspended: Owner[] = [];
 
   function beginDelivery(entry: ToastEntry, capturedOwner: Owner): void {
     const delivery: ToastDelivery = {
@@ -85,30 +119,92 @@ export function createToastStore(log: Logger): ToastStore {
     beginDelivery(entry, current);
   }
 
-  function registerHost(subscriber: ToastSubscriber): ToastHostLease | null {
-    if (owner) {
-      log.warn(
-        '检测到多个 <ToastHost />。只有第一个生效,重复挂载的实例保持惰性 —— 请在 app 根只挂一次。'
-      );
-      return null;
+  /** 把前任降为挂起态:丢弃它的在途投递,并通知它收起屏幕上那条 toast。 */
+  function suspendOwner(target: Owner): void {
+    // 不回退到 pending —— 否则接管者一挂上就把前任那条补投一遍(跨 owner 重放)。
+    if (delivered?.ownerToken === target.token) delivered = null;
+    const notify = target.onClear;
+    if (!notify) return;
+    try {
+      notify();
+    } catch (error) {
+      log.error('ToastHost clear 回调抛错', error);
+      // 坏 Host 就地作废:留在栈里也只会在恢复时接着抛。
+      target.subscriber = null;
+      target.onClear = null;
+    }
+  }
+
+  /** 弹出最近一个仍可用的挂起 owner;抛错被作废的(subscriber 已置空)直接丢弃。 */
+  function popSuspended(): Owner | null {
+    while (suspended.length > 0) {
+      const next = suspended.pop();
+      if (next?.subscriber) return next;
     }
+    return null;
+  }
+
+  /** 刚上任的 owner 在首投里抛错被作废:继续往下弹,别把栈里剩下的人一起埋掉。 */
+  function resumeAfterFailedInstall(): void {
+    const fallback = popSuspended();
+    if (fallback) owner = fallback;
+  }
+
+  function registerHost(
+    subscriber: ToastSubscriber,
+    onClear?: ToastClearSubscriber
+  ): ToastHostLease | null {
     const token = Symbol('ToastHostOwner');
-    const self: Owner = { token, subscriber };
+    const self: Owner = { token, subscriber, onClear: onClear ?? null };
+    const previous = owner;
+    // 先换 owner 再通知前任:clear 回调里同步 publish() 的那条应当投给**接管者**,
+    // 投给正在退场的前任会立刻变成一条冻在屏幕上的孤儿 toast。
+    //(Confirm 那侧顺序相反 —— 它的 clear 由 settle 发给当时的 owner,必须先排空。)
     owner = self;
+    if (previous) {
+      suspendOwner(previous);
+      // clear 回调抛错作废的前任不入栈,免得恢复出一个死订阅。
+      if (previous.subscriber) suspended.push(previous);
+    }
     if (pending) beginDelivery(pending, self);
-    // 首投期间 subscriber 抛错会把 owner 作废 —— 此时不能发出可用的 lease。
-    if (owner?.token !== token) return null;
+    // 首投期间 subscriber 抛错会把 owner 作废 —— 此时不能发出可用的 lease,
+    // 并且要立刻把刚挂起的前任放回 owner,否则栈里的人再也醒不过来。
+    if (owner?.token !== token) {
+      resumeAfterFailedInstall();
+      return null;
+    }
     return {
       ownerToken: token,
       release(): void {
+        const index = suspended.indexOf(self);
+        if (index >= 0) {
+          // 乱序卸载(父 Modal 先于内层 Host 卸载):挂起者的在途投递在被接管时已丢弃,
+          // 这里只把它摘出栈,绝不能碰当前 owner。
+          suspended.splice(index, 1);
+          self.subscriber = null;
+          self.onClear = null;
+          return;
+        }
         if (owner?.token !== token) return;
         self.subscriber = null;
+        self.onClear = null;
         owner = null;
-        if (delivered?.ownerToken === token) {
-          // 未完成的投递退回 pending,让下一个 Host 能补投;但更新的 pending 优先。
-          if (!pending) pending = delivered.entry;
-          delivered = null;
-        }
+        const mine = delivered?.ownerToken === token ? delivered : null;
+        if (mine) delivered = null;
+        // 归还方向**不丢**在途 toast —— 与接管方向相反,这条区分是有实证的:
+        // 「Modal 内操作成功 → toast → setVisible(false)」是最常见的一条路径,
+        // 内层 Host 跟着 Modal 一起卸载,这条 toast 刚发出、用户一眼都没看到。
+        // 接管方向丢弃是因为前任那条属于「已经被盖住的过去」;归还方向是把刚发生的
+        // 事情**交回上一层**,不是跨 owner 重放。整条交回、不追剩余时长 —— 这正是
+        // 既有的「owner A 卸载后 B 拿到同一 entry、新 leaseId」形态。
+        if (mine && !pending) pending = mine.entry;
+        const successor = popSuspended();
+        if (!successor) return;
+        owner = successor;
+        // 有人接手就当场重投(新 ownerToken + 新 leaseId,前任的迟到回调仍认不出它);
+        // 没人接手时它就停在 pending,等下一个挂上来的 Host 补投 —— 既有语义不变。
+        if (pending) beginDelivery(pending, successor);
+        if (owner?.token !== successor.token) resumeAfterFailedInstall();
       },
     };
   }

package/src/components/ui/Toast/toast.ts

@@ -56,7 +56,8 @@ function emit(input: ToastInput, kind: ToastKind = 'info') {
 }
 
 /**
- * 命令式 toast API。在 app 根附近挂一次 `<ToastHost />` 即可。
+ * 命令式 toast API。在 app 根附近挂一个 `<ToastHost />` 即可;需要在 `Modal` 里显示
+ * 时可在 Modal 内再挂一个,它会接管、关闭后自动归还。
  *
  * toast('已切换到日报');
  * toast.success('订单提交成功');
@@ -69,7 +70,7 @@ export const toast = Object.assign((input: ToastInput) => emit(input, 'info'), {
   error: (input: ToastInput) => emit(input, 'error'),
 });
 
-/** 内部:ToastHost 挂载时注册唯一 owner;重复挂载得到 null。 */
+/** 内部:ToastHost 挂载时接管 owner;前任入栈挂起,本 lease 释放时归还。 */
 export const registerToastHost = store.registerHost;
 
 /** 内部:三重身份 CAS —— owner token + leaseId + entry id 全对才算完成。 */