@hanzogui/sheet 7.3.0 → 8.0.0

package/src/webViewport.ts

@@ -0,0 +1,100 @@
+/**
+ * Web (mobile-browser) viewport helpers for the Sheet's keyboard handling.
+ *
+ * On real iOS Safari (verified on-device, iOS 26) the soft keyboard shrinks
+ * BOTH `window.visualViewport.height` AND `window.innerHeight` — neither is the
+ * stable layout viewport. Measured during a keyboard open: visualViewport
+ * 714 -> 404, innerHeight 714 -> 561 (it wobbles), but
+ * `document.documentElement.clientHeight` holds rock-steady at 714 the whole
+ * time (open, mid-keyboard, and close). So clientHeight IS the stable layout
+ * viewport, and we derive everything from it:
+ *   - keyboard resize height = clientHeight - visualViewport.height (stays
+ *     correct even as innerHeight drifts), so keyboard detection is stable.
+ *   - keyboard bottom inset = clientHeight - (visualViewport.offsetTop +
+ *     visualViewport.height), so Safari's focus pan doesn't over-lift the sheet.
+ *   - the sheet's fit-mode position math reads clientHeight, so it never
+ *     re-measures against a shrunk value; the frame can translate with the
+ *     keyboard while keeping its natural fit height.
+ */
+
+// ignore small viewport changes (URL bar collapse, accessory bars) so they
+// don't read as a full keyboard. a real soft keyboard is well above this.
+export const MIN_KEYBOARD_HEIGHT = 80
+
+export function isEditableElement(el: Element | null): boolean {
+  if (!el) return false
+  const tag = el.tagName
+  if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return true
+  if ((el as HTMLElement).isContentEditable) return true
+  return false
+}
+
+/**
+ * The stable layout-viewport height. document.documentElement.clientHeight is
+ * unaffected by the soft keyboard on iOS Safari (unlike innerHeight /
+ * visualViewport), so it stays constant while the keyboard animates in/out.
+ */
+export function getStableLayoutViewportHeight(): number {
+  if (typeof window === 'undefined') return 0
+  const ch = typeof document !== 'undefined' ? document.documentElement?.clientHeight : 0
+  if (ch && ch > 0) return ch
+  // fallback when clientHeight is unavailable (SSR / detached): best effort
+  return Math.max(window.innerHeight || 0, window.visualViewport?.height || 0)
+}
+
+/**
+ * the largest the visible viewport can ever become on this device.
+ *
+ * iOS Safari grows the visible area as its top/bottom chrome (URL bar, toolbar,
+ * the dynamic bottom safe area) retracts on scroll, so the current layout
+ * viewport — document.documentElement.clientHeight — is not an upper bound: the
+ * chrome can collapse and reveal area BELOW it. A sheet whose hidden/below-fold
+ * region is sized against the current viewport then peeks back into view as the
+ * page scrolls and Safari reveals more.
+ *
+ * So we track a session high-water mark across every measured viewport signal,
+ * floored at the device screen height, so we never under-shoot even before any
+ * chrome collapse has been observed. Used to push hidden/minimized sheet content
+ * fully past the maximum the viewport could ever expose.
+ */
+let _maxViewportHeight = 0
+export function getMaxViewportHeight(): number {
+  if (typeof window === 'undefined') return 0
+  const ch = typeof document !== 'undefined' ? document.documentElement?.clientHeight : 0
+  _maxViewportHeight = Math.max(
+    _maxViewportHeight,
+    ch || 0,
+    window.innerHeight || 0,
+    window.visualViewport?.height || 0,
+    window.screen?.height || 0
+  )
+  return _maxViewportHeight
+}
+
+export function getWebKeyboardResizeHeight(): number {
+  if (typeof window === 'undefined') return 0
+  const vv = window.visualViewport
+  if (!vv) return 0
+  return Math.max(0, Math.round(getStableLayoutViewportHeight() - vv.height))
+}
+
+export function getWebVisualViewportOffsetTop(): number {
+  if (typeof window === 'undefined') return 0
+  return Math.max(0, Math.round(window.visualViewport?.offsetTop || 0))
+}
+
+/**
+ * bottom layout inset hidden below the visual viewport. When Safari pans the
+ * visual viewport during focus, offsetTop reduces the bottom-hidden area.
+ */
+export function getWebKeyboardBottomInset(): number {
+  if (typeof window === 'undefined') return 0
+  const vv = window.visualViewport
+  if (!vv) return 0
+  const visibleBottom = getWebVisualViewportOffsetTop() + vv.height
+  return Math.max(0, Math.round(getStableLayoutViewportHeight() - visibleBottom))
+}
+
+export function getWebKeyboardHeight(): number {
+  return getWebKeyboardResizeHeight()
+}

