@solidrt/core 0.0.35 → 0.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "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.37"
   },
   "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,10 @@
 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 { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur, onBack, exit } from "./window"
+export type { BackEvent } 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

@@ -31,6 +31,17 @@ declare module "srt:events" {
   export function once(event: string, callback: (data: any) => void): () => void
 }
 
+// The running application's own surface (lattice), present in every build.
+declare module "srt:app" {
+  /**
+   * Leave the current app, unconditionally: back to the launcher in a dev
+   * client, quit when standalone or at the launcher root (on Android the
+   * client backgrounds instead of dying). The default action of an
+   * unprevented `back` event; prefer the @solidrt/core re-export.
+   */
+  export function exit(): void
+}
+
 // Dev-server control surface (lattice). Present only in dev/go builds; in other
 // builds `available` is false and the functions are no-ops.
 declare module "srt:dev" {
@@ -63,18 +74,28 @@ declare module "srt:apps" {
   export type InstalledApp = { id: string; name: string; version: string }
   /** Installed apps, sorted by name. */
   export function list(): InstalledApp[]
-  /** A stored version: id (manifest hash), bytes on disk, whether it is the current one. */
-  export type AppVersion = { id: string; size: number; current: boolean }
+  /**
+   * A stored version: id (manifest hash), bytes on disk, whether it is the
+   * current one, and the SolidRT (CLI) release that built it per its
+   * manifest ("unknown" from an in-repo CLI or when the manifest predates
+   * the field).
+   */
+  export type AppVersion = { id: string; size: number; current: boolean; solidrtVersion: string }
   /** 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 +103,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 +122,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/types.d.ts

@@ -198,8 +198,18 @@ export interface WheelEvent extends PointerEvent {
   deltaY: number
 }
 
+// Key events use the W3C UI Events vocabulary: `key` is the logical,
+// layout-dependent value ("a", "!", "Enter", "ArrowLeft"); `code` is the
+// physical, layout-independent key position ("KeyA", "Digit1", "NumpadEnter").
+// Printable characters for text entry arrive via onTextInput, not here.
 export interface KeyEvent {
   key: string
+  code: string
+  repeat: boolean
+  shiftKey: boolean
+  ctrlKey: boolean
+  altKey: boolean
+  metaKey: boolean
 }
 
 export interface TextEvent {

package/src/window.ts

@@ -2,30 +2,30 @@ import { createSignal, onCleanup, onSettled, flush } from "@solidjs/signals"
 import { requestFrame } from "flux:rendertree"
 import { renderFrame } from "srt:render"
 import { on, once } from "srt:events"
+import { exit } from "srt:app"
 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.
+ * Leaves the current app, unconditionally: back to the launcher in a dev
+ * client, quitting when standalone or at the launcher itself (on Android the
+ * client backgrounds instead of dying). The default action of an unprevented
+ * `back` event; call it directly to exit programmatically, e.g. after
+ * intercepting back for an unsaved-changes dialog.
  */
-export function setPointerCapture(nodeId: number, pointerId: number) {
-  pointerCaptures.set(pointerId, nodeId)
-}
+export { exit }
 
-/** 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 ----------------
 
@@ -189,6 +189,30 @@ export function onWindowBlur(fn: () => void) {
   return unsubscribe
 }
 
+// ------ Back ----------------
+
+export type BackEvent = { preventDefault: () => void }
+
+// App handlers for the window-level back event, run in registration order.
+// Kept in a local registry (not per-handler bus subscriptions) so the default
+// action runs exactly once, after every handler has had its say.
+let backHandlers = new Set<(e: BackEvent) => void>()
+
+/**
+ * Calls `fn` on the user's back intent (Android back button/gesture, the
+ * desktop dev chord). Call `e.preventDefault()` when back means in-app
+ * navigation right now (close a modal, previous screen); unprevented, the
+ * default action runs: exit(). Apps without a handler exit on back
+ * everywhere, which is the correct zero-effort default.
+ * Returns a cleanup function; also auto-cleans within a reactive scope.
+ */
+export function onBack(fn: (e: BackEvent) => void) {
+  backHandlers.add(fn)
+  let cleanup = () => backHandlers.delete(fn)
+  onCleanup(cleanup)
+  return cleanup
+}
+
 // ------ Window ----------------
 
 export function attachWindow(_nodeId: number) {
@@ -201,6 +225,7 @@ export function attachWindow(_nodeId: number) {
   let unsubWheel: () => void = null!
   let unsubKeyDown: () => void = null!
   let unsubKeyUp: () => void = null!
+  let unsubBack: () => void = null!
   let unsubTextInput: () => void = null!
   let unsubKeyboardVisibility: () => void = null!
   let unsubRefreshRate: () => void = null!
@@ -244,6 +269,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 +281,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)
       },
     )
 
@@ -326,6 +339,18 @@ export function attachWindow(_nodeId: number) {
       }
     })
 
+    unsubBack = on("back", () => {
+      let prevented = false
+      let e: BackEvent = {
+        preventDefault: () => {
+          prevented = true
+        },
+      }
+      // Copy first: a handler may unregister (itself or others) mid-dispatch.
+      for (let fn of [...backHandlers]) fn(e)
+      if (!prevented) exit()
+    })
+
     unsubTextInput = on("textInput", (e: any) => {
       let id = getFocusedNodeId()
       if (id != null) {
@@ -361,6 +386,7 @@ export function attachWindow(_nodeId: number) {
     if (unsubWheel) unsubWheel()
     if (unsubKeyDown) unsubKeyDown()
     if (unsubKeyUp) unsubKeyUp()
+    if (unsubBack) unsubBack()
     if (unsubTextInput) unsubTextInput()
     if (unsubKeyboardVisibility) unsubKeyboardVisibility()
     if (unsubRefreshRate) unsubRefreshRate()