@solidrt/core 0.0.7 → 0.0.9

package/package.json

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

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from "./renderer"
 export { setFocus, getFocusedNodeId, measureText, getBoundingBox } from "./core"
 export type { BoundingBox } from "./core"
-export { onFrame, createPacedClock, onLayout, onResize, onWindowFocus, onWindowBlur } from "./window"
+export { onFrame, onLayout, onResize, onWindowFocus, onWindowBlur } from "./window"
 export { createTexture, decodeImage } from "./gpu"
 export type { DecodedImage } from "./gpu"
 export type {

package/src/types.d.ts

@@ -3,6 +3,15 @@
 import type { JSX as SolidJSX } from "@solidjs/signals"
 
 declare global {
+  function requestAnimationFrame(callback: (time: number) => void): number
+  function cancelAnimationFrame(id: number): void
+
+  // UI event bus (lattice). on/once return an unsubscribe function.
+  let srt: {
+    on(event: string, callback: (data: any) => void): () => void
+    once(event: string, callback: (data: any) => void): () => void
+  }
+
   let ffi: {
     createRoot(id: number): void
     createNode(id: number, kind: string): void

package/src/window.ts

@@ -1,4 +1,4 @@
-import { onCleanup, onSettled, flush, createSignal } from "@solidjs/signals"
+import { onCleanup, onSettled, flush } from "@solidjs/signals"
 import { getEventHandler, getFocusedNodeId, setFocus } from "./core"
 
 // ------ Animation frames ----------------
@@ -11,10 +11,12 @@ let animationFrames = new Map<number, Function>()
 let refreshRate = 60
 
 /**
- * Calls `fn` before every frame is painted, with the raw runtime signals: `tick`
- * is the unsmoothed wall-clock time in ms sampled at present, `frame` is the
- * present count, and `rate` is the current refresh rate in Hz. No pacing is
- * applied; see createPacedClock for an opt-in smooth clock.
+ * Calls `fn` before every frame is painted: `tick` is the time in ms, `frame` is
+ * the present count, and `rate` is the current refresh rate in Hz. `tick` is paced
+ * by the runtime (one refresh period per present, slow-corrected toward the wall
+ * clock) so animations driven off it stay smooth even when swap-return times
+ * jitter. For raw, continuous wall-clock time (e.g. measuring code), use
+ * performance.now() instead.
  * Returns a cleanup function; also auto-cleans within a reactive scope.
  */
 export function onFrame(fn: (tick: number, frame: number, rate: number) => void) {
@@ -34,26 +36,6 @@ export function onFrame(fn: (tick: number, frame: number, rate: number) => void)
   return cleanup
 }
 
-/**
- * Opt-in smooth clock built on the raw onFrame signals. Paces by present count
- * (one refresh period per frame) and slowly corrects toward the raw wall-clock
- * tick, so it stays smooth while keeping up and tracks real time when the
- * framerate drops. `gain` (0..1) trades convergence speed for jitter. Returns an
- * accessor for the paced time in milliseconds.
- */
-export function createPacedClock(opts?: { gain?: number }) {
-  let gain = opts?.gain ?? 0.05
-  let [time, setTime] = createSignal(0)
-  let clock = 0
-  onFrame((tick, _frame, rate) => {
-    let period = 1000 / rate
-    clock += period
-    clock += (tick - clock) * gain
-    setTime(clock)
-  })
-  return time
-}
-
 // ------ Resize ----------------
 
 interface SafeArea {
@@ -71,7 +53,7 @@ interface ResizeEvent {
 }
 
 export function onResize(fn: (data: ResizeEvent) => void) {
-  let unsubscribe = Flux.on("resize", fn)
+  let unsubscribe = srt.on("resize", fn)
   onCleanup(unsubscribe)
   return unsubscribe
 }
@@ -81,19 +63,19 @@ export function onResize(fn: (data: ResizeEvent) => void) {
 // by a re-layout pass before painting (one extra pass; cascades beyond that
 // paint stale).
 export function onLayout(fn: () => void) {
-  let unsubscribe = Flux.on("postLayout", fn)
+  let unsubscribe = srt.on("postLayout", fn)
   onCleanup(unsubscribe)
   return unsubscribe
 }
 
 export function onWindowFocus(fn: () => void) {
-  let unsubscribe = Flux.on("windowFocus", fn)
+  let unsubscribe = srt.on("windowFocus", fn)
   onCleanup(unsubscribe)
   return unsubscribe
 }
 
 export function onWindowBlur(fn: () => void) {
-  let unsubscribe = Flux.on("windowBlur", fn)
+  let unsubscribe = srt.on("windowBlur", fn)
   onCleanup(unsubscribe)
   return unsubscribe
 }
@@ -127,15 +109,15 @@ export function attachWindow(_nodeId: number) {
 
   onSettled(() => {
     // Sticky event: a late subscriber still receives the current rate.
-    unsubRefreshRate = Flux.on("displayRefreshRate", ({ hz }: { hz: number }) => {
+    unsubRefreshRate = srt.on("displayRefreshRate", ({ hz }: { hz: number }) => {
       if (hz > 0) refreshRate = hz
     })
 
-    unsubscribe = Flux.on("render", ({ time, frame }: { time: number; frame: number }) => {
+    unsubscribe = srt.on("render", ({ time, frame }: { time: number; frame: number }) => {
       runFrame(time * 1000, frame)
     })
 
-    unsubDown = Flux.on(
+    unsubDown = srt.on(
       "pointerDown",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
         for (let nodeId of targets) {
@@ -150,13 +132,13 @@ export function attachWindow(_nodeId: number) {
       },
     )
 
-    unsubUp = Flux.on("pointerUp", ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
+    unsubUp = srt.on("pointerUp", ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
       for (let nodeId of targets) {
         getEventHandler(nodeId, "onPointerUp")?.(e)
       }
     })
 
-    unsubMove = Flux.on(
+    unsubMove = srt.on(
       "pointerMove",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
         for (let nodeId of targets) {
@@ -165,7 +147,7 @@ export function attachWindow(_nodeId: number) {
       },
     )
 
-    unsubEnter = Flux.on(
+    unsubEnter = srt.on(
       "pointerEnter",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
         for (let nodeId of targets) {
@@ -174,7 +156,7 @@ export function attachWindow(_nodeId: number) {
       },
     )
 
-    unsubLeave = Flux.on(
+    unsubLeave = srt.on(
       "pointerLeave",
       ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
         for (let nodeId of targets) {
@@ -183,27 +165,27 @@ export function attachWindow(_nodeId: number) {
       },
     )
 
-    unsubWheel = Flux.on("wheel", ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
+    unsubWheel = srt.on("wheel", ({ targets, ...e }: { targets: number[]; [k: string]: any }) => {
       for (let nodeId of targets) {
         getEventHandler(nodeId, "onWheel")?.(e)
       }
     })
 
-    unsubKeyDown = Flux.on("keydown", (e: any) => {
+    unsubKeyDown = srt.on("keydown", (e: any) => {
       let id = getFocusedNodeId()
       if (id != null) {
         getEventHandler(id, "onKeyDown")?.(e)
       }
     })
 
-    unsubKeyUp = Flux.on("keyup", (e: any) => {
+    unsubKeyUp = srt.on("keyup", (e: any) => {
       let id = getFocusedNodeId()
       if (id != null) {
         getEventHandler(id, "onKeyUp")?.(e)
       }
     })
 
-    unsubTextInput = Flux.on("textInput", (e: any) => {
+    unsubTextInput = srt.on("textInput", (e: any) => {
       let id = getFocusedNodeId()
       if (id != null) {
         getEventHandler(id, "onTextInput")?.(e)
@@ -212,7 +194,7 @@ export function attachWindow(_nodeId: number) {
 
     // When the user dismisses the on-screen keyboard (swipe down, "Done",
     // back button), blur the focused node so the app's UI state catches up.
-    unsubKeyboardVisibility = Flux.on("keyboardVisibility", ({ shown }: { shown: boolean }) => {
+    unsubKeyboardVisibility = srt.on("keyboardVisibility", ({ shown }: { shown: boolean }) => {
       if (!shown) setFocus(null)
     })
 
@@ -223,7 +205,7 @@ export function attachWindow(_nodeId: number) {
     // synchronously here, while we are still inside this onSettled callback
     // where flush() is illegal (not reentrant). Defer runFrame to a microtask
     // so the first frame always runs after this callback returns.
-    unsubFirstResize = Flux.once("resize", () => {
+    unsubFirstResize = srt.once("resize", () => {
       queueMicrotask(() => runFrame(0, 0))
     })
   })