@solidrt/core 0.0.10 → 0.0.13

package/src/window.ts

@@ -1,4 +1,6 @@
-import { onCleanup, onSettled, flush } from "@solidjs/signals"
+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 { getEventHandler, getFocusedNodeId, setFocus } from "./core"
 
@@ -28,12 +30,12 @@ export function onFrame(fn: (tick: number, frame: number, rate: number) => void)
     frameId = nextFrameId++
     animationFrames.set(frameId, extendedFn)
     // A pending onFrame callback is a standing request for the next frame.
-    ffi.requestFrame()
+    requestFrame()
   }
 
   frameId = nextFrameId++
   animationFrames.set(frameId, extendedFn)
-  ffi.requestFrame()
+  requestFrame()
 
   let cleanup = () => animationFrames.delete(frameId)
   onCleanup(cleanup)
@@ -42,6 +44,8 @@ export function onFrame(fn: (tick: number, frame: number, rate: number) => void)
 
 // ------ Resize ----------------
 
+// Insets: each value is the distance from the corresponding window edge, like
+// CSS env(safe-area-inset-*).
 interface SafeArea {
   top: number
   left: number
@@ -62,10 +66,86 @@ export function onResize(fn: (data: ResizeEvent) => void) {
   return unsubscribe
 }
 
-// Fires after layout has been computed for the current frame but before paint.
-// Setting properties that affect layout from this callback will be picked up
-// by a re-layout pass before painting (one extra pass; cascades beyond that
-// paint stale).
+// ------ Reactive window state ----------------
+
+// Singleton accessors over the same events as onResize / onWindowFocus. There
+// is one window, so these are bare accessors rather than a createX instance.
+// Lazily subscribed on first read (resize is sticky, so the first read sees the
+// current value); app-lifetime, so no onCleanup.
+
+let sizeAccessor: (() => { width: number; height: number }) | undefined
+let safeAreaAccessor: (() => SafeArea) | undefined
+let displayScaleAccessor: (() => number) | undefined
+
+function ensureResizeState() {
+  if (sizeAccessor) return
+  let [size, setSize] = createSignal({ width: 0, height: 0 })
+  let [safe, setSafe] = createSignal<SafeArea>({ top: 0, left: 0, right: 0, bottom: 0 })
+  let [scale, setScale] = createSignal(1)
+  on("resize", (e: ResizeEvent) => {
+    setSize({ width: e.width, height: e.height })
+    setSafe(e.safeArea)
+    setScale(e.displayScale)
+  })
+  sizeAccessor = size
+  safeAreaAccessor = safe
+  displayScaleAccessor = scale
+}
+
+/** Current window size, as a reactive accessor. */
+export function windowSize(): { width: number; height: number } {
+  ensureResizeState()
+  return sizeAccessor!()
+}
+
+/** Current safe-area insets, as a reactive accessor. */
+export function safeArea(): SafeArea {
+  ensureResizeState()
+  return safeAreaAccessor!()
+}
+
+/** Current display scale (device pixel ratio), as a reactive accessor. */
+export function displayScale(): number {
+  ensureResizeState()
+  return displayScaleAccessor!()
+}
+
+let focusedAccessor: (() => boolean) | undefined
+
+/** Whether the window currently has focus, as a reactive accessor. */
+export function windowFocused(): boolean {
+  if (!focusedAccessor) {
+    let [focused, setFocused] = createSignal(true)
+    on("windowFocus", () => setFocused(true))
+    on("windowBlur", () => setFocused(false))
+    focusedAccessor = focused
+  }
+  return focusedAccessor()
+}
+
+let keyboardHeightAccessor: (() => number) | undefined
+
+/**
+ * Height in logical pixels that the on-screen keyboard overlaps the window
+ * (0 when hidden or on platforms without a soft keyboard), as a reactive
+ * accessor. The window is not resized for the keyboard, so pad or lift content
+ * by this much to keep it above the keyboard.
+ */
+export function keyboardHeight(): number {
+  if (!keyboardHeightAccessor) {
+    let [height, setHeight] = createSignal(0)
+    on("keyboardVisibility", ({ height: h }: { height: number }) => setHeight(h ?? 0))
+    keyboardHeightAccessor = height
+  }
+  return keyboardHeightAccessor()
+}
+
+/**
+ * Fires after layout has been computed for the current frame but before paint.
+ * Setting properties that affect layout from this callback will be picked up
+ * by a re-layout pass before painting (one extra pass; cascades beyond that
+ * paint stale).
+ */
 export function onLayout(fn: () => void) {
   let unsubscribe = on("postLayout", fn)
   onCleanup(unsubscribe)
@@ -108,7 +188,7 @@ export function attachWindow(_nodeId: number) {
       for (let fn of frames.values()) fn(t, frame, refreshRate)
     }
     flush()
-    draw()
+    renderFrame()
   }
 
   onSettled(() => {

package/src/camera-view.tsx

@@ -1,55 +0,0 @@
-import { createSignal, onCleanup } from "@solidjs/signals"
-import { openCamera, type BarcodeResult, type Camera } from "./camera"
-
-// Convenience viewfinder over openCamera: opens on mount, renders the stream
-// texture, closes on cleanup. Use openCamera directly for anything it does not
-// cover; this is just composition, no extra capability.
-
-export interface CameraViewProps {
-  /** Explicit device id from listCameras(); takes precedence over facing. */
-  camera?: number
-  facing?: "front" | "back"
-  /**
-   * Size hint for the stream and explicit size of the view. Omit height to
-   * follow the stream's aspect ratio, which can flip when a phone rotates.
-   */
-  width?: number
-  height?: number
-  scan?: "qr"[]
-  onReady?: (cam: Camera) => void
-  onError?: (error: Error) => void
-  onBarcode?: (result: BarcodeResult) => void
-}
-
-export function CameraView(props: CameraViewProps) {
-  let [texture, setTexture] = createSignal<number | undefined>(undefined)
-  let cam: Camera | undefined
-  let disposed = false
-
-  openCamera({
-    camera: props.camera,
-    facing: props.facing,
-    width: props.width,
-    height: props.height,
-    scan: props.scan,
-  })
-    .then((opened) => {
-      if (disposed) {
-        opened.close()
-        return
-      }
-      cam = opened
-      if (props.onBarcode) opened.onBarcode(props.onBarcode)
-      setTexture(opened.texture)
-      props.onReady?.(opened)
-    })
-    .catch((e) => props.onError?.(e instanceof Error ? e : new Error(String(e))))
-
-  onCleanup(() => {
-    disposed = true
-    cam?.close()
-    cam = undefined
-  })
-
-  return <texture src={texture()} width={props.width} height={props.height} />
-}

package/src/speech.ts

@@ -1,67 +0,0 @@
-// Speech recognition. A session captures the microphone, segments utterances
-// by silence (Silero VAD) and transcribes each one with Whisper, delivering
-// final transcripts through onResult. With wakeWord the session starts
-// asleep behind an efficient wake word detector (livekit-wakeword) and only
-// transcribes after the wake word. startRecognition resolves once the models
-// are loaded and listening has begun; it rejects when loading fails.
-// Models are passed as bytes so any source composes: flux:fs file(), fetch
-// (incl. the dev-server file proxy), or a download cache layered on top.
-// Requires a runtime built with speech support.
-
-export type SpeechOptions = {
-  /** A ggml Whisper model (file contents, e.g. ggml-tiny.en.bin). */
-  model: Uint8Array
-  /** A ggml Silero VAD model (file contents). */
-  vadModel: Uint8Array
-  /** Whisper language code; "auto" detects (multilingual models only). Default "en". */
-  language?: string
-  /** Explicit microphone device id from listMicrophones(). */
-  microphone?: number
-  /** Stop automatically after the first final result (with wakeWord: re-arm instead, one result per wake). */
-  singleUtterance?: boolean
-  /** Also deliver snapshot transcripts (final: false) while an utterance is still being spoken. */
-  interimResults?: boolean
-  /**
-   * Wake word: start asleep, fire onWake when it is heard, then transcribe
-   * the speech that follows. How the wake word is specified depends on the
-   * engine. The current engine detects with a trained classifier and takes
-   * the model's bytes (livekit-wakeword ONNX, e.g. the pretrained "hey
-   * livekit"; custom phrases are trained offline with its toolkit). Phrase
-   * strings are reserved for engines that match text; passing them to this
-   * engine rejects with an error.
-   */
-  wakeWord?: Uint8Array | string | string[]
-  /** Detector confidence (0..1) that counts as a wake. Default 0.5. */
-  wakeThreshold?: number
-}
-
-export type SpeechResult = {
-  /** Transcript of the utterance (a snapshot of it when final is false). */
-  text: string
-  /** True for the completed utterance, false for interim snapshots. */
-  final: boolean
-}
-
-export type SpeechSession = {
-  /** Receive transcripts (replaces any previous callback). */
-  onResult(callback: (result: SpeechResult) => void): void
-  /** The user started speaking (replaces any previous callback). */
-  onSpeechStart(callback: () => void): void
-  /** The utterance ended; its final result follows once transcribed. */
-  onSpeechEnd(callback: () => void): void
-  /** The wake word was heard (wakeWordModel sessions only). */
-  onWake(callback: () => void): void
-  /** Release the microphone and discard any utterance in progress. */
-  stop(): void
-}
-
-export async function startRecognition(options: SpeechOptions): Promise<SpeechSession> {
-  let started = await speech.start(options)
-  return {
-    onResult: (callback: (result: SpeechResult) => void) => speech.setResultCallback(started.handle, callback),
-    onSpeechStart: (callback: () => void) => speech.setSpeechStartCallback(started.handle, callback),
-    onSpeechEnd: (callback: () => void) => speech.setSpeechEndCallback(started.handle, callback),
-    onWake: (callback: () => void) => speech.setWakeCallback(started.handle, callback),
-    stop: () => speech.stop(started.handle),
-  }
-}