solid-drift 0.25.0 → 0.27.0

package/README.md

@@ -1534,6 +1534,72 @@ const chat = createChatModel({
 - Honest limitation: api.anthropic.com does not send CORS headers for browser origins, so from a browser Anthropic must go through your own server route or proxy; point `baseUrl` at it. For production with any provider, prefer a server route that holds the key and set `baseUrl` to it so keys never ship to the browser.
 - `createSSE(url, options?)` is a fetch-based event-stream client (`{ status, events, lastEvent, error, connect, disconnect }`): unlike `EventSource` it supports any method and custom headers, parses the full SSE framing (named events, multi-line data, comments, chunk splits), and leaves reconnection manual via `connect()`. SSR-safe: nothing connects until `connect()` (or `autoConnect`) runs on the client.
 
+### Voice
+
+A full voice loop: mic metering, speech-to-text, a voice state machine, canvas waveforms, text-to-speech (browser or cloud), thinking indicators, and a voice-enabled prompt input.
+
+```tsx
+import { createVoiceState, createSpeech, createTTS, createPrompt, createChatModel } from "solid-drift"
+
+const voice = createVoiceState()
+const chat = createChatModel({ provider: "openai", apiKey: getKey, model: "gpt-4o-mini" })
+const tts = createTTS()
+const prompt = createPrompt({
+  onSubmit: async (text) => {
+    voice.toThinking()
+    await chat.send(text)
+    voice.toSpeaking()
+    const msgs = chat.messages()
+    tts.speak(msgs[msgs.length - 1]?.content ?? "")
+    voice.toIdle()
+  },
+})
+
+<input
+  value={prompt.value()}
+  onInput={(e) => prompt.setValue(e.currentTarget.value)}
+  onKeyDown={(e) => e.key === "Enter" && prompt.submit()}
+/>
+<button onClick={() => { voice.toListening(); prompt.toggleMic(); }}>Mic</button>
+```
+
+- `createVoiceState()` is the turn state machine: `state()` is `idle`, `listening`, `thinking`, or `speaking`, with `toIdle`/`toListening`/`toThinking`/`toSpeaking` transitions.
+- `createMicLevel(options?)` returns `{ level, active, supported, analyser, error, start, stop }`: a 0..1 smoothed RMS meter from `getUserMedia` plus an `AnalyserNode` (call `start()` from a user gesture). The exposed `analyser` wires straight into `createWaveform`.
+- `createSpeech(options?)` wraps the Web Speech API (`SpeechRecognition` with `webkitSpeechRecognition` fallback): `{ supported, listening, transcript, interim, error, start, stop, reset }`. Final results accumulate into `transcript()`; `continuous` sessions auto-restart if the browser ends them mid-turn.
+- `createWaveform(canvas, options)` draws the analyser's time-domain wave (`mode: "line"`) or spectrum (`mode: "bars"`) on a canvas, DPR-aware, on the shared clock; under reduced motion it redraws at most every 250ms.
+- `createTTS(options?)` speaks via `speechSynthesis` by default (`{ supported, speaking, voices, speak, cancel }`, async voice loading, `speak()` cancels the current utterance first) and upgrades to any cloud voice through `provider: { speak(text, { signal }) }`.
+- `createThinking(options?)` cycles `"Thinking"`, `"Thinking."`, ... through `phrases` at `interval` ms: `{ text, running, start, stop }`.
+- `createPrompt(options?)` is the voice-enabled input: `{ value, setValue, listening, interim, supported, toggleMic, submit, clear }`. Mic finals are appended to the value as they arrive; `submit()` fires `onSubmit` and clears by default. Everything is SSR-safe: unsupported primitives report `supported: false` and their actions no-op on the server.
+
+### Mobile hardware
+
+```tsx
+import { createBattery, createShare, createScanline } from "solid-drift";
+
+const battery = createBattery();
+const share = createShare();
+const scanline = createScanline({ duration: 1800 });
+
+scanline.start();
+// in your scanner viewfinder:
+// <div class="line" style={{ top: `${scanline.progress() * 100}%` }} />
+
+<p>Battery: {Math.round(battery.level() * 100)}% {battery.charging() ? "(charging)" : ""}</p>
+<button onClick={() => share.share({ title: "solid-drift", url: location.href })}>Share</button>
+```
+
+- `createBattery()` wraps `navigator.getBattery()`: `{ supported, charging, level, chargingTime, dischargingTime, error }`. Level is 0..1; times are seconds (`Infinity` when unknown). Listeners detach on cleanup.
+- `createNetwork()` tracks `navigator.onLine` plus the Network Information API: `{ online, effectiveType, downlink, rtt, saveData, supported }`. Updates on `online`/`offline` events and the connection `change` event.
+- `createWakeLock()` keeps the screen awake: `{ supported, active, error, request, release }`. Re-acquires automatically when the tab becomes visible again if the lock was still wanted.
+- `createContactPick()` wraps the Contact Picker API: `{ supported, contacts, error, pick }`. `pick({ multiple })` resolves with normalized `{ name, tel, email }` arrays, or an empty array when the user cancels.
+- `createOTP()` wraps the WebOTP API: `{ supported, code, error, wait, abort }`. `wait({ transport })` resolves with the SMS code (or `null` when aborted). Requires a secure origin and an origin-bound SMS format.
+- `createShare()` wraps the Web Share API: `{ supported, canShare, error, share }`. `share({ title, text, url, files })` opens the native sheet; user dismissal is not an error.
+- `createNFC()` wraps Web NFC (Chrome on Android, secure context, needs a user gesture): `{ supported, scanning, message, error, scan, write, abort }`. Scanned tags land in `message()` with decoded `text`/`url` records plus `serialNumber`; `write()` takes a string or `{ records }`.
+- `createTorch()` drives the camera flashlight: `{ supported, on, error, attach, set, toggle }`. `attach(trackOrStream)` checks the `torch` capability, then `set(true/false)` applies it via `applyConstraints`.
+- `createGyro()` wraps `deviceorientation`: `{ supported, needsPermission, alpha, beta, gamma, absolute, listening, error, requestPermission, start, stop }`. On iOS, call `requestPermission()` from a tap handler before `start()`; `start()` also requests it if needed.
+- `createShake(options?)` detects shake gestures from `devicemotion`: `{ supported, needsPermission, listening, shakes, error, requestPermission, start, stop }`. A shake counts when the acceleration delta exceeds `threshold` (default 15 m/s^2), rate-limited by `cooldown` (default 800ms); `onShake` fires per shake.
+- `createScanline(options?)` is the animated line of a QR/barcode viewfinder: `{ progress, running, start, stop }`. `progress()` sweeps 0..1 on the shared clock (`direction: "down" | "up" | "alternate"`); bind it to the line's position. Under reduced motion it freezes mid-frame. Every primitive is SSR-safe: server renders get `supported: false` and safe no-op actions.
+
 ### Easings
 
 Named easings: `linear`, `easeInQuad`, `easeOutQuad`, `easeInOutQuad`, `easeInCubic`, `easeOutCubic`, `easeInOutCubic`, `easeInQuart`, `easeOutQuart`, `easeInOutQuart`, `easeOutExpo`, `easeOutBack`, plus the cartoon set: `easeInBack` (anticipation dip before movement), `easeInOutBack` (wind-up, overshoot, settle), `easeOutElastic` (decaying rubber-band oscillation), `easeOutBounce` (shrinking cartoon bounces). Also `cubicBezier(x1, y1, x2, y2)` for CSS-style curves. Pass a name or a custom `(t) => number` function anywhere an easing is accepted.

package/dist/hardware.d.ts

@@ -0,0 +1,207 @@
+export interface BatteryState {
+    supported: boolean;
+    charging: () => boolean;
+    level: () => number;
+    chargingTime: () => number;
+    dischargingTime: () => number;
+    error: () => Error | null;
+}
+/**
+ * createBattery
+ *
+ * Reactive wrapper around the Battery Status API (`navigator.getBattery`).
+ * Tracks charging state, level (0..1), and charge/discharge time in seconds.
+ */
+export declare function createBattery(): BatteryState;
+export interface NetworkState {
+    online: () => boolean;
+    effectiveType: () => string | undefined;
+    downlink: () => number | undefined;
+    rtt: () => number | undefined;
+    saveData: () => boolean;
+    supported: boolean;
+}
+/**
+ * createNetwork
+ *
+ * Reactive network status: `navigator.onLine` plus the Network Information
+ * API (`navigator.connection`) for effective type, downlink, RTT, and
+ * data-saver preference.
+ */
+export declare function createNetwork(): NetworkState;
+export interface WakeLockState {
+    supported: boolean;
+    active: () => boolean;
+    error: () => Error | null;
+    request: () => Promise<void>;
+    release: () => Promise<void>;
+}
+/**
+ * createWakeLock
+ *
+ * Keeps the screen awake with the Screen Wake Lock API. Re-acquires the lock
+ * automatically when the tab becomes visible again after a release.
+ */
+export declare function createWakeLock(): WakeLockState;
+export interface PickedContact {
+    name: string[];
+    tel: string[];
+    email: string[];
+}
+export interface ContactPickState {
+    supported: boolean;
+    contacts: () => PickedContact[];
+    error: () => Error | null;
+    pick: (options?: {
+        multiple?: boolean;
+    }) => Promise<PickedContact[]>;
+}
+/**
+ * createContactPick
+ *
+ * Contact Picker API (`navigator.contacts.select`). Resolves with the chosen
+ * contacts; empty array when the user cancels.
+ */
+export declare function createContactPick(): ContactPickState;
+export interface OTPState {
+    supported: boolean;
+    code: () => string | null;
+    error: () => Error | null;
+    wait: (options?: {
+        transport?: string[];
+    }) => Promise<string | null>;
+    abort: () => void;
+}
+/**
+ * createOTP
+ *
+ * WebOTP API: reads a one-time code from an incoming SMS without leaving the
+ * page. `wait()` resolves with the code (or null when aborted). Works only on
+ * secure origins where the SMS matches the site's origin-bound format.
+ */
+export declare function createOTP(): OTPState;
+export interface ShareState {
+    supported: boolean;
+    canShare: (data: ShareData) => boolean;
+    error: () => Error | null;
+    share: (data: ShareData) => Promise<void>;
+}
+/**
+ * createShare
+ *
+ * Web Share API: opens the native share sheet. `share()` resolves when the
+ * user completes or dismisses the sheet (dismissal is not an error).
+ */
+export declare function createShare(): ShareState;
+export interface NFCRecord {
+    recordType: string;
+    mediaType?: string;
+    text?: string;
+    url?: string;
+}
+export interface NFCMessage {
+    records: NFCRecord[];
+    serialNumber: string;
+}
+export interface NFCState {
+    supported: boolean;
+    scanning: () => boolean;
+    message: () => NFCMessage | null;
+    error: () => Error | null;
+    scan: () => Promise<void>;
+    write: (content: string | {
+        records: Array<Record<string, unknown>>;
+    }) => Promise<void>;
+    abort: () => void;
+}
+/**
+ * createNFC
+ *
+ * Web NFC (Chrome on Android, secure context): scan tags with `scan()` and
+ * read decoded records from `message`; write text or records with `write()`.
+ * Scanning needs a user gesture.
+ */
+export declare function createNFC(): NFCState;
+export interface TorchState {
+    supported: () => boolean;
+    on: () => boolean;
+    error: () => Error | null;
+    attach: (input: MediaStreamTrack | MediaStream) => void;
+    set: (value: boolean) => Promise<void>;
+    toggle: () => Promise<void>;
+}
+/**
+ * createTorch
+ *
+ * Camera flashlight for devices that expose the `torch` capability.
+ * Attach a video track (or stream) from `getUserMedia`, then `set()` or
+ * `toggle()` the flashlight.
+ */
+export declare function createTorch(): TorchState;
+export interface GyroState {
+    supported: boolean;
+    needsPermission: boolean;
+    alpha: () => number | null;
+    beta: () => number | null;
+    gamma: () => number | null;
+    absolute: () => boolean;
+    listening: () => boolean;
+    error: () => Error | null;
+    requestPermission: () => Promise<"granted" | "denied">;
+    start: () => Promise<void>;
+    stop: () => void;
+}
+/**
+ * createGyro
+ *
+ * Device orientation (alpha/beta/gamma in degrees). On iOS the motion
+ * permission prompt must come from a user gesture: call `requestPermission()`
+ * from a tap handler, then `start()`.
+ */
+export declare function createGyro(): GyroState;
+export interface ShakeOptions {
+    /** Acceleration delta (m/s^2) that counts as a shake. Default 15. */
+    threshold?: number;
+    /** Minimum milliseconds between shakes. Default 800. */
+    cooldown?: number;
+    onShake?: () => void;
+}
+export interface ShakeState {
+    supported: boolean;
+    needsPermission: boolean;
+    listening: () => boolean;
+    shakes: () => number;
+    error: () => Error | null;
+    requestPermission: () => Promise<"granted" | "denied">;
+    start: () => Promise<void>;
+    stop: () => void;
+}
+/**
+ * createShake
+ *
+ * Shake-to-undo style detection from `devicemotion`. Counts a shake when the
+ * acceleration delta exceeds `threshold`, rate-limited by `cooldown`.
+ */
+export declare function createShake(options?: ShakeOptions): ShakeState;
+export interface ScanlineOptions {
+    /** Milliseconds per sweep. Default 1800. */
+    duration?: number;
+    /** Sweep pattern. Default "alternate" (ping-pong). */
+    direction?: "down" | "up" | "alternate";
+}
+export interface ScanlineState {
+    /** Line position, 0 at the top edge and 1 at the bottom edge. */
+    progress: () => number;
+    running: () => boolean;
+    start: () => void;
+    stop: () => void;
+}
+/**
+ * createScanline
+ *
+ * The animated line of a camera viewfinder (QR/barcode scanning UI). Bind
+ * `progress()` to the line position, for example
+ * `style={{ top: `${progress() * 100}%` }}`. Runs on the shared clock and
+ * freezes mid-frame under reduced motion.
+ */
+export declare function createScanline(options?: ScanlineOptions): ScanlineState;