@rafaelaugusto/jolt 0.1.0-beta.15 → 0.1.0-beta.17

package/src/bottom-sheet/native.ts

@@ -0,0 +1,214 @@
+import {
+  Application,
+  Screen,
+  Utils,
+  isIOS,
+  type ScrollView,
+  type View,
+} from '@nativescript/core'
+
+function firstResponder(view: UIView): UIView | undefined {
+  if (view.isFirstResponder) return view
+  for (let i = 0; i < view.subviews.count; i++) {
+    const found = firstResponder(view.subviews.objectAtIndex(i))
+    if (found) return found
+  }
+  return undefined
+}
+
+export function windowHeight(view: View): number {
+  if (isIOS)
+    return (
+      (view.nativeViewProtected as UIView)?.window?.bounds.size.height ??
+      Screen.mainScreen.heightDIPs
+    )
+  const activity =
+    Application.android.foregroundActivity ?? Application.android.startActivity
+  if (android.os.Build.VERSION.SDK_INT >= 30 && activity)
+    return (
+      activity.getWindowManager().getCurrentWindowMetrics().getBounds().height() /
+      Utils.layout.getDisplayDensity()
+    )
+  return Screen.mainScreen.heightDIPs
+}
+
+export function captureFocus(panel: View, returnFocus?: View): () => void {
+  if (returnFocus)
+    return () => {
+      if (!returnFocus.isLoaded) return
+      returnFocus.focus()
+      returnFocus.accessibilityScreenChanged()
+    }
+  if (isIOS) {
+    const window = (panel.nativeViewProtected as UIView)?.window
+    const responder = window ? firstResponder(window) : undefined
+    const accessible = UIAccessibilityFocusedElement(null)
+    return () => {
+      if (responder?.window) responder.becomeFirstResponder()
+      UIAccessibilityPostNotification(
+        UIAccessibilityLayoutChangedNotification,
+        accessible ?? responder ?? null,
+      )
+    }
+  }
+  const activity =
+    Application.android.foregroundActivity ?? Application.android.startActivity
+  const previous = activity?.getCurrentFocus()
+  return () => {
+    if (previous?.isAttachedToWindow()) {
+      previous.requestFocus()
+      previous.sendAccessibilityEvent(
+        android.view.accessibility.AccessibilityEvent.TYPE_VIEW_FOCUSED,
+      )
+    }
+  }
+}
+
+export function revealFocusedField(panel: View, scroll?: ScrollView): void {
+  if (!scroll?.nativeViewProtected || !panel.nativeViewProtected) return
+  if (isIOS) {
+    const focused = firstResponder(panel.nativeViewProtected as UIView)
+    const native = scroll.nativeViewProtected as UIScrollView
+    if (focused?.isDescendantOfView(native))
+      native.scrollRectToVisibleAnimated(
+        focused.convertRectToView(focused.bounds, native),
+        false,
+      )
+  } else {
+    const focused = (panel.nativeViewProtected as android.view.View).findFocus()
+    if (focused)
+      focused.requestRectangleOnScreen(
+        new android.graphics.Rect(0, 0, focused.getWidth(), focused.getHeight()),
+        true,
+      )
+  }
+}
+
+export function dismissKeyboard(panel: View): void {
+  if (!panel.nativeViewProtected) return
+  if (isIOS) (panel.nativeViewProtected as UIView).endEditing(true)
+  else {
+    const focused = (panel.nativeViewProtected as android.view.View).findFocus()
+    if (focused) {
+      const manager = focused
+        .getContext()
+        .getSystemService(
+          android.content.Context.INPUT_METHOD_SERVICE,
+        ) as android.view.inputmethod.InputMethodManager
+      manager.hideSoftInputFromWindow(focused.getWindowToken(), 0)
+      focused.clearFocus()
+    }
+  }
+}
+
+/** Add only our actions; preserve an application's existing native accessibility actions. */
+export function sheetActions(
+  handle: View,
+  actions: readonly { label: string; run(): void }[],
+): () => void {
+  if (isIOS) {
+    const native = handle.nativeViewProtected as UIView
+    const previous = native.accessibilityCustomActions
+    const own = actions.map(({ label, run }) =>
+      UIAccessibilityCustomAction.alloc().initWithNameActionHandler(label, () => {
+        run()
+        return true
+      }),
+    )
+    const existing: UIAccessibilityCustomAction[] = []
+    if (previous)
+      for (let i = 0; i < previous.count; i++) existing.push(previous.objectAtIndex(i))
+    native.accessibilityCustomActions = NSArray.arrayWithArray([...existing, ...own])
+    return () => {
+      const current = native.accessibilityCustomActions
+      const retained: UIAccessibilityCustomAction[] = []
+      if (current)
+        for (let i = 0; i < current.count; i++) {
+          const action = current.objectAtIndex(i)
+          if (!own.includes(action)) retained.push(action)
+        }
+      native.accessibilityCustomActions = retained.length
+        ? NSArray.arrayWithArray(retained)
+        : null
+    }
+  }
+  const native = handle.nativeViewProtected as android.view.View
+  const compat = androidx.core.view.ViewCompat
+  const ids: number[] = []
+  let ended = false,
+    timer: ReturnType<typeof setTimeout> | undefined
+  // Core batches accessibility-style updates in a microtask and installs its delegate.
+  // Wrap that delegate afterwards, retaining its semantics and all existing actions.
+  const repair = () => {
+    if (ended || handle.nativeViewProtected !== native) return
+    compat.setAccessibilityDelegate(
+      native,
+      compat.getAccessibilityDelegate(native) ??
+        new androidx.core.view.AccessibilityDelegateCompat(),
+    )
+    if (ids.length) return
+    const node = native.createAccessibilityNodeInfo(),
+      existing = node.getActionList()
+    const used = new Set<number>()
+    for (let index = 0; index < existing.size(); index++)
+      used.add(existing.get(index).getId())
+    node.recycle()
+    const resources = native.getResources(),
+      packageName = native.getContext().getPackageName()
+    const available: number[] = []
+    for (let index = 0; index < 32; index++) {
+      const id = resources.getIdentifier(
+        `accessibility_custom_action_${index}`,
+        'id',
+        packageName,
+      )
+      if (id && !used.has(id)) available.push(id)
+    }
+    if (available.length < actions.length)
+      throw new Error(
+        'Not enough free Android accessibility actions for the sheet handle.',
+      )
+    for (let index = 0; index < actions.length; index++) {
+      const { label, run } = actions[index]!,
+        id = available[index]!
+      const action =
+        new androidx.core.view.accessibility.AccessibilityNodeInfoCompat.AccessibilityActionCompat(
+          id,
+          label,
+        )
+      compat.replaceAccessibilityAction(
+        native,
+        action,
+        label,
+        new androidx.core.view.accessibility.AccessibilityViewCommand({
+          perform: () => {
+            run()
+            return true
+          },
+        }),
+      )
+      ids.push(id)
+    }
+  }
+  const schedule = () => {
+    if (ended || timer !== undefined) return
+    timer = setTimeout(() => {
+      timer = undefined
+      repair()
+    }, 0)
+  }
+  const changes = [
+    'accessibleChange',
+    'accessibilityRoleChange',
+    'accessibilityStateChange',
+    'accessibilityMediaSessionChange',
+  ]
+  for (const event of changes) handle.style.on(event, schedule)
+  schedule()
+  return () => {
+    ended = true
+    if (timer !== undefined) clearTimeout(timer)
+    for (const event of changes) handle.style.off(event, schedule)
+    ids.forEach((id) => compat.removeAccessibilityAction(native, id))
+  }
+}

