@solidrt/core 0.0.60 → 0.0.62

package/src/long-press.ts

@@ -0,0 +1,137 @@
+// The long-press recognizer: a pointer held LONG_PRESS_MS without leaving
+// TAP_SLOP of its down fires while still down, then streams moves until
+// the lift (drag-after-long-press is the reorder idiom: the finger that
+// held a row now carries it).
+//
+// Arena: the down arms silently, no claim. A claim at the down would be
+// refused wherever a press already holds the pointer (the same node, or
+// an inner pressable), and the wanted behaviour there is the press
+// showing pressed and the long-press winning at the timer, so the steal
+// happens at the timer instead: the press is cancelled (its feedback
+// retracts, it never fires), an ancestor pan can no longer take the
+// finger, moves stream to the consumer. A pan that crossed its slop first
+// resolved the arena, so the timer's steal is refused and the recognizer
+// stands down: scrolling a list of long-pressable rows scrolls. Nested
+// long-presses resolve innermost-first for free: the inner timer was
+// registered first in the leaf-to-root walk. Options are read at event
+// time; cancel() retracts without an end; an unmount clears the timer and
+// the claim. Mouse and touch alike (a held button long-presses).
+//
+// The hold timer itself (createHoldTimer) is shared with the pointer
+// feed's longPress source, which pulses instead of stealing: the feed is
+// one arena claimant (its transform) and must stay so.
+
+import { onSettled } from "@solidjs/signals"
+import type { PointerEvent } from "./types"
+import { arena, type ArenaOwner } from "./arena"
+import { pastSlop, pointAt, type PointerPoint } from "./gesture"
+
+// Hold before a long-press fires: Flutter, iOS and Android's upper value.
+const LONG_PRESS_MS = 500
+
+export interface HoldTimerOptions {
+  /** Read when the timer is armed. */
+  ms?: () => number | undefined
+  onFire: (pointerId: number, at: PointerPoint, event: { shiftKey: boolean; ctrlKey: boolean; altKey: boolean; metaKey: boolean; button?: number }) => void
+}
+
+/** The arm / slop / timer machine under a long-press: one pointer at a
+ * time, disarmed by travel, by a lift, by a second pointer or by cancel(). */
+export function createHoldTimer(options: HoldTimerOptions) {
+  let armed: { id: number; at: PointerPoint; mods: { shiftKey: boolean; ctrlKey: boolean; altKey: boolean; metaKey: boolean; button?: number } } | null = null
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let disarm = () => {
+    if (timer !== null) clearTimeout(timer)
+    timer = null
+    armed = null
+  }
+  return {
+    /** The pointer armed right now, if any. */
+    armed: () => armed?.id ?? null,
+    down(e: PointerEvent) {
+      if (armed) {
+        // A second finger is not a long-press.
+        disarm()
+        return
+      }
+      let ms = options.ms?.() ?? LONG_PRESS_MS
+      armed = { id: e.pointerId, at: pointAt(e), mods: { shiftKey: e.shiftKey, ctrlKey: e.ctrlKey, altKey: e.altKey, metaKey: e.metaKey, button: e.button } }
+      timer = setTimeout(() => {
+        timer = null
+        let a = armed!
+        armed = null
+        options.onFire(a.id, a.at, a.mods)
+      }, ms)
+    },
+    move(e: PointerEvent) {
+      if (armed && armed.id === e.pointerId && pastSlop(e, armed.at)) disarm()
+    },
+    up(e: PointerEvent) {
+      if (armed && armed.id === e.pointerId) disarm()
+    },
+    cancel: disarm,
+  }
+}
+
+export interface LongPressOptions {
+  /** Hold before the fire, default 500 ms. */
+  ms?: number
+  /** Fired at the timer while the pointer is still down, with the down's
+   * position. */
+  onLongPress?: (at: PointerPoint) => void
+  /** Movement since the previous event after the fire, in the handler
+   * node's parent frame (createPan's frame rule). */
+  onLongPressMove?: (dx: number, dy: number) => void
+  /** The lift after a fire. */
+  onLongPressEnd?: () => void
+}
+
+export function createLongPress(options: LongPressOptions) {
+  // The pointer the long-press won, and its last delivered parent position.
+  let fired: number | null = null
+  let last: { x: number; y: number } | null = null
+  let hold = createHoldTimer({
+    ms: () => options.ms,
+    onFire: (id, at) => {
+      if (!arena.steal(id, owner)) return
+      fired = id
+      last = { x: at.parentX, y: at.parentY }
+      options.onLongPress?.(at)
+    },
+  })
+  let cancel = () => {
+    hold.cancel()
+    if (fired !== null) {
+      arena.release(fired, owner)
+      fired = null
+      last = null
+    }
+  }
+  let owner: ArenaOwner = { cancel }
+  onSettled(() => cancel)
+
+  let handlers = {
+    onPointerDown: (e: PointerEvent) => {
+      if (e.button != null && e.button !== 0) return
+      if (fired !== null) return
+      hold.down(e)
+    },
+    onPointerMove: (e: PointerEvent) => {
+      if (fired === e.pointerId && last) {
+        options.onLongPressMove?.(e.parentX - last.x, e.parentY - last.y)
+        last = { x: e.parentX, y: e.parentY }
+        return
+      }
+      hold.move(e)
+    },
+    onPointerUp: (e: PointerEvent) => {
+      if (fired === e.pointerId) {
+        cancel()
+        options.onLongPressEnd?.()
+        return
+      }
+      hold.up(e)
+    },
+  }
+  return { handlers, cancel }
+}