package/test/keyboardAvoidance.test.ts

@@ -0,0 +1,269 @@
+import { afterEach, describe, expect, test } from 'vitest'
+
+import {
+  getKeyboardAdjustedSheetY,
+  getKeyboardOccludedHeight,
+  getSheetReleasePosition,
+} from '../src/keyboardAvoidance'
+import {
+  getWebKeyboardBottomInset,
+  getWebKeyboardResizeHeight,
+  getWebVisualViewportOffsetTop,
+} from '../src/webViewport'
+
+const originalWindow = globalThis.window
+const originalDocument = globalThis.document
+
+function setWebViewport({
+  clientHeight,
+  visualViewportHeight,
+  offsetTop = 0,
+}: {
+  clientHeight: number
+  visualViewportHeight: number
+  offsetTop?: number
+}) {
+  Object.defineProperty(globalThis, 'document', {
+    configurable: true,
+    value: {
+      documentElement: {
+        clientHeight,
+      },
+    },
+  })
+  Object.defineProperty(globalThis, 'window', {
+    configurable: true,
+    value: {
+      innerHeight: clientHeight,
+      visualViewport: {
+        height: visualViewportHeight,
+        offsetTop,
+      },
+    },
+  })
+}
+
+afterEach(() => {
+  Object.defineProperty(globalThis, 'window', {
+    configurable: true,
+    value: originalWindow,
+  })
+  Object.defineProperty(globalThis, 'document', {
+    configurable: true,
+    value: originalDocument,
+  })
+})
+
+describe('getKeyboardAdjustedSheetY', () => {
+  const base = {
+    sheetY: 320,
+    screenSize: 844,
+    isKeyboardVisible: true,
+    keyboardHeight: 300,
+    safeAreaTop: 44,
+  }
+
+  test('keeps the original position when translation is disabled', () => {
+    expect(
+      getKeyboardAdjustedSheetY({
+        ...base,
+        shouldTranslate: false,
+      })
+    ).toBe(base.sheetY)
+  })
+
+  test('shifts sheets up by keyboard height and caps at safe area', () => {
+    expect(
+      getKeyboardAdjustedSheetY({
+        ...base,
+        shouldTranslate: true,
+      })
+    ).toBe(44)
+  })
+
+  test('keeps a smaller fit sheet at its natural height and moves it with the keyboard', () => {
+    expect(
+      getKeyboardAdjustedSheetY({
+        ...base,
+        sheetY: 500,
+        shouldTranslate: true,
+      })
+    ).toBe(200)
+  })
+
+  test('does not shift hidden keyboard or offscreen close positions', () => {
+    expect(
+      getKeyboardAdjustedSheetY({
+        ...base,
+        isKeyboardVisible: false,
+        shouldTranslate: true,
+      })
+    ).toBe(base.sheetY)
+    expect(
+      getKeyboardAdjustedSheetY({
+        ...base,
+        sheetY: base.screenSize,
+        shouldTranslate: true,
+      })
+    ).toBe(base.screenSize)
+  })
+})
+
+describe('getKeyboardOccludedHeight', () => {
+  const base = {
+    frameSize: 700,
+    isKeyboardVisible: true,
+    keyboardHeight: 300,
+    screenSize: 844,
+    sheetY: 59,
+  }
+
+  test('returns overflow below the keyboard top after the sheet is clamped', () => {
+    expect(getKeyboardOccludedHeight(base)).toBe(215)
+  })
+
+  test('returns zero when the keyboard-adjusted sheet clears the keyboard', () => {
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        frameSize: 400,
+        sheetY: 144,
+      })
+    ).toBe(0)
+  })
+
+  test('ignores hidden keyboard and offscreen sheet positions', () => {
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        isKeyboardVisible: false,
+      })
+    ).toBe(0)
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        sheetY: base.screenSize,
+      })
+    ).toBe(0)
+  })
+
+  test('clamps occlusion to the frame height', () => {
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        frameSize: 120,
+        keyboardHeight: 1000,
+        sheetY: 0,
+      })
+    ).toBe(120)
+  })
+})
+
+describe('getSheetReleasePosition', () => {
+  // WEB keyboard-fit-dismiss threshold (the 75de9c9694 web keyboard-handoff fix):
+  // when the keyboard is up, a fit+dismiss sheet only dismisses after enough
+  // ACTUAL travel, ignoring a velocity-projected short drag.
+  test('web: keeps a keyboard-fit sheet open when velocity projects a short drag to dismiss', () => {
+    expect(
+      getSheetReleasePosition({
+        positions: [0, 844],
+        projectedEnd: 480,
+        currentPosition: 150,
+        frameSize: 591,
+        dismissOnSnapToBottom: true,
+        snapPointsMode: 'fit',
+        isKeyboardVisible: true,
+        isWeb: true,
+      })
+    ).toBe(0)
+  })
+
+  test('web: allows a keyboard-fit sheet to dismiss after enough actual travel', () => {
+    expect(
+      getSheetReleasePosition({
+        positions: [0, 844],
+        projectedEnd: 560,
+        currentPosition: 225,
+        frameSize: 591,
+        dismissOnSnapToBottom: true,
+        snapPointsMode: 'fit',
+        isKeyboardVisible: true,
+        isWeb: true,
+      })
+    ).toBe(1)
+  })
+
+  // NATIVE must NOT apply the web threshold — it snaps purely by projected
+  // position (the pre-rework v2.1.0 behavior). regression guard: with the
+  // threshold leaking into native, this short-projected drag wrongly stayed open
+  // (0); native should snap to the nearest point (here: dismiss, index 1).
+  test('native: snaps a keyboard-fit sheet by projected position, ignoring the web threshold', () => {
+    expect(
+      getSheetReleasePosition({
+        positions: [0, 844],
+        projectedEnd: 480,
+        currentPosition: 150,
+        frameSize: 591,
+        dismissOnSnapToBottom: true,
+        snapPointsMode: 'fit',
+        isKeyboardVisible: true,
+        isWeb: false,
+      })
+    ).toBe(1)
+  })
+
+  test('native: a projected-open drag snaps back open', () => {
+    expect(
+      getSheetReleasePosition({
+        positions: [0, 844],
+        projectedEnd: 200,
+        currentPosition: 300,
+        frameSize: 591,
+        dismissOnSnapToBottom: true,
+        snapPointsMode: 'fit',
+        isKeyboardVisible: true,
+        isWeb: false,
+      })
+    ).toBe(0)
+  })
+
+  test('keeps normal multi-snap release behavior outside keyboard-fit dismiss', () => {
+    expect(
+      getSheetReleasePosition({
+        positions: [0, 360, 844],
+        projectedEnd: 310,
+        currentPosition: 90,
+        frameSize: 591,
+        dismissOnSnapToBottom: true,
+        snapPointsMode: 'percent',
+        isKeyboardVisible: true,
+        isWeb: true,
+      })
+    ).toBe(1)
+  })
+})
+
+describe('web viewport keyboard metrics', () => {
+  test('separates keyboard resize height from bottom inset when Safari pans the visual viewport', () => {
+    setWebViewport({
+      clientHeight: 678,
+      visualViewportHeight: 452,
+      offsetTop: 158,
+    })
+
+    expect(getWebKeyboardResizeHeight()).toBe(226)
+    expect(getWebVisualViewportOffsetTop()).toBe(158)
+    expect(getWebKeyboardBottomInset()).toBe(68)
+  })
+
+  test('matches resize height and bottom inset when the visual viewport is not panned', () => {
+    setWebViewport({
+      clientHeight: 678,
+      visualViewportHeight: 452,
+    })
+
+    expect(getWebKeyboardResizeHeight()).toBe(226)
+    expect(getWebVisualViewportOffsetTop()).toBe(0)
+    expect(getWebKeyboardBottomInset()).toBe(226)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,57 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "strict": true
+  },
+  "references": [
+    {
+      "path": "../../core/animations-react-native"
+    },
+    {
+      "path": "../../core/compose-refs"
+    },
+    {
+      "path": "../../core/constants"
+    },
+    {
+      "path": "../../core/core"
+    },
+    {
+      "path": "../../core/create-context"
+    },
+    {
+      "path": "../../core/helpers"
+    },
+    {
+      "path": "../../core/use-constant"
+    },
+    {
+      "path": "../../core/use-controllable-state"
+    },
+    {
+      "path": "../../core/use-keyboard-visible"
+    },
+    {
+      "path": "../animate-presence"
+    },
+    {
+      "path": "../portal"
+    },
+    {
+      "path": "../remove-scroll"
+    },
+    {
+      "path": "../scroll-view"
+    },
+    {
+      "path": "../stacks"
+    }
+  ],
+  "exclude": [
+    "types",
+    "dist",
+    "test",
+    "**/__tests__"
+  ]
+}

package/types/GestureDetectorWrapper.d.ts

@@ -9,6 +9,6 @@ interface GestureDetectorWrapperProps {
  * Conditionally wraps children with GestureDetector when RNGH is available.
  * Uses a plain View wrapper that GestureDetector can attach gesture handlers to.
  */
-export declare function GestureDetectorWrapper({ gesture, children, style, }: GestureDetectorWrapperProps): React.JSX.Element;
+export declare function GestureDetectorWrapper({ gesture, children, style, }: GestureDetectorWrapperProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=GestureDetectorWrapper.d.ts.map

package/types/GestureDetectorWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GestureDetectorWrapper.d.ts","sourceRoot":"","sources":["../src/GestureDetectorWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGnD,UAAU,2BAA2B;IACnC,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,QAAQ,EACR,KAAK,GACN,EAAE,2BAA2B,qBAsB7B"}
+{"version":3,"file":"GestureDetectorWrapper.d.ts","sourceRoot":"","sources":["../src/GestureDetectorWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGnD,UAAU,2BAA2B;IACnC,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,QAAQ,EACR,KAAK,GACN,EAAE,2BAA2B,2CAmB7B"}

package/types/GestureSheetContext.d.ts

@@ -32,5 +32,5 @@ export interface GestureSheetProviderProps {
     panGesture: any | null;
     panGestureRef: RefObject<any> | null;
 }
-export declare function GestureSheetProvider({ children, isDragging, blockPan, setBlockPan, panGesture, panGestureRef, }: GestureSheetProviderProps): React.JSX.Element;
+export declare function GestureSheetProvider({ children, isDragging, blockPan, setBlockPan, panGesture, panGestureRef, }: GestureSheetProviderProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=GestureSheetContext.d.ts.map

package/types/GestureSheetContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GestureSheetContext.d.ts","sourceRoot":"","sources":["../src/GestureSheetContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAEjE,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,UAAU,EAAE,GAAG,GAAG,IAAI,CAAA;IACtB;;OAEG;IACH,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACpC;;OAEG;IACH,UAAU,EAAE,OAAO,CAAA;IACnB;;OAEG;IACH,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACvC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAA;CAClB;AAID,wBAAgB,sBAAsB,IAAI,wBAAwB,GAAG,IAAI,CAExE;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACvC,UAAU,EAAE,GAAG,GAAG,IAAI,CAAA;IACtB,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;CACrC;AAED,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,WAAW,EACX,UAAU,EACV,aAAa,GACd,EAAE,yBAAyB,qBAY3B"}
+{"version":3,"file":"GestureSheetContext.d.ts","sourceRoot":"","sources":["../src/GestureSheetContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAEjE,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,UAAU,EAAE,GAAG,GAAG,IAAI,CAAA;IACtB;;OAEG;IACH,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;IACpC;;OAEG;IACH,UAAU,EAAE,OAAO,CAAA;IACnB;;OAEG;IACH,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACvC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAA;CAClB;AAID,wBAAgB,sBAAsB,IAAI,wBAAwB,GAAG,IAAI,CAExE;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACvC,UAAU,EAAE,GAAG,GAAG,IAAI,CAAA;IACtB,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;CACrC;AAED,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,WAAW,EACX,UAAU,EACV,aAAa,GACd,EAAE,yBAAyB,2CAY3B"}

package/types/Sheet.d.ts

@@ -1,18 +1,18 @@
 export { createSheetScope } from './SheetContext';
 export * from './types';
-export declare const Handle: import("@hanzogui/core").GuiComponent<import("@hanzogui/core").TamaDefer, import("@hanzogui/core").GuiElement, import("@hanzogui/core").RNViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
+export declare const Handle: import("@hanzogui/core").GuiComponent<import("@hanzogui/core").TamaDefer, import("@hanzogui/core").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
     open?: boolean | undefined;
     unstyled?: boolean | undefined;
     elevation?: number | import("@hanzogui/core").SizeTokens | undefined;
     fullscreen?: boolean | undefined;
 }, import("@hanzogui/core").StaticConfigPublic>;
-export declare const Overlay: import("@hanzogui/core").GuiComponent<import("@hanzogui/core").TamaDefer, import("@hanzogui/core").GuiElement, import("@hanzogui/core").RNViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
+export declare const Overlay: import("@hanzogui/core").GuiComponent<import("@hanzogui/core").TamaDefer, import("@hanzogui/core").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
     open?: boolean | undefined;
     unstyled?: boolean | undefined;
     elevation?: number | import("@hanzogui/core").SizeTokens | undefined;
     fullscreen?: boolean | undefined;
 }, import("@hanzogui/core").StaticConfigPublic>;
-export declare const Frame: import("@hanzogui/core").GuiComponent<import("@hanzogui/core").TamaDefer, import("@hanzogui/core").GuiElement, import("@hanzogui/core").RNViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
+export declare const Frame: import("@hanzogui/core").GuiComponent<import("@hanzogui/core").TamaDefer, import("@hanzogui/core").GuiElement, import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
     unstyled?: boolean | undefined;
     elevation?: number | import("@hanzogui/core").SizeTokens | undefined;
     fullscreen?: boolean | undefined;
@@ -34,6 +34,7 @@ export declare const Sheet: import("react").ForwardRefExoticComponent<{
     transitionConfig?: import("@hanzogui/core").AnimatedNumberStrategy;
     preferAdaptParentOpenState?: boolean;
     unmountChildrenWhenHidden?: boolean;
+    disableTransparencyHide?: boolean;
     native?: "ios"[] | boolean;
     transition?: import("@hanzogui/core").TransitionProp;
     handleDisableScroll?: boolean;
@@ -50,7 +51,7 @@ export declare const Sheet: import("react").ForwardRefExoticComponent<{
     __scopeSheet?: import("@hanzogui/create-context").Scope<any>;
 } & import("react").RefAttributes<import("react-native").View>> & {
     Controlled: import("react").FunctionComponent<Omit<import("./types").SheetProps, "open" | "onOpenChange"> & import("react").RefAttributes<import("react-native").View>> & {
-        Frame: import("react").ForwardRefExoticComponent<import("./types").SheetScopedProps<Omit<import("@hanzogui/core").GetFinalProps<import("@hanzogui/core").RNViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
+        Frame: import("react").ForwardRefExoticComponent<import("./types").SheetScopedProps<Omit<import("@hanzogui/core").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
             unstyled?: boolean | undefined;
             elevation?: number | import("@hanzogui/core").SizeTokens | undefined;
             fullscreen?: boolean | undefined;
@@ -115,7 +116,7 @@ export declare const Sheet: import("react").ForwardRefExoticComponent<{
             fullscreen?: boolean | undefined;
         }>> & import("react").RefAttributes<import("react-native").ScrollView>>;
     };
-    Frame: import("react").ForwardRefExoticComponent<import("./types").SheetScopedProps<Omit<import("@hanzogui/core").GetFinalProps<import("@hanzogui/core").RNViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
+    Frame: import("react").ForwardRefExoticComponent<import("./types").SheetScopedProps<Omit<import("@hanzogui/core").GetFinalProps<import("@hanzogui/core").RNGuiViewNonStyleProps, import("@hanzogui/core").StackStyleBase, {
         unstyled?: boolean | undefined;
         elevation?: number | import("@hanzogui/core").SizeTokens | undefined;
         fullscreen?: boolean | undefined;

package/types/Sheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sheet.d.ts","sourceRoot":"","sources":["../src/Sheet.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,cAAc,SAAS,CAAA;AAMvB,eAAO,MAAM,MAAM;;;;;+CAmCjB,CAAA;AAMF,eAAO,MAAM,OAAO;;;;;+CA2BlB,CAAA;AAMF,eAAO,MAAM,KAAK;;;;+CAoBhB,CAAA;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}
+{"version":3,"file":"Sheet.d.ts","sourceRoot":"","sources":["../src/Sheet.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,cAAc,SAAS,CAAA;AAMvB,eAAO,MAAM,MAAM;;;;;+CAmCjB,CAAA;AAMF,eAAO,MAAM,OAAO;;;;;+CA2BlB,CAAA;AAMF,eAAO,MAAM,KAAK;;;;+CAoBhB,CAAA;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}

package/types/SheetContext.d.ts

@@ -2,7 +2,7 @@ import type { SheetContextValue } from './useSheetProviderProps';
 export declare const createSheetContext: <ContextValueType extends object | null>(rootComponentName: string, defaultContext?: ContextValueType) => readonly [(props: ContextValueType & {
     scope: import("@hanzogui/create-context").Scope<ContextValueType>;
     children: React.ReactNode;
-}) => import("react").JSX.Element, (consumerName: string, scope: import("@hanzogui/create-context").Scope<ContextValueType | undefined>, options?: {
+}) => import("react/jsx-runtime").JSX.Element, (consumerName: string, scope: import("@hanzogui/create-context").Scope<ContextValueType | undefined>, options?: {
     warn?: boolean;
     fallback?: Partial<ContextValueType>;
 }) => ContextValueType], createSheetScope: import("@hanzogui/create-context").CreateScope;
@@ -32,11 +32,14 @@ export declare const SheetProvider: (props: {
     setPositionImmediate: import("react").Dispatch<import("react").SetStateAction<number>>;
     onlyShowFrame: boolean;
 } & {
+    keyboardOccludedHeight: number;
+    isKeyboardVisible: boolean;
+    keyboardStableFrameHeight: number;
     setHasScrollView: (val: boolean) => void;
 } & {
     scope: import("@hanzogui/create-context").Scope<SheetContextValue>;
     children: React.ReactNode;
-}) => import("react").JSX.Element, useSheetContext: (consumerName: string, scope: import("@hanzogui/create-context").Scope<SheetContextValue | undefined>, options?: {
+}) => import("react/jsx-runtime").JSX.Element, useSheetContext: (consumerName: string, scope: import("@hanzogui/create-context").Scope<SheetContextValue | undefined>, options?: {
     warn?: boolean;
     fallback?: Partial<SheetContextValue> | undefined;
 } | undefined) => SheetContextValue;

package/types/SheetContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SheetContext.d.ts","sourceRoot":"","sources":["../src/SheetContext.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,eAAO,MAAO,kBAAkB;;;gJAM2rB,CAAC;QAAS,CAAC;YAAoB,CAAC;yBANztB,gBAAgB,gDAAkC,CAAA;AAEpF,eAAO,MAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAE,eAAe;;;mCAG3C,CAAA"}
+{"version":3,"file":"SheetContext.d.ts","sourceRoot":"","sources":["../src/SheetContext.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,eAAO,MAAO,kBAAkB;;;4JAM2rB,CAAC;QAAS,CAAC;YAAoB,CAAC;yBANztB,gBAAgB,gDAAkC,CAAA;AAEpF,eAAO,MAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CAAE,eAAe;;;mCAG3C,CAAA"}

package/types/SheetController.d.ts

@@ -1,7 +1,6 @@
-import React from 'react';
 import type { ReactNode } from 'react';
 import type { SheetControllerContextValue } from './useSheetController';
 export declare const SheetController: ({ children, onOpenChange: onOpenChangeProp, onAnimationComplete: onAnimationCompleteProp, open, hidden, disableDrag, }: Partial<SheetControllerContextValue> & {
     children?: ReactNode;
-}) => React.JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=SheetController.d.ts.map

package/types/SheetController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SheetController.d.ts","sourceRoot":"","sources":["../src/SheetController.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwB,MAAM,OAAO,CAAA;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAA;AAGvE,eAAO,MAAM,eAAe,GAAI,wHAO7B,OAAO,CAAC,2BAA2B,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,sBAgCjE,CAAA"}
+{"version":3,"file":"SheetController.d.ts","sourceRoot":"","sources":["../src/SheetController.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAA;AAGvE,eAAO,MAAM,eAAe,GAAI,wHAO7B,OAAO,CAAC,2BAA2B,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,4CAgCjE,CAAA"}

package/types/SheetImplementationCustom.d.ts

@@ -18,6 +18,7 @@ export declare const SheetImplementationCustom: React.ForwardRefExoticComponent<
     transitionConfig?: import("@hanzogui/core").AnimatedNumberStrategy;
     preferAdaptParentOpenState?: boolean;
     unmountChildrenWhenHidden?: boolean;
+    disableTransparencyHide?: boolean;
     native?: "ios"[] | boolean;
     transition?: import("@hanzogui/core").TransitionProp;
     handleDisableScroll?: boolean;

package/types/SheetImplementationCustom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SheetImplementationCustom.d.ts","sourceRoot":"","sources":["../src/SheetImplementationCustom.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAOvC,OAAO,EAA4B,IAAI,EAAE,MAAM,cAAc,CAAA;AAM7D,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,SAAS,CAAA;AAsBzD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA8wBrC,CAAA"}
+{"version":3,"file":"SheetImplementationCustom.d.ts","sourceRoot":"","sources":["../src/SheetImplementationCustom.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAOvC,OAAO,EAA4B,IAAI,EAAE,MAAM,cAAc,CAAA;AAmB7D,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,SAAS,CAAA;AAmCzD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAy/BrC,CAAA"}

package/types/SheetScrollView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SheetScrollView.d.ts","sourceRoot":"","sources":["../src/SheetScrollView.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAsC,MAAM,OAAO,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,cAAc,CAAA;AAS9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmL3B,CAAA"}
+{"version":3,"file":"SheetScrollView.d.ts","sourceRoot":"","sources":["../src/SheetScrollView.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAsC,MAAM,OAAO,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,IAAI,YAAY,EAAE,MAAM,cAAc,CAAA;AAgB9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAyV3B,CAAA"}

package/types/createSheet.d.ts

@@ -28,6 +28,7 @@ export declare function createSheet<H extends GuiComponent | SheetStyledComponen
     transitionConfig?: import("@hanzogui/core").AnimatedNumberStrategy;
     preferAdaptParentOpenState?: boolean;
     unmountChildrenWhenHidden?: boolean;
+    disableTransparencyHide?: boolean;
     native?: "ios"[] | boolean;
     transition?: import("@hanzogui/core").TransitionProp;
     handleDisableScroll?: boolean;
@@ -46,9 +47,9 @@ export declare function createSheet<H extends GuiComponent | SheetStyledComponen
     Controlled: FunctionComponent<Omit<SheetProps, "open" | "onOpenChange"> & RefAttributes<RNView>> & {
         Frame: ForwardRefExoticComponent<SheetScopedProps<Omit<GetProps<F>, keyof {
             /**
-             * By default the sheet adds a view below its bottom that extends down another 50%,
-             * this is useful if your Sheet has a spring animation that bounces "past" the top when
-             * opening, preventing it from showing the content underneath.
+             * by default the sheet adds a view below its bottom that extends past the
+             * largest visible viewport height. this covers spring overshoot when opening
+             * so page content never shows through below the sheet.
              */
             disableHideBottomOverflow?: boolean;
             /**
@@ -59,9 +60,9 @@ export declare function createSheet<H extends GuiComponent | SheetStyledComponen
             adjustPaddingForOffscreenContent?: boolean;
         }> & {
             /**
-             * By default the sheet adds a view below its bottom that extends down another 50%,
-             * this is useful if your Sheet has a spring animation that bounces "past" the top when
-             * opening, preventing it from showing the content underneath.
+             * by default the sheet adds a view below its bottom that extends past the
+             * largest visible viewport height. this covers spring overshoot when opening
+             * so page content never shows through below the sheet.
              */
             disableHideBottomOverflow?: boolean;
             /**
@@ -119,9 +120,9 @@ export declare function createSheet<H extends GuiComponent | SheetStyledComponen
     };
     Frame: ForwardRefExoticComponent<SheetScopedProps<Omit<GetProps<F>, keyof {
         /**
-         * By default the sheet adds a view below its bottom that extends down another 50%,
-         * this is useful if your Sheet has a spring animation that bounces "past" the top when
-         * opening, preventing it from showing the content underneath.
+         * by default the sheet adds a view below its bottom that extends past the
+         * largest visible viewport height. this covers spring overshoot when opening
+         * so page content never shows through below the sheet.
          */
         disableHideBottomOverflow?: boolean;
         /**
@@ -132,9 +133,9 @@ export declare function createSheet<H extends GuiComponent | SheetStyledComponen
         adjustPaddingForOffscreenContent?: boolean;
     }> & {
         /**
-         * By default the sheet adds a view below its bottom that extends down another 50%,
-         * this is useful if your Sheet has a spring animation that bounces "past" the top when
-         * opening, preventing it from showing the content underneath.
+         * by default the sheet adds a view below its bottom that extends past the
+         * largest visible viewport height. this covers spring overshoot when opening
+         * so page content never shows through below the sheet.
          */
         disableHideBottomOverflow?: boolean;
         /**

package/types/createSheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSheet.d.ts","sourceRoot":"","sources":["../src/createSheet.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,6BAA6B,EAE9B,MAAM,gBAAgB,CAAA;AAOvB,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAExF,OAAO,KAAK,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,cAAc,CAAA;AAOlD,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAI3D,KAAK,gBAAgB,GAAG;IACtB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,KAAK,SAAS,GAAG,SAAS,GAAG,gBAAgB,CAAA;AAE7C,KAAK,oBAAoB,GAAG,6BAA6B,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAA;AAEtF,wBAAgB,WAAW,CACzB,CAAC,SAAS,YAAY,GAAG,oBAAoB,EAC7C,CAAC,SAAS,YAAY,GAAG,oBAAoB,EAC7C,CAAC,SAAS,YAAY,GAAG,oBAAoB,EAC7C,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiG7D;;;;eAIG;wCACyB,OAAO;YAEnC;;;;eAIG;+CACgC,OAAO;;YAZ1C;;;;eAIG;wCACyB,OAAO;YAEnC;;;;eAIG;+CACgC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAZ1C;;;;WAIG;oCACyB,OAAO;QAEnC;;;;WAIG;2CACgC,OAAO;;QAZ1C;;;;WAIG;oCACyB,OAAO;QAEnC;;;;WAIG;2CACgC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgJ7C"}
+{"version":3,"file":"createSheet.d.ts","sourceRoot":"","sources":["../src/createSheet.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,6BAA6B,EAE9B,MAAM,gBAAgB,CAAA;AAOvB,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAExF,OAAO,KAAK,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,cAAc,CAAA;AAOlD,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAK3D,KAAK,gBAAgB,GAAG;IACtB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,KAAK,SAAS,GAAG,SAAS,GAAG,gBAAgB,CAAA;AAE7C,KAAK,oBAAoB,GAAG,6BAA6B,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAA;AAEtF,wBAAgB,WAAW,CACzB,CAAC,SAAS,YAAY,GAAG,oBAAoB,EAC7C,CAAC,SAAS,YAAY,GAAG,oBAAoB,EAC7C,CAAC,SAAS,YAAY,GAAG,oBAAoB,EAC7C,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkG7D;;;;eAIG;wCACyB,OAAO;YAEnC;;;;eAIG;+CACgC,OAAO;;YAZ1C;;;;eAIG;wCACyB,OAAO;YAEnC;;;;eAIG;+CACgC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAZ1C;;;;WAIG;oCACyB,OAAO;QAEnC;;;;WAIG;2CACgC,OAAO;;QAZ1C;;;;WAIG;oCACyB,OAAO;QAEnC;;;;WAIG;2CACgC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2J7C"}

package/types/gestureState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gestureState.d.ts","sourceRoot":"","sources":["../src/gestureState.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEvE,YAAY,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAG3E,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED,wBAAgB,sBAAsB,IAAI,YAAY,CAErD;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAE3E;AAGD,eAAO,MAAM,eAAe,+BAAyB,CAAA"}
+{"version":3,"file":"gestureState.d.ts","sourceRoot":"","sources":["../src/gestureState.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEvE,YAAY,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAa3E,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED,wBAAgB,sBAAsB,IAAI,YAAY,CAErD;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAY3E;AAGD,eAAO,MAAM,eAAe,+BAAyB,CAAA"}