@solidrt/core 0.0.35 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -27,7 +27,7 @@
     "colord": "^2.9.3"
   },
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.35"
+    "@solidrt/flux-types": "0.0.36"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-beta.20",

package/src/core.ts

@@ -64,16 +64,27 @@ export interface BoundingBox {
 }
 
 /**
- * Returns the node's window-relative bounding box from the most recently
- * computed layout, or `null` if the node has no layout or has not been laid out
- * yet. This is a snapshot read, not reactive: call it inside `onLayout` (or an
- * event handler) to get values for the current frame. Phase 1 composes only
- * translations; x/y are wrong when a rotate/scale sits anywhere above the node.
+ * Returns the node's bounding box from the most recently computed layout,
+ * relative to its nearest positioning context (an ancestor with an explicit
+ * `position="relative"`, falling back to the window), or `null` if the node
+ * has no layout or has not been laid out yet. This is a snapshot read, not
+ * reactive: call it inside `onLayout` (or an event handler) to get values for
+ * the current frame. Transforms anywhere in the chain (including the node's
+ * own) compose fully; the box is the axis-aligned bounds of the transformed
+ * quad.
  */
 export function getBoundingBox(node: { id: number }): BoundingBox | null {
   return tree.getBoundingBox(node.id)
 }
 
+/**
+ * Like getBoundingBox, but always window-relative (getBoundingClientRect
+ * semantics), the frame pointer event clientX/clientY are reported in.
+ */
+export function getBoundingBoxViewport(node: { id: number }): BoundingBox | null {
+  return tree.getBoundingBoxViewport(node.id)
+}
+
 /**
  * Measures the rendered size of `text` in layout pixels under the given font
  * options (family, size, weight, style, maxLines), without adding it to the

package/src/index.ts

@@ -1,10 +1,9 @@
 export * from "./renderer"
-export { setFocus, getFocusedNodeId, measureText, getBoundingBox } from "./core"
+export { setFocus, getFocusedNodeId, measureText, getBoundingBox, getBoundingBoxViewport } from "./core"
 export type { BoundingBox } from "./core"
 export { parseColor, mixColors, brightness, createLinearGradient, createRadialGradient } from "./color"
 export type { Gradient, GradientStop } from "./color"
 export { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur } from "./window"
-export { setPointerCapture, releasePointerCapture } from "./window"
 export { windowSize, safeArea, displayScale, windowFocused, keyboardHeight } from "./window"
 export { env } from "./environment"
 export type { InputDevices, SystemTheme, Orientation } from "./environment"

package/src/runtime-modules.d.ts

@@ -67,14 +67,19 @@ declare module "srt:apps" {
   export type AppVersion = { id: string; size: number; current: boolean }
   /** One file in a listing: a relative path and its size in bytes. */
   export type AppFile = { path: string; size: number }
