@rafaelaugusto/jolt 0.1.0-beta.16 → 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/gesture-native.ts

@@ -11,6 +11,7 @@ export interface GestureSettings {
   rotate: boolean
   tap: boolean
   doubleTap: boolean
+  contactEvents: boolean
   minX: number
   maxX: number
   minY: number
@@ -43,6 +44,13 @@ export function createGestureDriver(
   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,
@@ -91,6 +99,13 @@ export function createGestureDriver(
       },
     }
   }
+  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,

package/src/gestures/index.ts

@@ -53,6 +53,10 @@ export interface GesturesOptions {
   spring?: Pick<SpringValueOptions, 'stiffness' | 'damping' | 'mass'>
   /** A descendant, vertical NativeScript ScrollView. Other list plugins are not supported. */
   scrollView?: ScrollView
+  /** First contact, before pan recognition; useful when a touch interrupts a spring. */
+  onContactStart?: (event: GestureEvent) => void
+  /** Last contact released or cancelled, including a touch that never becomes a pan. */
+  onContactEnd?: (event: GestureEvent) => void
   onStart?: (event: GestureEvent) => void
   onEnd?: (event: GestureEvent) => void
   onCancel?: (event: GestureEvent) => void
@@ -106,7 +110,15 @@ function settings(options: GesturesOptions): GestureSettings {
       throw new TypeError(`Gesture ${key} must be boolean or an options object.`)
   if (options.rotate !== undefined && typeof options.rotate !== 'boolean')
     throw new TypeError('Gesture rotate must be boolean.')
-  for (const key of ['onStart', 'onEnd', 'onCancel', 'onTap', 'onDoubleTap'] as const)
+  for (const key of [
+    'onStart',
+    'onEnd',
+    'onCancel',
+    'onTap',
+    'onDoubleTap',
+    'onContactStart',
+    'onContactEnd',
+  ] as const)
     if (options[key] !== undefined && typeof options[key] !== 'function')
       throw new TypeError(`Gesture ${key} must be a function.`)
   const pan = typeof options.pan === 'object' ? options.pan : {}
@@ -123,6 +135,7 @@ function settings(options: GesturesOptions): GestureSettings {
     rotate: !!options.rotate,
     tap: !!options.onTap,
     doubleTap: !!options.onDoubleTap,
+    contactEvents: !!(options.onContactStart || options.onContactEnd),
     minScale: pinch.min ?? 0.25,
     maxScale: pinch.max ?? 4,
   }
@@ -201,6 +214,8 @@ export function gestures(
       options.onCancel,
       options.onTap,
       options.onDoubleTap,
+      options.onContactStart,
+      options.onContactEnd,
     ][state]
     try {
       handler?.(event)

package/src/ios-plugin.d.ts

@@ -1,4 +1,21 @@
+declare class JoltReorderHandle extends UIButton {
+  onMove: ((direction: number) => void) | null
+}
+declare class JoltReorderSession extends NSObject {
+  static attachOptionsOnState(
+    list: UITableView,
+    options: string,
+    callback: (state: number, index: number, toIndex: number) => void,
+  ): JoltReorderSession
+  readonly active: boolean
+  registerHandle(view: UIView): void
+  setEnabled(enabled: boolean): void
+  setReducedMotion(reduced: boolean): void
+  cancel(): void
+  dispose(): void
+}
 declare class JoltGestureSession extends NSObject {
+  static supportsContactEvents(): boolean
   static attachScrollXYScaleRotationOptionsOnState(
     surface: UIView,
     scroll: UIScrollView | null,
@@ -180,3 +197,18 @@ declare class JoltReferenceProperties extends NSObject {
   static sceneAppearanceSinkCount(): number
   static sceneAppearanceWriteCount(): number
 }
+
+declare class JoltSceneShaderProperties extends NSObject {
+  static environmentError(
+    scene: NSObject,
+    error: interop.Reference<NSError>,
+  ): JoltPropertySink | null
+  static uniformNameConfigurationError(
+    target: NSObject,
+    name: string,
+    configuration: string,
+    error: interop.Reference<NSError>,
+  ): JoltPropertySink | null
+  static sinkCount(): number
+  static writeCount(): number
+}

package/src/native/index.ts

@@ -22,3 +22,9 @@ export {
   sceneKitMaterialDiffuse,
   sceneKitMaterialEmission,
 } from '../scene-appearance.js'
+export { sceneKitEnvironmentIntensity, sceneKitUniform } from '../scene-shader.js'
+export type {
+  SceneUniformType,
+  SceneUniformValue,
+  SceneUniformOptions,
+} from '../scene-shader.js'

package/src/native-property.ts

@@ -56,10 +56,16 @@ const owners = new WeakMap<object, Map<string, Owner>>()
 export function registerNativeProperty<T>(
   definition: NativePropertyDefinition<T>,
 ): (target: object) => NativeProperty<T> {
-  if (!/^[\w.-]+\/[\w.-]+$/.test(definition.name))
-    throw new TypeError('Native property names must be namespaced: plugin/property.')
+  validateDefinition(definition)
   if (definitions.has(definition.name))
     throw new Error(`Native property "${definition.name}" is already registered.`)
+  definitions.add(definition.name)
+  return (target) => new PropertyTarget(target, definition)
+}
+
+function validateDefinition<T>(definition: NativePropertyDefinition<T>) {
+  if (!/^[\w.-]+\/[\w.-]+$/.test(definition.name))
+    throw new TypeError('Native property names must be namespaced: plugin/property.')
   if (
     !definition.units.length ||
     definition.units.some((unit) => typeof unit !== 'string' || !unit)
@@ -76,8 +82,15 @@ export function registerNativeProperty<T>(
     typeof definition.decode !== 'function'
   )
     throw new TypeError('A native property needs create(), encode() and decode().')
-  definitions.add(definition.name)
-  return (target) => new PropertyTarget(target, definition)
+}
+
+/** Internal factory for per-target schemas; identity still shares the registry ownership map. */
+export function nativePropertyTarget<T>(
+  target: object,
+  definition: NativePropertyDefinition<T>,
+): NativeProperty<T> {
+  validateDefinition(definition)
+  return new PropertyTarget(target, definition)
 }
 
 class PropertyTarget<T> implements NativeProperty<T> {

package/src/reorder/handle.ts

@@ -0,0 +1,9 @@
+import { Button, isIOS } from '@nativescript/core'
+
+/** Focusable native handle: Alt/Option + ↑/↓ moves its current item. */
+export class ReorderHandle extends Button {
+  override createNativeView(): ReturnType<Button['createNativeView']> {
+    if (isIOS) return JoltReorderHandle.new()
+    return new org.rafaelaugusto.jolt.ReorderHandle(this._context)
+  }
+}

package/src/reorder/index.ts

@@ -0,0 +1,243 @@
+import { Application, ListView, Trace, type View } from '@nativescript/core'
+import { onReducedMotion, reducedMotion } from '../config.js'
+import { coreListAdapter } from './list-view.js'
+import { itemKeys, moveAt, sameKeys } from './model.js'
+import type {
+  Reorder,
+  ReorderAdapter,
+  ReorderAdapterDriver,
+  ReorderCancelReason,
+  ReorderKey,
+  ReorderNativeEvent,
+  ReorderOptions,
+} from './types.js'
+
+export { coreListAdapter }
+export { ReorderHandle } from './handle.js'
+export { ReorderSurface } from './surface.js'
+export type * from './types.js'
+
+const owners = new WeakMap<View, { dispose(): void }>()
+function report(callback: () => void) {
+  try {
+    callback()
+  } catch (error) {
+    Trace.write(
+      `Jolt reorder callback failed: ${String(error)}`,
+      Trace.categories.Error,
+      Trace.messageType.error,
+    )
+  }
+}
+
+/** Reorder a flat, vertical Core ListView, or an explicitly supported adapter. */
+export function reorder<T, K extends ReorderKey = ReorderKey>(
+  source: ListView | ReorderAdapter<T>,
+  options: ReorderOptions<T, K>,
+): Reorder<K> {
+  if (
+    !options ||
+    typeof options.key !== 'function' ||
+    typeof options.onCommit !== 'function'
+  )
+    throw new TypeError('reorder() requires key(item) and onCommit(move).')
+  const adapter = source instanceof ListView ? coreListAdapter<T>(source) : source
+  if (
+    !adapter?.view ||
+    typeof adapter.items !== 'function' ||
+    typeof adapter.subscribe !== 'function' ||
+    typeof adapter.attach !== 'function'
+  )
+    throw new TypeError('Provide a Core ListView or a ReorderAdapter.')
+  for (const callback of [options.onStart, options.onCancel])
+    if (callback !== undefined && typeof callback !== 'function')
+      throw new TypeError('Reorder callbacks must be functions.')
+  if (
+    options.handle !== undefined &&
+    typeof options.handle !== 'string' &&
+    typeof options.handle !== 'function'
+  )
+    throw new TypeError('The reorder handle must be a view id or resolver.')
+  const longPress = options.longPress ?? 350,
+    edgeSize = options.edge?.size ?? 72,
+    edgeSpeed = options.edge?.speed ?? 640
+  if (!Number.isFinite(longPress) || longPress < 150 || longPress > 2000)
+    throw new RangeError('Reorder longPress must be between 150 and 2000 ms.')
+  if (![edgeSize, edgeSpeed].every((value) => Number.isFinite(value) && value > 0))
+    throw new RangeError('Reorder edge size and speed must be positive finite numbers.')
+
+  const view = adapter.view
+  let keys = itemKeys(adapter.items(), options.key)
+  owners.get(view)?.dispose()
+  let driver: ReorderAdapterDriver | undefined,
+    active: { key: K; index: number; keys: K[] } | undefined,
+    disposed = false,
+    paused = false
+  const read = () => itemKeys(adapter.items(), options.key)
+
+  function cancel(reason: ReorderCancelReason) {
+    const previous = active
+    active = undefined
+    driver?.cancel()
+    if (previous) report(() => options.onCancel?.({ key: previous.key, reason }))
+  }
+  function refresh() {
+    if (disposed) return
+    let next: K[]
+    try {
+      next = read()
+    } catch (error) {
+      cancel('data-changed')
+      throw error
+    }
+    if (active) cancel(next.includes(active.key) ? 'data-changed' : 'removed')
+    keys = next
+  }
+  function event(event: ReorderNativeEvent) {
+    if (disposed || paused) return
+    if (event.type === 'start') {
+      keys = read()
+      const key = keys[event.index]
+      if (key === undefined) {
+        driver?.cancel()
+        return
+      }
+      active = { key, index: event.index, keys: [...keys] }
+      report(() => options.onStart?.(key))
+    } else if (event.type === 'cancel') {
+      cancel(event.geometryChanged ? 'geometry-changed' : 'cancelled')
+    } else {
+      const previous = active
+      if (!previous) return
+      const next = read()
+      if (!sameKeys(previous.keys, next) || event.index !== previous.index) {
+        cancel(next.includes(previous.key) ? 'data-changed' : 'removed')
+        keys = next
+        return
+      }
+      const move = moveAt(previous.keys, previous.index, event.toIndex)
+      active = undefined
+      if (move) report(() => options.onCommit(move))
+      else report(() => options.onCancel?.({ key: previous.key, reason: 'unchanged' }))
+      keys = read()
+    }
+  }
+  function moveTo(key: K, toIndex: number): boolean {
+    if (disposed || paused) return false
+    cancel('cancelled')
+    keys = read()
+    const move = moveAt(keys, keys.indexOf(key), toIndex)
+    if (!move) return false
+    report(() => options.onCommit(move))
+    keys = read()
+    return true
+  }
+  function attach() {
+    if (disposed || driver || !view.isLoaded) return
+    keys = read()
+    driver = adapter.attach({
+      handle: options.handle,
+      longPress,
+      edgeSize,
+      edgeSpeed,
+      reducedMotion: reducedMotion(),
+      accessibility: {
+        moveUp: options.accessibility?.moveUp ?? 'Move up',
+        moveDown: options.accessibility?.moveDown ?? 'Move down',
+      },
+      event: (input) => {
+        try {
+          event(input)
+        } catch (error) {
+          cancel('data-changed')
+          report(() => {
+            throw error
+          })
+        }
+      },
+      move: (index, direction) => {
+        keys = read()
+        const key = keys[index]
+        return key !== undefined && moveTo(key, index + direction) ? key : undefined
+      },
+      keyAt: (index) => keys[index],
+      indexOf: (key) => {
+        try {
+          return read().indexOf(key as K)
+        } catch {
+          return -1
+        }
+      },
+    })
+    driver.setEnabled(!paused)
+  }
+  function unload() {
+    cancel('unloaded')
+    driver?.dispose()
+    driver = undefined
+  }
+  const suspend = () => cancel('cancelled')
+  const releaseItems = adapter.subscribe(refresh)
+  const releaseReduced = onReducedMotion((value) => driver?.setReducedMotion(value))
+  const result: Reorder<K> = {
+    get activeKey() {
+      return active?.key
+    },
+    get disposed() {
+      return disposed
+    },
+    move(key, beforeKey) {
+      if (disposed || paused) return false
+      const current = read(),
+        from = current.indexOf(key)
+      if (from < 0 || beforeKey === key) return false
+      const before = beforeKey === null ? current.length : current.indexOf(beforeKey)
+      return before < 0 ? false : moveTo(key, before > from ? before - 1 : before)
+    },
+    moveUp(key) {
+      if (disposed || paused) return false
+      return moveTo(key, read().indexOf(key) - 1)
+    },
+    moveDown(key) {
+      if (disposed || paused) return false
+      return moveTo(key, read().indexOf(key) + 1)
+    },
+    cancel: () => cancel('cancelled'),
+    refresh,
+    pause() {
+      paused = true
+      cancel('disabled')
+      driver?.setEnabled(false)
+    },
+    play() {
+      if (!disposed) {
+        paused = false
+        driver?.setEnabled(true)
+      }
+    },
+    dispose() {
+      if (disposed) return
+      cancel('disposed')
+      disposed = true
+      driver?.dispose()
+      driver = undefined
+      releaseItems()
+      releaseReduced()
+      view.off('loaded', attach)
+      view.off('unloaded', unload)
+      Application.off(Application.suspendEvent, suspend)
+      if (owners.get(view) === result) owners.delete(view)
+    },
+  }
+  owners.set(view, result)
+  view.on('loaded', attach)
+  view.on('unloaded', unload)
+  Application.on(Application.suspendEvent, suspend)
+  try {
+    attach()
+  } catch (error) {
+    result.dispose()
+    throw error
+  }
+  return result
+}