package/src/pan.ts

@@ -1,6 +1,8 @@
 import { onSettled } from "@solidjs/signals"
 import type { PointerEvent } from "./types"
 import { arena } from "./arena"
+import { createVelocityTracker, flingVelocity } from "./velocity"
+import type { Velocity } from "./velocity"
 
 // Movement in logical pixels before a pan activates. Below this a drag still
 // reads as a press (tap wiggle); crossing it is the positive evidence that the
@@ -26,7 +28,13 @@ export interface PanOptions {
    * Positive dx is rightward, positive dy downward.
    */
   onPanMove?: (dx: number, dy: number) => void
-  onPanEnd?: () => void
+  /**
+   * The lift, with the pointer's velocity at it in the same parent-frame
+   * pixels per second (a least-squares fit over the last 100 ms, see
+   * velocity.ts): the fling fact for whoever animates on. Zero when the
+   * finger rested before lifting or moved under FLING_MIN_VELOCITY.
+   */
+  onPanEnd?: (velocity: Velocity) => void
 }
 
 // The pan recognizer: turns a drag into a movement-delta stream. On a down it
@@ -36,8 +44,11 @@ export interface PanOptions {
 // resolving it so no other recognizer can take the drag over. If the arena is
 // already resolved (an inner pan won first) the recognizer disarms and stays
 // out. The slop distance itself is swallowed: deltas stream from the
-// activation point on. Moves and the up arrive on the frozen down path, so an
-// active pan keeps streaming when the pointer leaves the node or the window.
+// activation point on, and the up carries the lift velocity (velocity.ts: a
+// fit over the last 100 ms of positions, zero after a rest or under the
+// fling minimum) for momentum. Moves and the up arrive on the frozen down
+// path, so an active pan keeps streaming when the pointer leaves the node
+// or the window.
 // cancel() is the external-cancel hook; it ends an active pan without
 // onPanEnd. Options are read at event time. Single-pointer by design; for
 // multi-pointer pinch/rotate compose createTransform instead.
@@ -55,6 +66,8 @@ export function createPan(options: PanOptions) {
   let origin: { x: number; y: number } | null = null
   let active: number | null = null
   let armed: number | null = null
+  // Parent-frame positions of the active pointer, for the lift's velocity.
+  let tracker = createVelocityTracker()
 
   let past = (e: PointerEvent) => {
     if (!origin) return false
@@ -94,6 +107,8 @@ export function createPan(options: PanOptions) {
           active = e.pointerId
           armed = null
           origin = { x: e.parentX, y: e.parentY }
+          tracker.reset()
+          tracker.push(e.parentX, e.parentY)
           options.onPanStart?.()
         } else {
           // The arena is resolved against us; the drag belongs elsewhere.
@@ -102,14 +117,18 @@ export function createPan(options: PanOptions) {
         return
       }
       if (active === e.pointerId && origin) {
+        tracker.push(e.parentX, e.parentY)
         options.onPanMove?.(e.parentX - origin.x, e.parentY - origin.y)
         origin = { x: e.parentX, y: e.parentY }
       }
     },
     onPointerUp: (e: PointerEvent) => {
       if (active === e.pointerId) {
+        // The up is not a sample: it sits where the last move left the
+        // pointer, and its age is what tells a rest from a flick.
+        let velocity = flingVelocity(tracker.velocity())
         reset()
-        options.onPanEnd?.()
+        options.onPanEnd?.(velocity)
       } else if (armed === e.pointerId) {
         reset()
       }

package/src/renderer.ts

@@ -1,6 +1,8 @@
-import { createRoot, onCleanup, NotReadyError, untrack } from "@solidjs/signals"
+// createErrorBoundary comes from signals, not solid-js: solid-js marks it
+// @internal (an app writes <Errored>, a renderer reaches for the primitive)
+// and strips it from its .d.ts, so the solid-js re-export types as any.
+import { createErrorBoundary, createRoot, onCleanup, NotReadyError, untrack } from "@solidjs/signals"
 import { createRenderer } from "@solidjs/universal"
-import { createErrorBoundary } from "solid-js"
 import type { Element } from "solid-js"
 import * as tree from "flux:rendertree"
 import { attachWindow, setWindowRoot } from "./window"
@@ -116,6 +118,10 @@ function removeNode(parent: ProxyNode, node: ProxyNode): void {
 const SENTINEL_INTERVAL_MS = 5000
 let sentinelDue = 0
 let warnedLeakTypes = new Set<string>()
+// The orphan total's order of magnitude (floor of log10) at the last
+// warning: a leak that keeps growing at a stable set of types warns again
+// each time the total crosses the next power of ten.
+let warnedMagnitude = -1
 
 export function scanForOrphans(now: number): void {
   if (!import.meta.env.DEV) return
@@ -129,18 +135,22 @@ export function scanForOrphans(now: number): void {
     counts.set(node.elementType, (counts.get(node.elementType) ?? 0) + 1)
   }
   if (total === 0) return
-  // Warn only when a new element type joins the orphans, but list every type
-  // with its count so the breakdown always adds up to the total.
+  // Warn when a new element type joins the orphans or the total crosses the
+  // next order of magnitude, but list every type with its count so the
+  // breakdown always adds up to the total.
   let fresh = [...counts].filter(([type]) => !warnedLeakTypes.has(type))
-  if (fresh.length === 0) return
+  let magnitude = Math.floor(Math.log10(total))
+  if (fresh.length === 0 && magnitude <= warnedMagnitude) return
   for (let [type] of fresh) warnedLeakTypes.add(type)
+  warnedMagnitude = magnitude
   let list = [...counts].map(([type, n]) => `<${type}> x${n}`).join(", ")
   console.warn(
     `Leak sentinel: ${total} nodes are unreachable and will never be freed: ${list}. ` +
       `The usual cause is reading an element-valued prop more than once (every read ` +
       `builds a new subtree); read it once where it mounts, or resolve it with ` +
       `children(). If these nodes are intentionally kept for later mounting, ignore ` +
-      `this. The next warning comes when a new element type joins the list.`,
+      `this. The next warning comes when a new element type joins the list or the ` +
+      `total passes ${10 ** (magnitude + 1)}.`,
   )
 }
 

package/src/runtime-modules.d.ts

@@ -51,6 +51,10 @@ declare module "*.glb" {
   const bytes: Uint8Array
   export default bytes
 }
+declare module "*.srtm" {
+  const bytes: Uint8Array
+  export default bytes
+}
 
 // UI event bus (lattice), provided by the runtime as a builtin module.
 // on/once return an unsubscribe function. Notable events: the routed pointer
@@ -79,6 +83,18 @@ declare module "srt:app" {
    * `back` on Android; exposed there as `background`.
    */
   export function background(): void
+  /**
+   * Make this install the handler for the app's own scheme (its appId, as
+   * in `com.example.app://settings`), so links of it open the app: on Linux
+   * a desktop entry plus the mimeapps.list default, on Windows the
+   * HKCU\Software\Classes protocol key, both for the current user. Throws
+   * when the registration cannot be written. Android and macOS packages
+   * declare the scheme themselves, so the call has nothing to do there; a
+   * dev client registers nothing and logs a warning. Prefer the
+   * @solidrt/core `registerProtocolHandler`, the same call documented with
+   * the rest of the link surface.
+   */
+  export function registerProtocolHandler(): void
 }
 
 // Dev-server control surface (lattice). Present only in dev/go builds; in other
@@ -106,6 +122,17 @@ declare module "srt:dev" {
    * clients ever invoke commands.
    */
   export function registerDebug(name: string, fn: (args?: any) => unknown): void
+  /**
+   * Report where the app is, for tooling: a string naming the current
+   * location (a router's path; an app routing by hand may report its own),
+   * called again on every change. The runtime stores the value and never
+   * interprets it. The dev server reads it (`GET /__control__/link`, the
+   * get_location MCP tool), and a hot reload of the same app starts with the
+   * last reported location as its `env.launchLink`, so a rebuild comes back
+   * to the screen it left. null withdraws it. Callable in every build, but
+   * only dev clients ever read it.
+   */
+  export function reportLocation(location: string | null): void
 }
 
 // Installed-app management (lattice), the player's surface over the client's

package/src/svg.ts

@@ -27,6 +27,7 @@ export type SvgDraw = {
   color: string | Gradient
   drawStyle: "fill" | "stroke"
   fillRule?: "nonzero" | "evenodd"
+  /** Absent when the source omits it: the d-path default of 1 applies, SVG's own. */
   strokeWidth?: number
   strokeCap?: StrokeCap
   strokeJoin?: StrokeJoin

package/src/swipe.ts

@@ -0,0 +1,130 @@
+// The swipe recognizer: a one-pointer drag that, at the lift, has
+// travelled SWIPE_MIN_DISTANCE from its down at SWIPE_MIN_VELOCITY or
+// more, within SWIPE_ANGLE_TOLERANCE of one of the four axes. Discrete:
+// onSwipe fires once, at the lift, with the direction and the velocity.
+// Direction is the dominant axis of the VELOCITY, not of the travel (a
+// finger that wandered then flicked swipes where it flicked). A drag
+// that ends without qualifying gets onSwipeEnd alone, so a consumer that
+// followed the finger snaps back.
+//
+// Built on createPan with the pan's axis derived from the allowed
+// directions: a horizontal-only swipe inside a vertical ScrollView takes
+// only horizontal drags, exactly as nested scrollers share drags today,
+// and it steals at the pan's slop, so a pressable under it retracts. The
+// pan measures the parent-frame velocity it hands the consumer; the
+// thresholds are finger travel, so the swipe keeps a second tracker in
+// window pixels over the events it wraps. The classifier is shared with
+// the pointer feed's swipe sources. Mouse and touch alike.
+
+import { createPan } from "./pan"
+import type { PointerEvent } from "./types"
+import { createVelocityTracker } from "./velocity"
+import type { Velocity } from "./velocity"
+
+export type SwipeDirection = "Left" | "Right" | "Up" | "Down"
+
+export const SWIPE_DIRECTIONS: readonly SwipeDirection[] = ["Left", "Right", "Up", "Down"]
+
+// Least finger travel (window px) from the down to the lift.
+const SWIPE_MIN_DISTANCE = 24
+// Least finger speed at the lift (window px/s): Android's usual
+// minimumFlingVelocity of 50 dp/s at the density it assumes.
+const SWIPE_MIN_VELOCITY = 300
+// How far off an axis (degrees) the velocity may point.
+const SWIPE_ANGLE_TOLERANCE = 30
+const OFF_AXIS_RATIO = Math.tan((SWIPE_ANGLE_TOLERANCE * Math.PI) / 180)
+
+/**
+ * The direction a lift swipes in, or null: `finger` is the velocity in
+ * window px/s, `travel` the window-px offset from the down.
+ */
+export function classifySwipe(finger: Velocity, travel: { dx: number; dy: number }, directions: readonly SwipeDirection[] = SWIPE_DIRECTIONS): SwipeDirection | null {
+  if (Math.hypot(travel.dx, travel.dy) < SWIPE_MIN_DISTANCE) return null
+  let ax = Math.abs(finger.vx)
+  let ay = Math.abs(finger.vy)
+  if (Math.hypot(ax, ay) < SWIPE_MIN_VELOCITY) return null
+  let direction: SwipeDirection
+  if (ax >= ay) {
+    if (ay > ax * OFF_AXIS_RATIO) return null
+    direction = finger.vx < 0 ? "Left" : "Right"
+  } else {
+    if (ax > ay * OFF_AXIS_RATIO) return null
+    direction = finger.vy < 0 ? "Up" : "Down"
+  }
+  return directions.includes(direction) ? direction : null
+}
+
+export interface SwipeOptions {
+  /** Which directions count; default all four. Decides the pan's axis:
+   * only Left/Right takes horizontal drags, only Up/Down vertical ones. */
+  directions?: SwipeDirection[]
+  onSwipeStart?: () => void
+  /** Movement since the previous event in the handler node's parent frame,
+   * so a card follows the finger (createPan's frame rule). */
+  onSwipeMove?: (dx: number, dy: number) => void
+  /** The lift qualified: fired once, before onSwipeEnd. `velocity` is the
+   * pan's, parent-frame px/s. */
+  onSwipe?: (direction: SwipeDirection, velocity: Velocity) => void
+  /** Every lift of an active swipe, qualified or not. */
+  onSwipeEnd?: (velocity: Velocity) => void
+}
+
+export function createSwipe(options: SwipeOptions) {
+  let directions = () => options.directions ?? SWIPE_DIRECTIONS
+  let axisOf = (): "horizontal" | "vertical" | "both" => {
+    let d = directions()
+    let h = d.includes("Left") || d.includes("Right")
+    let v = d.includes("Up") || d.includes("Down")
+    return h && !v ? "horizontal" : v && !h ? "vertical" : "both"
+  }
+  // The down's window position and the finger's window-px velocity, over
+  // every event the wrapped pan sees.
+  let down: { id: number; x: number; y: number } | null = null
+  // The lift's window position, set just before the pan's up runs.
+  let lift: { x: number; y: number } | null = null
+  let finger = createVelocityTracker()
+  let pan = createPan({
+    get axis() {
+      return axisOf()
+    },
+    onPanStart: () => options.onSwipeStart?.(),
+    onPanMove: (dx, dy) => options.onSwipeMove?.(dx, dy),
+    onPanEnd: velocity => {
+      let direction: SwipeDirection | null = null
+      if (down && lift) {
+        direction = classifySwipe(finger.velocity(), { dx: lift.x - down.x, dy: lift.y - down.y }, directions())
+      }
+      if (direction) options.onSwipe?.(direction, velocity)
+      options.onSwipeEnd?.(velocity)
+    },
+  })
+
+  let handlers = {
+    onPointerDown: (e: PointerEvent) => {
+      if (down === null && (e.button == null || e.button === 0)) {
+        down = { id: e.pointerId, x: e.clientX, y: e.clientY }
+        finger.reset()
+        finger.push(e.clientX, e.clientY)
+      }
+      pan.handlers.onPointerDown(e)
+    },
+    onPointerMove: (e: PointerEvent) => {
+      if (down && down.id === e.pointerId) finger.push(e.clientX, e.clientY)
+      pan.handlers.onPointerMove(e)
+    },
+    onPointerUp: (e: PointerEvent) => {
+      if (down && down.id === e.pointerId) lift = { x: e.clientX, y: e.clientY }
+      pan.handlers.onPointerUp(e)
+      if (down && down.id === e.pointerId) {
+        down = null
+        lift = null
+      }
+    },
+  }
+  let cancel = () => {
+    pan.cancel()
+    down = null
+    lift = null
+  }
+  return { handlers, cancel }
+}