+  /**
+   * One fetch-cache entry: the cached (resolved) url, the response content
+   * type (lowercased, parameters stripped; absent when the response had
+   * none) and the entry's size on disk.
+   */
+  export type AppCacheEntry = { url: string; type?: string; size: number }
   /**
    * Usage details for one installed app: total bytes of its stored versions
-   * (assets shared between versions via hardlinks count in each) and of its
-   * data sandbox, plus the stored versions (current first, then newest first)
-   * and three file listings, each sorted by path. `assets` is the current
-   * version's manifest claim (declared sizes); `files` and `data` are disk
-   * walks of the current version dir and the data sandbox - the truth, so a
-   * divergence from the manifest is visible.
+   * (assets shared between versions via hardlinks count in each), of its
+   * data sandbox and of its fetch cache, plus the stored versions (current
+   * first, then newest first) and three listings: `files` and `data` are
+   * disk walks of the current version dir and the data sandbox (sorted by
+   * path), `cache` is the fetch cache's entries (sorted by url).
    */
   export type AppInfo = {
     id: string
@@ -82,10 +87,11 @@ declare module "srt:apps" {
     version: string
     installSize: number
     dataSize: number
+    cacheSize: number
     versions: AppVersion[]
-    assets: AppFile[]
     files: AppFile[]
     data: AppFile[]
+    cache: AppCacheEntry[]
   }
   /** Usage details for an installed app. Throws when the app is not installed. */
   export function info(id: string): AppInfo
@@ -100,6 +106,22 @@ declare module "srt:apps" {
    * the app is not installed.
    */
   export function remove(id: string): void
+  /**
+   * Delete the app's fetch cache. Clearing a missing or empty cache is a
+   * no-op; the id does not need to be installed, so a removed app's
+   * leftover cache is still clearable.
+   */
+  export function clearCache(id: string): void
+  /**
+   * Build identity of this runtime, for the launcher's settings screen. Not
+   * app-specific, but surfaced here since the launcher already imports this
+   * module. `version` is the release version (git describe; "0.0.0-dev" in a
+   * plain build), `profile` is "debug" or "release", `platform` is the OS
+   * (std::env::consts::OS, e.g. "linux", "android", "windows", "macos").
+   */
+  export const version: string
+  export const profile: string
+  export const platform: string
 }
 
 // Frame draw (lattice runner). renderFrame() synchronously renders the current

package/src/window.ts

@@ -5,27 +5,17 @@ import { on, once } from "srt:events"
 import { getEventHandler, getFocusedNodeId, setFocus } from "./core"
 import { scanForOrphans } from "./renderer"
 
-// ------ Pointer capture -----------------
-
-// Active pointer captures, pointerId -> nodeId. While a pointer is captured, its
-// move/up events dispatch straight to the captured node (bypassing hit testing),
-// so a drag keeps working when the pointer drifts off the element. Modeled on the
-// web setPointerCapture; capture auto-releases on pointerUp.
-let pointerCaptures = new Map<number, number>()
-
-/**
- * Routes all further move/up events for `pointerId` to `nodeId` until release,
- * regardless of what is under the pointer. Call from a pointerdown handler to own
- * a drag (e.g. a slider). Auto-releases on the matching pointerup.
- */
-export function setPointerCapture(nodeId: number, pointerId: number) {
-  pointerCaptures.set(pointerId, nodeId)
-}
-
-/** Ends a capture early. Not needed for the common case (pointerup releases it). */
-export function releasePointerCapture(pointerId: number) {
-  pointerCaptures.delete(pointerId)
-}
+// ------ Pointer routing -----------------
+
+// Hit path frozen at pointerDown, pointerId -> targets. While a pointer has an
+// active down, its moves and up dispatch along this path (same leaf-to-root
+// bubble) no matter where the pointer currently is, so every node under the
+// original down observes the whole gesture: a drag keeps working off-element,
+// and an ancestor recognizer (a scroller's pan) sees the moves it needs to
+// take over mid-gesture via the arena. There is no exclusive pointer capture;
+// gesture ownership is claim-based, above this layer. Enter/leave stay
+// hover-driven, and moves with no active down follow the live hit path.
+let downPaths = new Map<number, number[]>()
 
 // ------ Animation frames ----------------
 
@@ -244,6 +234,7 @@ export function attachWindow(_nodeId: number) {
     unsubDown = on(
       "pointerDown",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
+        downPaths.set(e.pointerId, targets)
         bubble(targets, "onPointerDown", e)
         // Outside-tap blur. Read focus AFTER per-node handlers so a tap that
         // moves focus to a new node is not immediately blurred again.
@@ -255,28 +246,15 @@ export function attachWindow(_nodeId: number) {
     )
 
     unsubUp = on("pointerUp", ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
-      let captured = pointerCaptures.get(e.pointerId)
-      if (captured != null) {
-        // Deliver to the captured node, then release (web auto-release on up).
-        e.stopPropagation = () => {}
-        getEventHandler(captured, "onPointerUp")?.(e)
-        pointerCaptures.delete(e.pointerId)
-        return
-      }
-      bubble(targets, "onPointerUp", e)
+      let frozen = downPaths.get(e.pointerId)
+      downPaths.delete(e.pointerId)
+      bubble(frozen ?? targets, "onPointerUp", e)
     })
 
     unsubMove = on(
       "pointerMove",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
-        let captured = pointerCaptures.get(e.pointerId)
-        if (captured != null) {
-          // Captured drags get moves anywhere over the window, bypassing hit test.
-          e.stopPropagation = () => {}
-          getEventHandler(captured, "onPointerMove")?.(e)
-          return
-        }
-        bubble(targets, "onPointerMove", e)
+        bubble(downPaths.get(e.pointerId) ?? targets, "onPointerMove", e)
       },
     )