@capgo/capacitor-pretty-toast 8.1.17 → 8.1.19

package/android/src/main/java/com/toast/ToastOverlay.kt

@@ -66,7 +66,13 @@ class ToastOverlay(activity: Activity) {
     var onPress: (() -> Unit)? = null
     var onActionPress: (() -> Unit)? = null
 
-    private val imageLoader: ExecutorService = Executors.newSingleThreadExecutor { r ->
+    // A `var`, not a `val`: show() calls destroy() on this same instance (not
+    // a fresh one) whenever useDynamicIsland changes, which shuts this down.
+    // loadIcon() rebuilds it on demand so a later custom-icon toast on the
+    // same overlay doesn't hit a RejectedExecutionException on a dead pool.
+    private var imageLoader: ExecutorService = newImageLoader()
+
+    private fun newImageLoader(): ExecutorService = Executors.newSingleThreadExecutor { r ->
         Thread(r, "ToastIconLoader").apply { isDaemon = true }
     }
     // Bitmaps keyed by URI so a repeat show of the same custom icon paints
@@ -379,6 +385,9 @@ class ToastOverlay(activity: Activity) {
     private fun loadIcon(built: ToastViewFactory.Built, uri: String) {
         val targetW = built.icon.layoutParams.width.takeIf { it > 0 } ?: DEFAULT_ICON_TARGET_PX
         val targetH = built.icon.layoutParams.height.takeIf { it > 0 } ?: DEFAULT_ICON_TARGET_PX
+        if (imageLoader.isShutdown) {
+            imageLoader = newImageLoader()
+        }
         imageLoader.execute {
             val bitmap = try {
                 when {

package/android/src/main/java/com/toast/anim/CutoutMorphAnimator.kt

@@ -28,6 +28,17 @@ class CutoutMorphAnimator(
     private var cornerAnimator: ValueAnimator? = null
     private val cornerRadiiBuf = FloatArray(8)
 
+    /**
+     * Set for the duration of dismiss()'s own pill.animate() run. A tap or
+     * release arriving in that window would otherwise reach snapBack(),
+     * which cancels the very same ViewPropertyAnimator instance (Android
+     * caches one per view) — cancel() never runs withEndAction, so the
+     * dismiss's own state reset and onEnd() callback would be lost forever,
+     * leaving the toast overlay's isDismissing flag stuck and every later
+     * toast permanently queued behind it.
+     */
+    private var isDismissingAnim = false
+
     /**
      * Lower bound for the measured pill height — guards against racing
      * the layout pass, where `pill.height` can briefly read as 0.
@@ -76,6 +87,7 @@ class CutoutMorphAnimator(
     }
 
     override fun dismiss(onEnd: () -> Unit) {
+        isDismissingAnim = true
         onBeforeDismiss()
 
         val expandedWidth = pill.width.toFloat().coerceAtLeast(1f)
@@ -110,6 +122,7 @@ class CutoutMorphAnimator(
             .setDuration(MORPH_DURATION_MS)
             .setInterpolator(MORPH_EASING)
             .withEndAction {
+                isDismissingAnim = false
                 resetPillToExpandedResting()
                 onEnd()
             }
@@ -123,6 +136,11 @@ class CutoutMorphAnimator(
     }
 
     override fun snapBack() {
+        // A dismiss already in flight owns this animator; cancelling it here
+        // would strand it (see isDismissingAnim above) instead of letting it
+        // finish and report back to ToastOverlay.
+        if (isDismissingAnim) return
+
         // Release-without-dismiss during a morph drag: spring back to full
         // size and restore content opacity.
         pill.animate().cancel()

package/ios/Sources/PrettyToastPlugin/PrettyToastView.swift

@@ -17,55 +17,56 @@ struct PrettyToastView: View {
             let scaleX: CGFloat = isExpanded ? 1 : (layout.compactWidth / layout.expandedWidth)
             let scaleY: CGFloat = isExpanded ? 1 : (layout.compactHeight / layout.expandedHeight)
 
-            let swipeGesture = DragGesture(minimumDistance: 2).onEnded { value in
-                if value.translation.height < -8 || value.predictedEndTranslation.height < -40 {
+            // A separate `.onTapGesture` alongside a low-threshold
+            // `.gesture(DragGesture())` on the same view is a classic SwiftUI
+            // trap: `minimumDistance: 2` makes the drag start recognizing on
+            // almost any real touch, taps included, and once it does, it took
+            // exclusive priority over the sibling tap gesture — so a plain
+            // tap never reached `wasTapped` and the toast could never be
+            // dismissed by tapping it. One gesture, one decision on release,
+            // fixes that: a short release is always a tap regardless of
+            // whether swipe-dismiss is enabled.
+            let dismissGesture = DragGesture(minimumDistance: 0).onEnded { value in
+                if window.enableSwipeDismiss && (value.translation.height < -8 || value.predictedEndTranslation.height < -40) {
                     window.swipeDismissRequested = true
+                } else {
+                    window.wasTapped = true
                 }
             }
 
             ZStack {
-                Group {
-                    let pill = toastBackground()
-                        .overlay {
-                            toastContent(layout)
-                                .frame(width: layout.expandedWidth, height: layout.expandedHeight)
-                                .scaleEffect(x: scaleX, y: scaleY)
-                        }
-                        .frame(
-                            width: isExpanded ? layout.expandedWidth : layout.compactWidth,
-                            height: isExpanded ? layout.expandedHeight : layout.compactHeight
-                        )
-                        .opacity(layout.hasDynamicIsland ? 1 : (isExpanded ? 1 : 0))
-                        .modifier(CapsuleOpacityModifier(
-                            haveDynamicIsland: layout.hasDynamicIsland,
-                            isExpanded: isExpanded
-                        ))
-                        .modifier(GeometryGroupModifier())
-                        .contentShape(Rectangle())
-                        .onTapGesture {
-                            window.wasTapped = true
+                toastBackground()
+                    .overlay {
+                        toastContent(layout)
+                            .frame(width: layout.expandedWidth, height: layout.expandedHeight)
+                            .scaleEffect(x: scaleX, y: scaleY)
+                    }
+                    .frame(
+                        width: isExpanded ? layout.expandedWidth : layout.compactWidth,
+                        height: isExpanded ? layout.expandedHeight : layout.compactHeight
+                    )
+                    .opacity(layout.hasDynamicIsland ? 1 : (isExpanded ? 1 : 0))
+                    .modifier(CapsuleOpacityModifier(
+                        haveDynamicIsland: layout.hasDynamicIsland,
+                        isExpanded: isExpanded
+                    ))
+                    .modifier(GeometryGroupModifier())
+                    .contentShape(Rectangle())
+                    .gesture(dismissGesture)
+                    .background(
+                        GeometryReader { geo in
+                            Color.clear.preference(
+                                key: ToastFrameKey.self,
+                                value: geo.frame(in: .named("overlayWindow"))
+                            )
                         }
-                        .background(
-                            GeometryReader { geo in
-                                Color.clear.preference(
-                                    key: ToastFrameKey.self,
-                                    value: geo.frame(in: .named("overlayWindow"))
-                                )
-                            }
-                        )
-                        .onPreferenceChange(ToastFrameKey.self) { frame in
-                            if window.toastHitFrame != frame {
-                                window.toastHitFrame = frame
-                            }
+                    )
+                    .onPreferenceChange(ToastFrameKey.self) { frame in
+                        if window.toastHitFrame != frame {
+                            window.toastHitFrame = frame
                         }
-
-                    if window.enableSwipeDismiss {
-                        pill.gesture(swipeGesture)
-                    } else {
-                        pill
                     }
-                }
-                .offset(y: layout.hasDynamicIsland ? (isExpanded ? layout.expandedTopOffset : layout.topOffset) : 0)
+                    .offset(y: layout.hasDynamicIsland ? (isExpanded ? layout.expandedTopOffset : layout.topOffset) : 0)
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
             .padding(.top, layout.hasDynamicIsland ? 0 : (isExpanded ? max(safeArea.top, 10) : 0))

package/ios/Sources/PrettyToastPlugin/ToastManager.swift

@@ -84,11 +84,18 @@ import UIKit
             self.cancelTimer()
             if autoDismiss && duration > 0 {
                 let interval = TimeInterval(duration) / 1000.0
-                self.autoDismissTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
+                // `.common` mode, like the backdrop sampler below: `.default`-mode
+                // timers are suspended for as long as the run loop is in `.tracking`
+                // mode, which UIKit enters for any active touch/scroll — so a toast
+                // triggered while (or dismissed while) the user is scrolling would
+                // never time out, jamming every later toast behind it in the queue.
+                let timer = Timer(timeInterval: interval, repeats: false) { [weak self] _ in
                     DispatchQueue.main.async {
                         self?.dismiss()
                     }
                 }
+                RunLoop.main.add(timer, forMode: .common)
+                self.autoDismissTimer = timer
             }
 
             if !accessibilityAnnouncement.isEmpty {
@@ -148,11 +155,15 @@ import UIKit
         cancelTimer()
         if autoDismiss && duration > 0 {
             let interval = TimeInterval(duration) / 1000.0
-            autoDismissTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
+            // See the matching comment in show(): `.common` mode so scrolling
+            // doesn't suspend the countdown.
+            let timer = Timer(timeInterval: interval, repeats: false) { [weak self] _ in
                 DispatchQueue.main.async {
                     self?.dismiss()
                 }
             }
+            RunLoop.main.add(timer, forMode: .common)
+            autoDismissTimer = timer
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-pretty-toast",
-  "version": "8.1.17",
+  "version": "8.1.19",
   "description": "Native-first pretty toast notifications for Capacitor and the web",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -54,6 +54,7 @@
     "watch": "tsc --watch",
     "prepublishOnly": "bun run build",
     "check:wiring": "node scripts/check-capacitor-plugin-wiring.mjs",
+    "check:cap9-deprecated": "node scripts/check-cap9-deprecated.mjs",
     "example:install": "cd example-app && bun install --frozen-lockfile",
     "example:build": "bun run build && cd example-app && bun install --frozen-lockfile && bun run build",
     "changelog:ai": "node scripts/generate-ai-changelog.mjs"

package/scripts/check-cap9-deprecated.mjs

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+/**
+ * Capacitor 9 deprecated native API guard.
+ *
+ * Fails when plugin native sources still use APIs removed in Capacitor 9.
+ * Does not flag Cordova SwiftPM product dependencies (still required on Cap 8).
+ *
+ * Usage:
+ *   node scripts/check-cap9-deprecated.mjs
+ *   node scripts/check-cap9-deprecated.mjs --workspace
+ *   node scripts/check-cap9-deprecated.mjs --dir path
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".build",
+  ".gradle",
+  "Pods",
+  "DerivedData",
+  ".swiftpm",
+  ".git",
+  "example-app",
+]);
+
+/** @type {{ id: string, pattern: RegExp, exts: string[], ignoreLine?: RegExp }[]} */
+const RULES = [
+  {
+    id: "hasOption",
+    pattern: /\bhasOption\s*\(/,
+    exts: [".java", ".kt", ".swift"],
+  },
+  {
+    id: "getConfigValue",
+    pattern: /\bgetConfigValue\s*\(/,
+    exts: [".java", ".kt", ".swift"],
+  },
+  {
+    id: "@NativePlugin",
+    pattern: /@NativePlugin\b/,
+    exts: [".java", ".kt"],
+  },
+  {
+    id: "saveCall",
+    pattern: /\bsaveCall\s*\(/,
+    exts: [".java", ".kt", ".swift"],
+  },
+  {
+    id: "getSavedCall",
+    pattern: /\bgetSavedCall\s*\(/,
+    exts: [".java", ".kt", ".swift"],
+  },
+  {
+    id: "freeSavedCall",
+    pattern: /\bfreeSavedCall\s*\(/,
+    exts: [".java", ".kt", ".swift"],
+  },
+  {
+    id: "releaseCall",
+    pattern: /\breleaseCall\s*\(/,
+    exts: [".java", ".kt", ".swift"],
+    ignoreLine: /\.releaseCall\s*\(\s*withID:/,
+  },
+  {
+    id: "pluginRequestPermission",
+    pattern: /\bpluginRequestPermissions?\s*\(/,
+    exts: [".java", ".kt"],
+  },
+  {
+    id: "pluginRequestAllPermissions",
+    pattern: /\bpluginRequestAllPermissions\s*\(/,
+    exts: [".java", ".kt"],
+  },
+  {
+    id: "hasDefinedPermissions",
+    pattern: /\bhasDefinedPermissions\s*\(/,
+    exts: [".java", ".kt"],
+  },
+  {
+    id: "CAPBridge",
+    pattern: /\bCAPBridge\./,
+    exts: [".swift"],
+    ignoreLine: /CAPBridgedPlugin/,
+  },
+  {
+    id: "CAPNotifications",
+    pattern: /\bCAPNotifications\b/,
+    exts: [".swift"],
+  },
+];
+
+const CORDova_SPM_LINE =
+  /\.product\s*\(\s*name\s*:\s*"Cordova"\s*,\s*package\s*:\s*"capacitor-swift-pm"\s*\)/;
+
+function readText(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function exists(p) {
+  try {
+    fs.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function parseArgs(argv) {
+  const out = { dir: process.cwd(), workspace: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--workspace") {
+      out.workspace = true;
+      continue;
+    }
+    if (a === "--dir" || a === "--pluginDir") {
+      out.dir = path.resolve(argv[++i] || ".");
+      continue;
+    }
+  }
+  return out;
+}
+
+function walkFiles(rootDir, exts) {
+  const out = [];
+  const stack = [rootDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        stack.push(path.join(dir, e.name));
+        continue;
+      }
+      if (!e.isFile()) continue;
+      for (const ext of exts) {
+        if (e.name.endsWith(ext)) {
+          out.push(path.join(dir, e.name));
+          break;
+        }
+      }
+    }
+  }
+  out.sort();
+  return out;
+}
+
+function collectScanRoots(pluginDir, cap) {
+  const roots = [];
+  if (cap.android) {
+    const androidMain = path.join(pluginDir, "android", "src", "main");
+    if (exists(androidMain)) roots.push(androidMain);
+  }
+  if (cap.ios) {
+    const iosSources = path.join(pluginDir, "ios", "Sources");
+    if (exists(iosSources)) roots.push(iosSources);
+    else {
+      const iosDir = path.join(pluginDir, "ios");
+      if (exists(iosDir)) roots.push(iosDir);
+    }
+  }
+  const packageSwift = path.join(pluginDir, "Package.swift");
+  if (exists(packageSwift)) roots.push(packageSwift);
+  return roots;
+}
+
+function scanFile(filePath, rule) {
+  const ext = path.extname(filePath);
+  if (!rule.exts.includes(ext)) return [];
+
+  const txt = readText(filePath);
+  const lines = txt.split(/\r?\n/);
+  const hits = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (filePath.endsWith("Package.swift") && CORDova_SPM_LINE.test(line)) {
+      continue;
+    }
+    if (rule.ignoreLine?.test(line)) continue;
+    if (rule.pattern.test(line)) {
+      hits.push({ line: i + 1, text: line.trim() });
+    }
+  }
+  return hits;
+}
+
+function listWorkspacePluginDirs(repoRoot) {
+  const packagesRoot = path.join(repoRoot, "packages");
+  if (!exists(packagesRoot)) return [];
+  return fs
+    .readdirSync(packagesRoot, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => path.join(packagesRoot, e.name))
+    .filter((dir) => {
+      const pkgPath = path.join(dir, "package.json");
+      if (!exists(pkgPath)) return false;
+      try {
+        const pkg = JSON.parse(readText(pkgPath));
+        const cap = typeof pkg.capacitor === "object" && pkg.capacitor ? pkg.capacitor : {};
+        return Boolean(cap.android || cap.ios);
+      } catch {
+        return false;
+      }
+    })
+    .sort();
+}
+
+/**
+ * @returns {boolean} true when the plugin passes
+ */
+function checkPluginDir(pluginDir) {
+  const pkgPath = path.join(pluginDir, "package.json");
+
+  if (!exists(pkgPath)) {
+    console.error(`[cap9-deprecated] ERROR: missing package.json in ${pluginDir}`);
+    return false;
+  }
+
+  let pkg;
+  try {
+    pkg = JSON.parse(readText(pkgPath));
+  } catch (e) {
+    console.error(`[cap9-deprecated] ERROR: invalid package.json (${pkgPath}): ${e?.message || e}`);
+    return false;
+  }
+
+  const cap = typeof pkg.capacitor === "object" && pkg.capacitor ? pkg.capacitor : {};
+  if (!cap.android && !cap.ios) {
+    return true;
+  }
+
+  const scanRoots = collectScanRoots(pluginDir, cap);
+  const allExts = [...new Set(RULES.flatMap((r) => r.exts))];
+  const files = [];
+  for (const root of scanRoots) {
+    if (root.endsWith("Package.swift")) {
+      files.push(root);
+      continue;
+    }
+    files.push(...walkFiles(root, allExts));
+  }
+
+  const violations = [];
+  for (const file of files) {
+    for (const rule of RULES) {
+      const hits = scanFile(file, rule);
+      for (const hit of hits) {
+        violations.push({
+          rule: rule.id,
+          file: path.relative(pluginDir, file),
+          line: hit.line,
+          text: hit.text,
+        });
+      }
+    }
+  }
+
+  if (violations.length) {
+    const relDir = path.relative(process.cwd(), pluginDir) || ".";
+    console.error(`[cap9-deprecated] FAIL in ${relDir}`);
+    for (const v of violations) {
+      console.error(`- ${v.rule}: ${v.file}:${v.line}: ${v.text}`);
+    }
+    return false;
+  }
+
+  return true;
+}
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const args = parseArgs(process.argv);
+
+if (args.workspace) {
+  const pluginDirs = listWorkspacePluginDirs(repoRoot);
+  if (!pluginDirs.length) {
+    console.error("[cap9-deprecated] ERROR: no Capacitor plugin packages found under packages/*");
+    process.exit(2);
+  }
+  let failed = false;
+  for (const dir of pluginDirs) {
+    if (!checkPluginDir(dir)) failed = true;
+  }
+  if (failed) process.exit(1);
+  console.log(`[cap9-deprecated] OK (${pluginDirs.length} plugin package(s) scanned)`);
+  process.exit(0);
+}
+
+const ok = checkPluginDir(args.dir);
+process.exit(ok ? 0 : 1);