@livx.cc/appwrap 0.61.7 → 0.61.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.61.7",
+  "version": "0.61.9",
   "description": "Wrap any PWA into a native app with native capabilities (appwrap runtime + @livx.cc/native-kit).",
   "license": "MIT",
   "author": "Elya Livshitz",

package/runtime/app/shell/handlers.ts

@@ -8,6 +8,7 @@ import { setStatusBarStyle } from './status-bar';
 import { buildCapabilityMap } from './capabilities.manifest';
 import { ACTIVE_MODULE_NAMES, PACK_MODULES } from './active-modules.generated';
 import { consumePendingBackgroundTaskId } from './background-context';
+import { settleShare, type ShareOutcome } from './share-outcome';
 
 /** Build identifier for the native shell bundle — bump per deploy to spot stale bundles. */
 export const SHELL_BUILD = 'share-target-1';
@@ -18,6 +19,40 @@ let lastWebVersion: WebVersionInfo = {};
 /** Latest version status the web reported — read by the dev-menu App Info screen. */
 export function getReportedWebVersion(): WebVersionInfo { return lastWebVersion; }
 
+/**
+ * Present the iOS share sheet and resolve when it ENDS — not when it opens — with how it ended
+ * (`{ completed, activity? }`, e.g. activity `com.apple.UIKit.activity.SaveToCameraRoll` for "Save
+ * Video"). That is what lets a caller say "Saved to Photos"; the sheet itself gives no feedback.
+ */
+function presentShareSheet(items: NSMutableArray<any>): Promise<ShareOutcome> {
+  return new Promise((resolve) => {
+    const controller = UIActivityViewController.alloc().initWithActivityItemsApplicationActivities(items, null);
+    const rootVC = Utils.ios.getRootViewController();
+    // iPad requires a popover anchor
+    if (controller.popoverPresentationController) {
+      controller.popoverPresentationController.sourceView = rootVC.view;
+    }
+    let done = false;
+    const finish = (o: ShareOutcome | null) => {
+      if (done || !o) return;
+      done = true;
+      resolve(o);
+    };
+    const presented = () => !!controller.presentingViewController && !controller.isBeingDismissed;
+    controller.completionWithItemsHandler = (activityType: string, completed: boolean) => {
+      // Recover the WebView on dismiss — a presented sheet can orphan a touch-stealing window / leave
+      // the renderer throttled (see CustomWebView.recoverAfterNativeSurface).
+      bridge.getWebView()?.recoverAfterNativeSurface();
+      const now = settleShare(activityType, !!completed, presented());
+      if (now) return finish(now);
+      // Still presented: a cancelled sub-activity (sheet stays) OR a dismissal still animating out.
+      // Re-check once it would have finished; a later handler call wins if it comes first.
+      setTimeout(() => finish(settleShare(null, false, presented())), 700);
+    };
+    rootVC.presentViewControllerAnimatedCompletion(controller, true, null);
+  });
+}
+
 /** Register all protocol-v1 handlers. */
 export function registerHandlers(): void {
   bridge.register('app.handshake', () => {
@@ -84,20 +119,10 @@ export function registerHandlers(): void {
     if (isIOS) {
       const items = NSMutableArray.new();
       if (content) items.addObject(content);
-      const controller = UIActivityViewController.alloc().initWithActivityItemsApplicationActivities(
-        items,
-        null
-      );
-      const rootVC = Utils.ios.getRootViewController();
-      // iPad requires a popover anchor
-      if (controller.popoverPresentationController) {
-        controller.popoverPresentationController.sourceView = rootVC.view;
-      }
-      // Recover the WebView on dismiss — a presented sheet can orphan a touch-stealing window / leave
-      // the renderer throttled (see CustomWebView.recoverAfterNativeSurface).
-      controller.completionWithItemsHandler = () => { bridge.getWebView()?.recoverAfterNativeSurface(); };
-      rootVC.presentViewControllerAnimatedCompletion(controller, true, null);
+      return presentShareSheet(items);
     } else if (isAndroid) {
+      // The chooser cannot report what (or whether) anything was picked, so there is no outcome to
+      // return: resolves undefined, which callers treat as "unknown" (no success feedback).
       const intent = new android.content.Intent(android.content.Intent.ACTION_SEND);
       intent.setType('text/plain');
       if (title) intent.putExtra(android.content.Intent.EXTRA_SUBJECT, title);
@@ -123,15 +148,7 @@ export function registerHandlers(): void {
         data.writeToFileAtomically(filePath, true);
         items.addObject(NSURL.fileURLWithPath(filePath));
       });
-      const controller = UIActivityViewController.alloc().initWithActivityItemsApplicationActivities(
-        items,
-        null
-      );
-      const rootVC = Utils.ios.getRootViewController();
-      if (controller.popoverPresentationController) {
-        controller.popoverPresentationController.sourceView = rootVC.view; // iPad anchor
-      }
-      rootVC.presentViewControllerAnimatedCompletion(controller, true, null);
+      return presentShareSheet(items);
     }
   );
 

package/runtime/app/shell/keyboard-frame.ts

@@ -0,0 +1,67 @@
+/**
+ * Pure iOS keyboard-frame decision (no NativeScript/UIKit globals — unit-testable).
+ *
+ * Decides how many points of the screen a keyboard notification's end frame covers, or why the
+ * event must NOT shrink the webview. A hidden keyboard must always end at full height, so any
+ * doubtful event resolves to "skip" — the hide pair (willHide/didHide) owns the restore.
+ */
+export type KeyboardEventTag = 'willShow' | 'didShow' | 'willChangeFrame';
+
+export interface KeyboardFrameInput {
+  tag: KeyboardEventTag;
+  /** willShow/didShow seen since the last willHide/didHide — the keyboard is (becoming) visible. */
+  inShowCycle: boolean;
+  /** UIKeyboardFrameEndUserInfoKey, in screen coordinates. Absent → nothing to apply. */
+  end?: { y: number };
+  /** Window height, or the SCREEN height when the webview is momentarily out of a window. */
+  containerHeight: number;
+}
+
+export interface KeyboardFrameDecision {
+  height: number;
+  skip?: 'no-frame' | 'off-screen' | 'out-of-cycle' | 'bogus';
+}
+
+export function resolveKeyboardHeight(input: KeyboardFrameInput): KeyboardFrameDecision {
+  const { tag, inShowCycle, end, containerHeight } = input;
+  if (!end || !(containerHeight > 0)) return { height: 0, skip: 'no-frame' };
+  // Overlap with the container, NOT the frame's height: iOS delivers keyboard-sized but off-screen
+  // end frames during dismissal — the frame height would shrink a keyboard-less screen.
+  const height = Math.max(0, Math.round(containerHeight - end.y));
+  if (height <= 0) return { height: 0, skip: 'off-screen' };
+  // willChangeFrame also fires OUTSIDE a show cycle (after didHide: iframe/dialog teardown, audio
+  // session / speech-recognition takeover) with an on-screen end frame. Applying it re-shrinks a
+  // keyboard-less screen and nothing restores it (field bug: half-screen empty band across screens).
+  // A keyboard that really appears always posts willShow or didShow (warm re-focus = didShow-only),
+  // which re-opens the cycle and lands the shrink.
+  if (tag === 'willChangeFrame' && !inShowCycle) return { height: 0, skip: 'out-of-cycle' };
+  // Bogus full-screen frames (origin.y≈0, seen during SMS-OTP autofill): a real software keyboard is
+  // never >85% of the screen; the real frame follows and self-heals.
+  if (height > containerHeight * 0.85) return { height, skip: 'bogus' };
+  return { height };
+}
+
+/**
+ * Stateful show-cycle gate around resolveKeyboardHeight: willShow/didShow open the cycle (a keyboard
+ * really appearing posts one of these), the hide pair closes it. Owns the flag so keyboard.ts can't
+ * forget to open or close it.
+ */
+export function createKeyboardShowCycle() {
+  let open = false;
+  return {
+    resolve(input: Omit<KeyboardFrameInput, 'inShowCycle'>): KeyboardFrameDecision {
+      if (input.tag === 'willChangeFrame') return resolveKeyboardHeight({ ...input, inShowCycle: open });
+      const decision = resolveKeyboardHeight({ ...input, inShowCycle: true });
+      // Only a show event with an on-screen keyboard opens the cycle: a skipped (off-screen/no-frame)
+      // didShow must not arm a following stray willChangeFrame. 'bogus' is a real keyboard mid-autofill
+      // whose true frame follows as willChangeFrame, so it opens.
+      if (!decision.skip || decision.skip === 'bogus') open = true;
+      // Known, unproven ordering: a late on-screen didShow AFTER didHide still opens + shrinks with no
+      // restoring hide to follow. Accepted until the device root cause is confirmed.
+      return decision;
+    },
+    close(): void {
+      open = false;
+    },
+  };
+}

package/runtime/app/shell/keyboard.ts

@@ -1,6 +1,7 @@
 import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
 import { SHELL_CONFIG } from './config';
+import { createKeyboardShowCycle, type KeyboardEventTag } from './keyboard-frame';
 import { appwrapNativeLog } from './native-log';
 
 declare const android: any;
@@ -19,6 +20,7 @@ declare const NSObject: any;
 declare const UIScrollViewDelegate: any;
 declare function CGPointMake(x: number, y: number): any;
 declare const UIColor: any;
+declare const UIScreen: any;
 
 let observersArmed = false;
 
@@ -76,6 +78,9 @@ function armIosKeyboardObservers(): void {
   // height → apply the configured extra lift to close the gap. Reset when the keyboard fully hides.
   let sawWillShow = false;
   let activeExtraLift = 0;
+  // willShow/didShow seen since the last willHide/didHide. Only a live show cycle may shrink via
+  // willChangeFrame — out-of-cycle frames re-shrank a keyboard-less screen (see keyboard-frame.ts).
+  const showCycle = createKeyboardShowCycle();
 
   const getWk = (): WKWebView | undefined => bridge.getWebView()?.ios as WKWebView | undefined;
 
@@ -110,7 +115,10 @@ function armIosKeyboardObservers(): void {
     const wv = bridge.getWebView();
     const wk = getWk();
     const win = wk?.window;
-    if (!wv || !wk || !win) {
+    // The RESTORE (margin 0) needs no window — only a shrink needs the safe-area inset. Waiting for a
+    // window on restore let a webview detached through a screen transition exhaust the retries and
+    // stay shrunk on the next screen.
+    if (!wv || !wk || (paddingBottom > 0 && !win)) {
       if (attempt < 20) pendingUpdate = setTimeout(() => Utils.dispatchToMainThread(() => updateFrame(attempt + 1)), 100);
       else if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] frame update gave up (webview detached), pad=${paddingBottom}`);
       return;
@@ -120,7 +128,7 @@ function armIosKeyboardObservers(): void {
     // which is what produced gaps, content under the status bar, and residual scroll state.
     // Subtract the bottom safe-area inset: NS layout already excludes it, and the keyboard COVERS
     // it — margining the full keyboard height double-counts those 34pt as a gap above the keyboard.
-    const safeBottom = win.safeAreaInsets?.bottom ?? 0;
+    const safeBottom = win?.safeAreaInsets?.bottom ?? 0;
     // On a WARM re-focus iOS 26 reports a keyboard TALLER than it draws (it reserves the ▲▼✓ accessory
     // row but doesn't draw it), leaving bare black native space between the shrunk webview and the
     // real keys. `activeExtraLift` (see onShow) is the configured extra lift on those warm shows and 0
@@ -147,33 +155,26 @@ function armIosKeyboardObservers(): void {
   // Re-focus does NOT re-fire willShow — capture-verified: a second tap arrives ONLY as
   // didShow/willChangeFrame. All three feed the same idempotent handler; whichever iOS sends, the
   // shrink lands. Height-0 frame events do nothing (hide is owned by the willHide/didHide pair).
-  const onShow = (tag: string, settleMs: number | null) => (note: any): void => {
+  const onShow = (tag: KeyboardEventTag, settleMs: number | null) => (note: any): void => {
     detachWebKitKeyboardHandling();
     if (tag === 'willShow') sawWillShow = true; // cold acquire → the accessory bar will be drawn
     // Warm re-focus (didShow/willChangeFrame with no willShow this cycle) → bar dropped → lift extra.
     activeExtraLift = sawWillShow ? 0 : (SHELL_CONFIG.iosKeyboardExtraLift ?? 82);
     const value = note?.userInfo?.objectForKey?.(UIKeyboardFrameEndUserInfoKey);
-    // Overlap with the window, NOT frame.size.height: iOS delivers keyboard-sized but off-screen
-    // end-frames during dismissal — size.height would shrink a keyboard-less screen.
-    let height = 0;
-    let winH = 0;
-    if (value) {
-      const end = value.CGRectValue;
-      const win = getWk()?.window;
-      winH = win ? win.bounds.size.height : 0;
-      height = winH ? Math.max(0, Math.round(winH - end.origin.y)) : Math.round(end.size.height);
-    }
-    if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] ${tag} height=${height}`);
+    const rect = value?.CGRectValue;
+    // Keyboard frames are in screen coordinates: a webview momentarily out of its window (screen
+    // transition) measures against the screen — never the raw frame height, which is keyboard-sized
+    // even for the off-screen end frames iOS posts during dismissal.
+    const win = getWk()?.window;
+    const containerHeight = win ? win.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
+    const { height, skip } = showCycle.resolve({
+      tag,
+      end: rect ? { y: rect.origin.y } : undefined,
+      containerHeight,
+    });
+    if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] ${tag} height=${height}${skip ? ` skip=${skip}` : ''} (container=${Math.round(containerHeight)})`);
     resetScrollView();
-    if (height <= 0) return;
-    // Guard against bogus full-screen keyboard frames. iOS occasionally delivers a transitional frame
-    // with origin.y≈0 (seen during SMS-OTP autofill) → height ≈ the whole window → the resize would
-    // shrink the webview to a sliver (huge black gap). A real software keyboard is never >85% of the
-    // screen; ignore the event and wait for the real frame (which follows and self-heals).
-    if (winH && height > winH * 0.85) {
-      if (SHELL_CONFIG.debug) appwrapNativeLog(`[native:keyboard] ignore bogus height=${height} (win=${Math.round(winH)})`);
-      return;
-    }
+    if (skip) return;
     // Paint the webview/window backdrop the page color so the resize shows no white flash. (The
     // iOS-26 phantom keyboard-height gap is closed geometrically by the extra lift in updateFrame.)
     syncBackdropColor();
@@ -187,11 +188,13 @@ function armIosKeyboardObservers(): void {
   center.addObserverForNameObjectQueueUsingBlock(UIKeyboardDidShowNotification, null, null, onShow('didShow', 50));
   center.addObserverForNameObjectQueueUsingBlock(UIKeyboardWillHideNotification, null, null, () => {
     if (SHELL_CONFIG.debug) appwrapNativeLog('[native:keyboard] willHide → restore');
+    showCycle.close(); // dismissal's willChangeFrame must not re-shrink
     setKeyboardHeight(0, 10);
     resetScrollView();
     bridge.emit('keyboard.hide');
   });
   center.addObserverForNameObjectQueueUsingBlock(UIKeyboardDidHideNotification, null, null, () => {
+    showCycle.close();
     setKeyboardHeight(0, 10); // enforcement pass — a hidden keyboard must always end at full height
     resetScrollView();
     sawWillShow = false; // keyboard fully gone → next show re-decides cold (bar) vs warm (no bar)

package/runtime/app/shell/share-outcome.ts

@@ -0,0 +1,21 @@
+/** How a share sheet ended — what `share.share` / `share.files` resolve with (native-kit `ShareResult`). */
+export interface ShareOutcome {
+  completed: boolean;
+  activity?: string;
+}
+
+/**
+ * Decide whether ONE `UIActivityViewController.completionWithItemsHandler` call ends the share.
+ * iOS 13+ calls the handler with (activityType, completed=false) when a sub-activity (Mail, Messages)
+ * is cancelled while the sheet STAYS open for another pick — resolving there would report "cancelled"
+ * and lose the real outcome. So: a completed activity ends it; otherwise only a sheet that is no longer
+ * presented does. `null` = not over yet, wait for the next call (or the dismissal re-check).
+ */
+export function settleShare(
+  activityType: string | null | undefined,
+  completed: boolean,
+  sheetStillPresented: boolean
+): ShareOutcome | null {
+  if (completed) return activityType ? { completed: true, activity: String(activityType) } : { completed: true };
+  return sheetStillPresented ? null : { completed: false };
+}

package/runtime/tests/keyboard-frame.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { createKeyboardShowCycle, resolveKeyboardHeight } from '../app/shell/keyboard-frame';
+
+/**
+ * iOS keyboard avoidance must never leave the webview shrunk once the keyboard is gone.
+ * Field bug pinned: Blank's "Fan Reach" call dialog (input in a showModal <dialog> in a sandboxed
+ * iframe, then TTS + STT) left a half-screen empty band that persisted onto the home grid.
+ */
+const H = 844; // iPhone 13 Pro window height (pt)
+const KB = { y: H - 336 }; // on-screen keyboard end frame
+
+describe('resolveKeyboardHeight', () => {
+  test('cold show applies the on-screen overlap', () => {
+    expect(resolveKeyboardHeight({ tag: 'willShow', inShowCycle: true, end: KB, containerHeight: H })).toEqual({ height: 336 });
+  });
+
+  test('warm re-focus (didShow-only) still applies', () => {
+    expect(resolveKeyboardHeight({ tag: 'didShow', inShowCycle: true, end: KB, containerHeight: H }).height).toBe(336);
+    expect(resolveKeyboardHeight({ tag: 'didShow', inShowCycle: true, end: KB, containerHeight: H }).skip).toBeUndefined();
+  });
+
+  test('willChangeFrame inside a show cycle (keyboard resize) applies', () => {
+    const end = { y: H - 380 };
+    expect(resolveKeyboardHeight({ tag: 'willChangeFrame', inShowCycle: true, end, containerHeight: H })).toEqual({ height: 380 });
+  });
+
+  test('willChangeFrame AFTER didHide with an on-screen frame does not re-shrink', () => {
+    expect(resolveKeyboardHeight({ tag: 'willChangeFrame', inShowCycle: false, end: KB, containerHeight: H })).toEqual({ height: 0, skip: 'out-of-cycle' });
+  });
+
+  test('keyboard-sized off-screen dismissal frame is zero overlap', () => {
+    expect(resolveKeyboardHeight({ tag: 'willChangeFrame', inShowCycle: true, end: { y: H }, containerHeight: H }).skip).toBe('off-screen');
+  });
+
+  test('no container height never falls back to the raw frame height', () => {
+    expect(resolveKeyboardHeight({ tag: 'didShow', inShowCycle: true, end: { y: H }, containerHeight: 0 })).toEqual({ height: 0, skip: 'no-frame' });
+  });
+
+  test('bogus full-screen frame is skipped', () => {
+    expect(resolveKeyboardHeight({ tag: 'willShow', inShowCycle: true, end: { y: 0 }, containerHeight: H }).skip).toBe('bogus');
+  });
+});
+
+describe('createKeyboardShowCycle', () => {
+  const frame = (tag: 'willShow' | 'didShow' | 'willChangeFrame') => ({ tag, end: KB, containerHeight: H });
+
+  test('a fresh cycle ignores a stray willChangeFrame', () => {
+    expect(createKeyboardShowCycle().resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+  });
+
+  test('willShow opens the cycle so a following willChangeFrame resize applies', () => {
+    const cycle = createKeyboardShowCycle();
+    expect(cycle.resolve(frame('willShow'))).toEqual({ height: 336 });
+    expect(cycle.resolve(frame('willChangeFrame'))).toEqual({ height: 336 });
+  });
+
+  test('a skipped (off-screen / no-frame) didShow does not open the cycle for a stray willChangeFrame', () => {
+    const cycle = createKeyboardShowCycle();
+    expect(cycle.resolve({ tag: 'didShow', end: { y: H }, containerHeight: H }).skip).toBe('off-screen');
+    expect(cycle.resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+    expect(cycle.resolve({ tag: 'didShow', containerHeight: H }).skip).toBe('no-frame');
+    expect(cycle.resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+  });
+
+  test('a bogus (autofill full-screen) willShow still opens the cycle so the real frame lands', () => {
+    const cycle = createKeyboardShowCycle();
+    expect(cycle.resolve({ tag: 'willShow', end: { y: 0 }, containerHeight: H }).skip).toBe('bogus');
+    expect(cycle.resolve(frame('willChangeFrame'))).toEqual({ height: 336 });
+  });
+
+  test('warm re-focus (didShow-only) re-opens the cycle after a hide', () => {
+    const cycle = createKeyboardShowCycle();
+    cycle.resolve(frame('willShow'));
+    cycle.close();
+    expect(cycle.resolve(frame('willChangeFrame')).skip).toBe('out-of-cycle');
+    expect(cycle.resolve(frame('didShow'))).toEqual({ height: 336 });
+    expect(cycle.resolve(frame('willChangeFrame'))).toEqual({ height: 336 });
+  });
+});
+
+// Source-level wiring (keyboard.ts imports NativeScript and can't load under bun).
+const src = readFileSync(join(import.meta.dir, '..', 'app', 'shell', 'keyboard.ts'), 'utf8');
+describe('keyboard.ts wiring', () => {
+  test('onShow routes through the show-cycle gate', () => {
+    expect(src).toMatch(/showCycle\.resolve\(\{/);
+    expect(src).not.toMatch(/resolveKeyboardHeight\(/);
+  });
+  test('both hide notifications close the show cycle', () => {
+    const hides = src.split('UIKeyboardWillHideNotification, null, null')[1] ?? '';
+    expect((hides.match(/showCycle\.close\(\)/g) ?? []).length).toBe(2);
+  });
+  test('restore to full height does not wait for the webview to be in a window', () => {
+    expect(src).toMatch(/if \(!wv \|\| !wk \|\| \(paddingBottom > 0 && !win\)\)/);
+  });
+});

package/runtime/tests/share-outcome.test.ts

@@ -0,0 +1,27 @@
+/**
+ * iOS share sheet outcome — `share.share` / `share.files` resolve when the sheet ENDS with
+ * `{ completed, activity? }`. Contract: a completed activity ends it (with its type), a dismissed sheet
+ * ends it as not completed, and a cancelled sub-activity while the sheet stays open does NOT end it.
+ */
+import { describe, expect, test } from 'bun:test';
+import { settleShare } from '../app/shell/share-outcome';
+
+describe('settleShare', () => {
+  test('"Save Video" completes with its activity type', () => {
+    expect(settleShare('com.apple.UIKit.activity.SaveToCameraRoll', true, false))
+      .toEqual({ completed: true, activity: 'com.apple.UIKit.activity.SaveToCameraRoll' });
+  });
+  test('completed while the sheet is still animating out still completes', () => {
+    expect(settleShare('com.apple.UIKit.activity.CopyToPasteboard', true, true))
+      .toEqual({ completed: true, activity: 'com.apple.UIKit.activity.CopyToPasteboard' });
+  });
+  test('completed with no activity type carries no activity key', () => {
+    expect(settleShare(null, true, false)).toEqual({ completed: true });
+  });
+  test('sheet dismissed without a pick → not completed', () => {
+    expect(settleShare(null, false, false)).toEqual({ completed: false });
+  });
+  test('sub-activity cancelled while the sheet stays open → not over yet', () => {
+    expect(settleShare('com.apple.UIKit.activity.Mail', false, true)).toBeNull();
+  });
+});