Components95 / 118
Effort Slider
An AI effort picker: a little brain rides a track of stops, leaning and stretching as you drag and springing onto each stop with an overshoot. At the top level the fill breaks into a twinkling pixel galaxy and sparks burst from the brain.
SliderSliderAIAISettingsSettingsCanvasCanvasParticlesParticlesSquash & stretchSquash & stretchGSAPGSAP
EffortMediumHow hard the model thinks before it answers. Higher is slower but smarter.
FasterSmarter
Recommended
Drag the brain to GalaxyOr click the track, or use the arrow keys
Tweak
LIVELIVELook
320px
Galaxy top level
Usage
Follows your tweaks.
usage.tsx
import { useState } from "react";
import { EffortSlider } from "@/components/inreact/effort-slider";
export function ModelSettings() {
const [effort, setEffort] = useState("Medium");
return <EffortSlider value={effort} onValueChange={setEffort} />;
}Install with the CLI
TS + Tailwind
npx shadcn@latest add https://inreact.vercel.app/r/effort-slider.jsonOr copy the source
Install the dependencies, then save this as components/inreact/effort-slider.tsx.
terminal
npm install gsapcomponents/inreact/effort-slider.tsx
"use client";
import { gsap } from "gsap";
import { useCallback, useEffect, useLayoutEffect, useRef, useState, type KeyboardEvent, type PointerEvent as ReactPointerEvent } from "react";
/**
* Effort Slider: a "how hard should the model think" picker for AI products.
*
* A little brain rides a track of stops from "faster" to "smarter", trailing a
* pink-violet fill. Drag it and it leans into the motion and stretches with
* its speed; let go and it springs onto the nearest stop with an overshoot,
* squashing as it lands; it pulses each time it passes a stop. The level name
* swaps with a soft blur. Push it to the last level and the fill breaks into a
* twinkling pixel galaxy, the brain turns violet, and sparks and rays burst out
* of it, still glittering while it stays there. Works with arrows, Home, End.
*
* <EffortSlider defaultValue="Medium" onValueChange={setEffort} />
*/
export interface EffortSliderProps {
levels?: string[];
value?: string;
defaultValue?: string;
onValueChange?: (level: string) => void;
/** Level marked "Recommended" (a taller tick). */
recommended?: string;
title?: string;
minLabel?: string;
maxLabel?: string;
/** Text in the "?" tooltip; empty hides the button. */
info?: string;
/** Give the last level the galaxy treatment. */
galaxy?: boolean;
/** Card width, px. */
width?: number;
className?: string;
}
const reduced = () => typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
const clamp = (a: number, b: number, v: number) => Math.max(a, Math.min(b, v));
// galaxy palette: deep indigo to violet, pink and a little cyan
const PIX = [
[70, 46, 140],
[112, 64, 186],
[150, 92, 214],
[205, 96, 186],
[236, 140, 214],
[120, 214, 236],
[186, 170, 255],
];
function Brain({ violet }: { violet?: boolean }) {
const fill = violet ? "#b9a8ff" : "#f8a6cb";
const ink = violet ? "#4a2fc2" : "#d92f78";
const half = (
<>
<path
d="M15.2 5.6C12.9 3.9 9.2 4.6 8.2 7.3 5.6 7.5 4 10 5 12.3c-1.9 1.5-1.8 5 .5 6.3-.6 3 1.8 5.6 4.8 5.1.9 2.5 3.6 3.2 4.9 1.6z"
fill={fill}
stroke={ink}
strokeWidth="1.9"
strokeLinejoin="round"
/>
<path d="M12.3 7.7c.5 1.5 0 2.7-1.3 3.3M7.9 11.3c1.8-.6 3.4.5 3.3 2.2M6.6 16.7c1.9-1 3.9 0 4 1.9M11.6 20.6c1 .6 1.4 2 1 3" fill="none" stroke={ink} strokeWidth="1.7" strokeLinecap="round" />
</>
);
return (
<svg viewBox="0 0 32 32" className="block size-full overflow-visible" aria-hidden="true">
{half}
<g transform="matrix(-1 0 0 1 32 0)">{half}</g>
{violet && (
<g fill="#fff">
<circle cx="10" cy="9.5" r=".9" />
<circle cx="21.5" cy="14" r=".7" />
<circle cx="12.5" cy="19" r=".6" />
<circle cx="23" cy="20.5" r=".8" />
</g>
)}
</svg>
);
}
/** The level name: the old one blurs away as the new one comes into focus. */
function Swap({ text, glow }: { text: string; glow: boolean }) {
const [items, setItems] = useState([{ id: 0, text }]);
const n = useRef(0);
const [last, setLast] = useState(text);
if (last !== text) {
setLast(text);
n.current += 1;
setItems((it) => [...it.slice(-1), { id: n.current, text }]);
}
return (
<span className="relative inline-grid">
{items.map((it, i) => (
<SwapItem key={it.id} text={it.text} out={i < items.length - 1} first={it.id === 0} glow={glow} onGone={() => setItems((all) => all.filter((x) => x.id !== it.id))} />
))}
</span>
);
}
function SwapItem({ text, out, first, glow, onGone }: { text: string; out: boolean; first: boolean; glow: boolean; onGone: () => void }) {
const ref = useRef<HTMLSpanElement>(null);
useLayoutEffect(() => {
const el = ref.current;
if (!el || first || reduced()) return;
gsap.fromTo(el, { opacity: 0, y: 5, filter: "blur(5px)" }, { opacity: 1, y: 0, filter: "blur(0px)", duration: 0.42, ease: "power3.out" });
}, [first]);
useEffect(() => {
const el = ref.current;
if (!el || !out) return;
if (reduced()) return onGone();
gsap.to(el, { opacity: 0, y: -5, filter: "blur(5px)", duration: 0.3, ease: "power2.in", onComplete: onGone });
}, [out]); // eslint-disable-line react-hooks/exhaustive-deps
return (
<span
ref={ref}
className="col-start-1 row-start-1 whitespace-nowrap transition-[color,text-shadow] duration-500"
style={{ color: glow ? "#aad8ff" : "#f2f2f2", textShadow: glow ? "0 0 10px rgba(130,190,255,.55)" : "none" }}
>
{text}
</span>
);
}
export function EffortSlider({
levels = ["Low", "Medium", "High", "Extra", "Max", "Galaxy"],
value,
defaultValue,
onValueChange,
recommended = "Medium",
title = "Effort",
minLabel = "Faster",
maxLabel = "Smarter",
info = "How hard the model thinks before it answers. Higher is slower but smarter.",
galaxy = true,
width = 320,
className,
}: EffortSliderProps) {
const n = levels.length;
const [inner, setInner] = useState(defaultValue ?? recommended ?? levels[0]);
const cur = value ?? inner;
const idx = Math.max(0, levels.indexOf(cur));
const recIdx = levels.indexOf(recommended);
const isGalaxy = galaxy && idx === n - 1;
const trackRef = useRef<HTMLDivElement>(null);
const fillRef = useRef<HTMLDivElement>(null);
const thumbRef = useRef<HTMLDivElement>(null);
const violetRef = useRef<HTMLDivElement>(null);
const pixRef = useRef<HTMLCanvasElement>(null);
const fxRef = useRef<HTMLCanvasElement>(null);
const dotRefs = useRef<(HTMLSpanElement | null)[]>([]);
const recRef = useRef<HTMLSpanElement>(null);
const api = useRef({ go: (_i: number) => {}, drag: (_x: number | null) => {}, hover: (_on: boolean) => {}, press: (_on: boolean) => {}, galaxy: (_on: boolean) => {} });
const set = useCallback(
(i: number) => {
const v = levels[clamp(0, n - 1, i)];
if (v === cur) return;
if (value === undefined) setInner(v);
onValueChange?.(v);
},
[levels, n, cur, value, onValueChange],
);
const setRef = useRef(set);
setRef.current = set;
// geometry, the thumb spring, the pixel galaxy and the sparks: one ticker
useLayoutEffect(() => {
const track = trackRef.current, fill = fillRef.current, thumb = thumbRef.current, violet = violetRef.current, pix = pixRef.current, fx = fxRef.current;
if (!track || !fill || !thumb || !violet || !pix || !fx) return;
const still = reduced();
const pctx = pix.getContext("2d")!, fctx = fx.getContext("2d")!;
let W = 0, H = 0, dpr = 1;
const stopX = (i: number) => W * 0.055 + (i * (W * 0.89)) / (n - 1);
const measure = () => {
W = track.clientWidth;
H = track.clientHeight;
dpr = Math.min(2, window.devicePixelRatio || 1);
pix.width = Math.round(W * dpr);
pix.height = Math.round(H * dpr);
fx.width = Math.round(fx.clientWidth * dpr);
fx.height = Math.round(fx.clientHeight * dpr);
dotRefs.current.forEach((d, i) => d && (d.style.left = `${stopX(i)}px`));
if (recRef.current && recIdx >= 0) recRef.current.style.left = `${stopX(recIdx)}px`;
};
measure();
const s = { x: stopX(idx), v: 0, t: stopX(idx), k: 260, c: 17 };
let sel = idx, dragging = false, hov = 1, press = 1, pulse = 1, last = s.x;
const g = { a: idx === n - 1 && galaxy ? 1 : 0, wipe: idx === n - 1 && galaxy ? 1 : 0 };
// sparks and rays around the brain
type P = { x: number; y: number; vx: number; vy: number; life: number; max: number; ray: boolean; len: number };
const parts: P[] = [];
const burst = (count: number, power: number) => {
for (let i = 0; i < count; i++) {
const ang = Math.random() * Math.PI * 2, sp = (0.35 + Math.random()) * power;
const ray = Math.random() < 0.45;
parts.push({ x: 0, y: 0, vx: Math.cos(ang) * sp, vy: Math.sin(ang) * sp, life: 0, max: 0.5 + Math.random() * 0.7, ray, len: ray ? 6 + Math.random() * 14 : 0 });
}
};
// per-cell random phase and colour for the mosaic
const seed = Array.from({ length: 4096 }, () => [Math.random(), Math.floor(Math.random() * PIX.length), Math.random()]);
api.current.go = (i: number) => {
sel = clamp(0, n - 1, i);
if (dragging) return; // the finger leads while dragging; it snaps on release
s.t = stopX(sel);
s.k = 260;
s.c = 17;
if (still) (s.x = s.t), (s.v = 0);
};
api.current.drag = (px: number | null) => {
if (px === null) {
dragging = false;
const near = Math.round(((s.x - stopX(0)) / (stopX(n - 1) - stopX(0))) * (n - 1));
api.current.go(near);
setRef.current(near);
return;
}
dragging = true;
s.t = clamp(stopX(0), stopX(n - 1), px);
s.k = 900;
s.c = 52;
if (still) s.x = s.t;
};
api.current.hover = (on) => !still && gsap.to(hv, { v: on ? 1.08 : 1, duration: 0.45, ease: "back.out(3)", overwrite: true });
api.current.press = (on) => !still && gsap.to(pr, { v: on ? 0.86 : 1, duration: on ? 0.1 : 0.6, ease: on ? "power2.out" : "elastic.out(1, 0.4)", overwrite: true });
api.current.galaxy = (on) => {
if (still) return void ((g.a = on ? 1 : 0), (g.wipe = on ? 1 : 0));
gsap.to(g, { a: on ? 1 : 0, duration: on ? 0.45 : 0.35, ease: "power2.out", overwrite: true });
if (on) {
gsap.fromTo(g, { wipe: 0 }, { wipe: 1, duration: 0.8, ease: "power2.out" });
gsap.fromTo(pl, { v: 1.45 }, { v: 1, duration: 0.9, ease: "elastic.out(1, 0.35)" });
burst(46, 150);
}
};
const hv = { v: 1 }, pr = { v: 1 }, pl = { v: 1 };
let lastKey = "";
let pulsed = { i: -1, t: 0 };
let emit = 0;
const tick = (time: number, ms: number) => {
const dt = Math.min(ms / 1000, 1 / 30);
if (!still) for (let k = 0; k < 2; k++) (s.v += (s.k * (s.t - s.x) - s.c * s.v) * (dt / 2)), (s.x += s.v * (dt / 2));
// passing a stop: the brain pulses and the dot pops
for (let i = 0; i < n; i++) {
const sx = stopX(i);
if ((last - sx) * (s.x - sx) < 0 || (last !== s.x && s.x === sx)) {
// a settling overshoot recrosses its own stop: pulse once, not on every wobble
const fresh = pulsed.i !== i || time - pulsed.t > 0.35;
if (fresh) pulsed = { i, t: time };
if (!still && fresh) {
gsap.fromTo(pl, { v: Math.max(pl.v, 1.16) }, { v: 1, duration: 0.5, ease: "elastic.out(1, 0.45)", overwrite: "auto" });
const d = dotRefs.current[i];
if (d) gsap.fromTo(d, { scale: 2.2 }, { scale: 1, duration: 0.5, ease: "back.out(2.5)", overwrite: true });
}
if (dragging) setRef.current(i);
}
}
last = s.x;
// stretch with speed, lean into the motion; volume kept
const sp = Math.abs(s.v);
const sx = 1 + Math.min(0.32, sp / 2600);
const sy = 1 / Math.sqrt(sx);
const tilt = clamp(-14, 14, s.v * 0.012);
const sc = hv.v * pr.v * pl.v;
const key = `${s.x.toFixed(2)}|${sx.toFixed(3)}|${tilt.toFixed(2)}|${sc.toFixed(3)}|${g.a.toFixed(3)}`;
if (key !== lastKey) {
lastKey = key;
thumb.style.transform = `translate3d(${(s.x - thumb.offsetWidth / 2).toFixed(2)}px,-50%,0) rotate(${tilt.toFixed(2)}deg) scale(${(sx * sc).toFixed(3)},${(sy * sc).toFixed(3)})`;
fill.style.width = `${Math.max(0, s.x + H * 0.15).toFixed(2)}px`;
fill.style.opacity = `${(1 - g.a).toFixed(3)}`;
violet.style.opacity = `${g.a.toFixed(3)}`;
}
// the pixel galaxy, twinkling in the fill
pctx.setTransform(dpr, 0, 0, dpr, 0, 0);
pctx.clearRect(0, 0, W, H);
if (g.a > 0.001) {
const rows = 5, cell = H / rows, cols = Math.ceil(W / cell);
const reach = s.x * g.wipe;
const tt = time;
for (let c = 0; c < cols; c++) {
const x0 = c * cell;
if (x0 > reach) break;
const u = x0 / Math.max(1, s.x); // 0 at the left, 1 at the brain
for (let r = 0; r < rows; r++) {
const sd = seed[(c * rows + r) % seed.length];
const tw = 0.5 + 0.5 * Math.sin(tt * (1.6 + sd[2] * 3) + sd[0] * 40);
const on = sd[0] < 0.42 + u * 0.58; // denser toward the brain
if (!on) continue;
const a = g.a * (0.26 + 0.74 * u) * (0.45 + 0.55 * tw) * clamp(0, 1, (reach - x0) / (cell * 3));
if (a < 0.03) continue;
const col = PIX[u < 0.3 ? sd[1] % 3 : sd[1]];
pctx.fillStyle = `rgba(${col[0]},${col[1]},${col[2]},${a.toFixed(3)})`;
pctx.fillRect(x0 + cell * 0.08, r * cell + cell * 0.08, cell * 0.84, cell * 0.84);
}
}
}
// sparks, rays and the halo around the brain
const fw = fx.width / dpr, fh = fx.height / dpr;
fctx.setTransform(dpr, 0, 0, dpr, 0, 0);
fctx.clearRect(0, 0, fw, fh);
if (g.a > 0.01 && !still) {
emit += dt * 26;
while (emit > 1) (emit -= 1), burst(1, 60);
}
if (parts.length || g.a > 0.01) {
const tr = track.getBoundingClientRect(), fr = fx.getBoundingClientRect();
const z = fr.width / Math.max(1, fw); // css zoom/scale of the card
const cx = (tr.left - fr.left) / z + s.x, cy = (tr.top - fr.top) / z + H / 2;
if (g.a > 0.01) {
const R = H * (1.5 + 0.12 * Math.sin(time * 3));
const grd = fctx.createRadialGradient(cx, cy, H * 0.2, cx, cy, R);
grd.addColorStop(0, `rgba(150,130,255,${(0.42 * g.a).toFixed(3)})`);
grd.addColorStop(1, "rgba(150,130,255,0)");
fctx.fillStyle = grd;
fctx.beginPath();
fctx.arc(cx, cy, R, 0, Math.PI * 2);
fctx.fill();
}
for (let i = parts.length - 1; i >= 0; i--) {
const p = parts[i];
p.life += dt;
if (p.life > p.max) {
parts.splice(i, 1);
continue;
}
p.x += p.vx * dt;
p.y += p.vy * dt;
p.vx *= 1 - 1.6 * dt;
p.vy *= 1 - 1.6 * dt;
const f = 1 - p.life / p.max;
const r0 = H * 0.42;
const d = Math.hypot(p.x, p.y) || 1;
const ox = cx + (p.x / d) * r0 + p.x, oy = cy + (p.y / d) * r0 + p.y;
if (p.ray) {
fctx.strokeStyle = `rgba(196,182,255,${(0.75 * f).toFixed(3)})`;
fctx.lineWidth = 1;
fctx.beginPath();
fctx.moveTo(ox, oy);
fctx.lineTo(ox + (p.x / d) * p.len * f, oy + (p.y / d) * p.len * f);
fctx.stroke();
} else {
fctx.fillStyle = `rgba(226,218,255,${(0.9 * f).toFixed(3)})`;
fctx.fillRect(ox - 0.8, oy - 0.8, 1.6, 1.6);
}
}
}
};
gsap.ticker.add(tick);
const ro = new ResizeObserver(() => {
measure();
s.t = stopX(sel);
if (!dragging) s.x = s.t;
});
ro.observe(track);
return () => {
gsap.ticker.remove(tick);
ro.disconnect();
gsap.killTweensOf([hv, pr, pl, g]);
};
}, [n, recIdx, galaxy]); // eslint-disable-line react-hooks/exhaustive-deps
// follow the value (from clicks, keys or the parent)
const wasGalaxy = useRef(isGalaxy);
useEffect(() => {
api.current.go(idx);
if (wasGalaxy.current !== isGalaxy) api.current.galaxy(isGalaxy);
wasGalaxy.current = isGalaxy;
}, [idx, isGalaxy]);
const xFrom = (e: ReactPointerEvent) => {
const r = trackRef.current!.getBoundingClientRect();
const z = r.width / Math.max(1, trackRef.current!.clientWidth);
return (e.clientX - r.left) / z;
};
const down = (e: ReactPointerEvent<HTMLDivElement>) => {
if (e.button !== 0) return;
try {
e.currentTarget.setPointerCapture(e.pointerId);
} catch {}
api.current.press(true);
api.current.drag(xFrom(e));
// focus for the arrow keys, without a keyboard focus ring
thumbRef.current?.focus({ preventScroll: true, focusVisible: false } as FocusOptions);
};
const move = (e: ReactPointerEvent<HTMLDivElement>) => {
if (e.buttons & 1) api.current.drag(xFrom(e));
};
const up = () => {
api.current.press(false);
api.current.drag(null);
};
const onKey = (e: KeyboardEvent) => {
const map: Record<string, number> = { ArrowRight: idx + 1, ArrowUp: idx + 1, ArrowLeft: idx - 1, ArrowDown: idx - 1, Home: 0, End: n - 1, PageUp: idx + 2, PageDown: idx - 2 };
if (map[e.key] === undefined) return;
e.preventDefault();
set(map[e.key]);
};
// the "?" tooltip springs up
const tipRef = useRef<HTMLSpanElement>(null);
const tip = (on: boolean) => {
const t = tipRef.current;
if (!t) return;
if (reduced()) return void gsap.set(t, { autoAlpha: on ? 1 : 0 });
gsap.to(t, on ? { autoAlpha: 1, y: 0, scale: 1, duration: 0.42, ease: "back.out(2.4)" } : { autoAlpha: 0, y: 4, scale: 0.92, duration: 0.18, ease: "power2.in" });
};
const trackH = Math.round(width * 0.092);
return (
<div
className={["relative rounded-[14px] border border-white/[0.07] bg-[#1a1a1b] text-[13px] select-none", className].filter(Boolean).join(" ")}
style={{ width, padding: `${width * 0.05}px ${width * 0.055}px ${width * 0.04}px`, boxShadow: "0 1px 0 rgba(255,255,255,.03) inset, 0 10px 30px -12px rgba(0,0,0,.6)" }}
>
{/* sparks may fly past the card's edge */}
<canvas ref={fxRef} aria-hidden="true" className="pointer-events-none absolute z-20" style={{ inset: -60, width: `calc(100% + 120px)`, height: `calc(100% + 120px)` }} />
<div className="flex items-center justify-between">
<span className="flex items-baseline gap-2">
<span className="text-[#8c8c8f]">{title}</span>
<Swap text={cur} glow={isGalaxy} />
</span>
{info && (
<span className="relative">
<button
type="button"
aria-label={info}
onPointerEnter={() => tip(true)}
onPointerLeave={() => tip(false)}
onFocus={() => tip(true)}
onBlur={() => tip(false)}
className="grid size-6 cursor-help place-items-center rounded-full border-0 bg-transparent p-0 text-[#8c8c8f] outline-none transition-colors hover:text-white focus-visible:ring-2 focus-visible:ring-white/30"
>
<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" aria-hidden="true">
<circle cx="12" cy="12" r="9" />
<path d="M9.6 9.4a2.5 2.5 0 0 1 4.8.9c0 1.7-2.4 2-2.4 3.6" />
<circle cx="12" cy="17.2" r=".4" fill="currentColor" />
</svg>
</button>
<span
ref={tipRef}
role="tooltip"
className="invisible absolute right-0 bottom-full z-30 mb-2 w-52 origin-bottom-right rounded-[10px] bg-[#2a2a2c] px-3 py-2 text-[12px] leading-snug text-[#e6e6e8] opacity-0"
style={{ boxShadow: "0 8px 24px -8px rgba(0,0,0,.6)" }}
>
{info}
</span>
</span>
)}
</div>
<div className="mt-[1.1em] flex justify-between text-[#8c8c8f]">
<span>{minLabel}</span>
<span>{maxLabel}</span>
</div>
<div
ref={trackRef}
onPointerDown={down}
onPointerMove={move}
onPointerUp={up}
onPointerCancel={up}
className="relative mt-[0.6em] cursor-pointer touch-none rounded-[8px] bg-[#262628]"
style={{ height: trackH }}
>
<div ref={fillRef} className="pointer-events-none absolute inset-y-0 left-0 overflow-hidden rounded-[8px]" style={{ background: "linear-gradient(90deg, rgba(120,60,130,.12), rgba(150,84,166,.55) 55%, #9a63ad)" }} />
<canvas ref={pixRef} aria-hidden="true" className="pointer-events-none absolute inset-0 size-full rounded-[8px]" />
{levels.map((l, i) => (
<span
key={l}
ref={(el) => void (dotRefs.current[i] = el)}
aria-hidden="true"
className="pointer-events-none absolute top-1/2 -translate-x-1/2 -translate-y-1/2 rounded-full bg-white/25"
style={i === recIdx ? { width: 3, height: trackH * 0.42, borderRadius: 2 } : { width: 4, height: 4 }}
/>
))}
<div
ref={thumbRef}
role="slider"
tabIndex={0}
aria-label={title}
aria-valuemin={0}
aria-valuemax={n - 1}
aria-valuenow={idx}
aria-valuetext={cur}
onKeyDown={onKey}
onPointerEnter={() => api.current.hover(true)}
onPointerLeave={() => api.current.hover(false)}
className="absolute top-1/2 left-0 z-10 cursor-grab rounded-full outline-none will-change-transform focus-visible:ring-2 focus-visible:ring-white/40 active:cursor-grabbing"
style={{ width: trackH * 1.18, height: trackH * 1.18 }}
>
<Brain />
<div ref={violetRef} className="absolute inset-0" style={{ opacity: 0 }}>
<Brain violet />
</div>
</div>
</div>
<div className="relative mt-[0.45em] h-[1.4em] text-[#8c8c8f]">
{recIdx >= 0 && (
<span ref={recRef} className="absolute top-0 whitespace-nowrap" style={{ transform: "translateX(-28%)" }}>
Recommended
</span>
)}
</div>
</div>
);
}
export default EffortSlider;
One prompt, any AI agent
Paste into Claude Code, Codex, Cursor or Windsurf. It carries your tweaks and the full source, so the agent installs it exactly.
Props
12 propslevelsstring[]The stops, from faster to smarter.default ["Low", …, "Galaxy"]default ["Low", …, "Galaxy"]valuestringControlled level.defaultValuestringStarting level (the recommended one by default).onValueChange(level) => voidCalled as the level changes.recommendedstringLevel marked Recommended.default "Medium"default "Medium"titlestringCard title.default "Effort"default "Effort"minLabelstringLeft end label.default "Faster"default "Faster"maxLabelstringRight end label.default "Smarter"default "Smarter"infostringTooltip text for the ? button (empty hides it).galaxybooleanGalaxy treatment for the last level.default truedefault truewidthnumberCard width, px.default 320default 320classNamestringExtra classes.