package/src/drag.ts

@@ -428,7 +428,7 @@ class DragController implements Drag {
     const [axis] = this.config.axes
     const value = this.config.value
     const animation = value
-      ? value.play(createTrack(axis!, [event[axis!]], plans[0]!.transition, 0))
+      ? value.playTrack(createTrack(axis!, [event[axis!]], plans[0]!.transition, 0))
       : new ViewAnimation(this.view, plans)
     this.release = animation
     void animation.finished.then((finished) => {

package/src/driver/android.ts

@@ -4,6 +4,7 @@ import {
   type AndroidPlayback,
 } from './android-playback.js'
 import { isDecorationProperty } from '../decoration.js'
+import { syncLiveSprings } from '../live-spring-driver.js'
 import {
   syncAndroidDecoration,
   playAndroidDecoration,
@@ -188,6 +189,7 @@ export function createAndroidDriver(): Driver {
     sync(view) {
       syncAndroidDecoration(view)
       syncAndroidColor(view)
+      syncLiveSprings(view)
     },
 
     elapsed: (handle) => (handle as Handle).elapsed(),

package/src/driver/ios-scroll-delegate.ts

@@ -0,0 +1,23 @@
+import type { ScrollView } from '@nativescript/core'
+
+/** Preserve Core's lazy scroll listener attach/detach without adding a JS scroll observer. */
+export function retainScrollDelegate(scroll: ScrollView, refresh: () => void) {
+  const host = scroll as ScrollView & { attachNative(): void; detachNative(): void }
+  const restore: (() => void)[] = []
+  for (const key of ['attachNative', 'detachNative'] as const) {
+    const original = host[key]
+    if (typeof original !== 'function') continue
+    const descriptor = Object.getOwnPropertyDescriptor(host, key)
+    const wrapper = function (this: typeof host) {
+      original.call(this)
+      refresh()
+    }
+    host[key] = wrapper
+    restore.push(() => {
+      if (host[key] !== wrapper) return
+      if (descriptor) Object.defineProperty(host, key, descriptor)
+      else delete (host as Partial<typeof host>)[key]
+    })
+  }
+  return () => restore.forEach((action) => action())
+}

package/src/driver/ios.ts

@@ -1,4 +1,5 @@
 import { iosPlayback } from './ios-playback.js'
+import { syncLiveSprings } from '../live-spring-driver.js'
 import { isDecorationProperty } from '../decoration.js'
 import {
   playIOSDecoration,
@@ -197,6 +198,7 @@ export function createIOSDriver(): Driver {
           view.nativeViewProtected,
           excluding ? (keyPaths[excluding as NumericProperty] ?? null) : null,
         )
+      syncLiveSprings(view)
     },
 
     presented(view, property) {

package/src/gesture-native.ts

@@ -0,0 +1,139 @@
+import { isIOS, type View, type ScrollView } from '@nativescript/core'
+import { liveValueInput, type DerivedValue } from './motion-value.js'
+import { nativeLiveNode } from './live-spring-driver.js'
+import { retainScrollDelegate } from './driver/ios-scroll-delegate.js'
+
+export interface GestureSettings {
+  axis: number
+  threshold: number
+  failOffset: number
+  pinch: boolean
+  rotate: boolean
+  tap: boolean
+  doubleTap: boolean
+  contactEvents: boolean
+  minX: number
+  maxX: number
+  minY: number
+  maxY: number
+  minScale: number
+  maxScale: number
+}
+export interface GestureDriver {
+  readonly active: boolean
+  cancel(): void
+  enabled(value: boolean): void
+  settle(values: readonly number[], animated: boolean): void
+  bounds(settings: GestureSettings): void
+  dispose(): void
+}
+export function createGestureDriver(
+  surface: View,
+  scroll: ScrollView | undefined,
+  values: readonly DerivedValue[],
+  options: GestureSettings,
+  callback: (state: number, vx: number, vy: number) => void,
+): GestureDriver {
+  const inputs = values.map(liveValueInput)
+  const nodes = inputs.map((input) => nativeLiveNode(input.node))
+  const changed = (state: number, vx: number, vy: number) => {
+    for (const input of inputs) input.changed()
+    callback(state, vx, vy)
+  }
+  const json = JSON.stringify(options)
+  if (isIOS) {
+    if (typeof JoltGestureSession === 'undefined')
+      throw new Error('Rebuild the native app to use gestures().')
+    if (
+      options.contactEvents &&
+      typeof JoltGestureSession.supportsContactEvents !== 'function'
+    )
+      throw new Error(
+        'Rebuild the native app to use gesture contact events and bottomSheet().',
+      )
+    const [x, y, scale, rotation] = nodes as [
+      JoltLiveSpring,
+      JoltLiveSpring,
+      JoltLiveSpring,
+      JoltLiveSpring,
+    ]
+    const native = JoltGestureSession.attachScrollXYScaleRotationOptionsOnState(
+      surface.nativeViewProtected,
+      scroll?.nativeViewProtected ?? null,
+      x,
+      y,
+      scale,
+      rotation,
+      json,
+      changed,
+    )
+    const releaseDelegate = scroll
+      ? retainScrollDelegate(scroll, () => native.refreshScrollDelegate())
+      : () => {}
+    return {
+      get active() {
+        return native.active
+      },
+      cancel: () => native.cancel(),
+      enabled: (value) => native.setEnabled(value),
+      settle: (values, animated) => {
+        native.settleXYScaleRotationAnimated(
+          values[0]!,
+          values[1]!,
+          values[2]!,
+          values[3]!,
+          animated,
+        )
+        inputs.forEach((input) => input.changed())
+      },
+      bounds: (settings) =>
+        native.updateLeftRightTopBottom(
+          settings.minX,
+          settings.maxX,
+          settings.minY,
+          settings.maxY,
+        ),
+      dispose: () => {
+        releaseDelegate()
+        native.dispose()
+      },
+    }
+  }
+  if (
+    options.contactEvents &&
+    typeof org.rafaelaugusto.jolt.GestureSession.supportsContactEvents !== 'function'
+  )
+    throw new Error(
+      'Rebuild the native app to use gesture contact events and bottomSheet().',
+    )
+  const [x, y, scale, rotation] = nodes as [
+    org.rafaelaugusto.jolt.LiveSpring,
+    org.rafaelaugusto.jolt.LiveSpring,
+    org.rafaelaugusto.jolt.LiveSpring,
+    org.rafaelaugusto.jolt.LiveSpring,
+  ]
+  const native = new org.rafaelaugusto.jolt.GestureSession(
+    surface.nativeViewProtected,
+    scroll?.nativeViewProtected ?? null,
+    x,
+    y,
+    scale,
+    rotation,
+    json,
+    new org.rafaelaugusto.jolt.GestureSession.Listener({ onState: changed }),
+  )
+  return {
+    get active() {
+      return native.isActive()
+    },
+    cancel: () => native.cancel(),
+    enabled: (value) => native.setEnabled(value),
+    settle: (values, animated) => {
+      native.settle(values[0]!, values[1]!, values[2]!, values[3]!, animated)
+      inputs.forEach((input) => input.changed())
+    },
+    bounds: (settings) =>
+      native.updateBounds(settings.minX, settings.maxX, settings.minY, settings.maxY),
+    dispose: () => native.dispose(),
+  }
+}