import { createSignal, onCleanup } from "solid-js"; import preview from "../../../.storybook/preview.js"; import { makeTimer, createTimer, createTimeoutLoop } from "@solid-primitives/timer"; import readme from "../README.md?raw"; import { Stat, Button, Container } from "../../../.storybook/ui/index.js"; const meta = preview.meta({ title: "Browser APIs/Timer", tags: ["autodocs"], parameters: { layout: "centered", docs: { description: { component: readme, }, }, }, }); export default meta; export const MakeTimer = meta.story({ name: "Manual timer", parameters: { docs: { description: { story: "`makeTimer` creates a `setTimeout` or `setInterval` and returns a function to clear it. No reactive lifecycle — the caller is responsible for cleanup (e.g. pass to `onCleanup`).", }, }, }, render: () => { const [count, setCount] = createSignal(0); const [running, setRunning] = createSignal(false); let clear: VoidFunction | undefined; const start = () => { if (running()) return; clear = makeTimer(() => setCount(c => c + 1), 500, setInterval); setRunning(true); }; const stop = () => { clear?.(); clear = undefined; setRunning(false); }; onCleanup(() => clear?.()); return ( makeTimer {count()} Start (500ms) Stop setCount(0)} variant="outline"> Reset Cleanup is manual — onCleanup(makeTimer(...)) ties it to the component lifecycle. ); }, }); export const CreateTimerStory = meta.story({ name: "Reactive interval", parameters: { docs: { description: { story: "`createTimer` wraps `makeTimer` in the reactive lifecycle. Pass a reactive accessor as the delay to change the interval on the fly — elapsed fraction carries forward so ticks stay smooth.", }, }, }, render: () => { const [delay, setDelay] = createSignal(1000); const [count, setCount] = createSignal(0); createTimer(() => setCount(c => c + 1), delay, setInterval); return ( createTimer {count()} {delay() === false ? "paused" : `${delay()}ms`} {([250, 500, 1000, 2000] as const).map(ms => ( setDelay(ms)} variant={delay() === ms ? "primary" : "outline"}> {ms}ms ))} setDelay(false)} variant={delay() === false ? "primary" : "outline"} > Pause ); }, }); export const CreateTimeoutLoop = meta.story({ name: "Between-tick loop", parameters: { docs: { description: { story: "`createTimeoutLoop` is like `createTimer` with `setInterval`, but the new delay only takes effect between executions — mid-tick delay changes don't affect the current interval.", }, }, }, render: () => { const [delay, setDelay] = createSignal(1000); const [count, setCount] = createSignal(0); createTimeoutLoop(() => setCount(c => c + 1), delay); return ( createTimeoutLoop {count()} {delay() === false ? "paused" : `${delay()}ms`} {([250, 500, 1000, 2000] as const).map(ms => ( setDelay(ms)} variant={delay() === ms ? "primary" : "outline"}> {ms}ms ))} setDelay(false)} variant={delay() === false ? "primary" : "outline"} > Pause Change the delay mid-tick — it takes effect on the next execution, not the current one. ); }, });
Cleanup is manual — onCleanup(makeTimer(...)) ties it to the component lifecycle.
onCleanup(makeTimer(...))
Change the delay mid-tick — it takes effect on the next execution, not the current one.