sh3-core 0.11.8 → 0.13.0

package/dist/primitives/widgets/IconToggleGroup.svelte

@@ -0,0 +1,86 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { toggleSingle, toggleMultiple } from './IconToggleGroup';
+
+  type Option = { value: string; icon: Snippet; tooltip?: string };
+
+  let {
+    options,
+    value = $bindable(),
+    multiple = false,
+    disabled = false,
+    size = 'md',
+  }: {
+    options: Option[];
+    value: string | string[];
+    multiple?: boolean;
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+  } = $props();
+
+  function isActive(v: string): boolean {
+    if (multiple && Array.isArray(value)) return value.includes(v);
+    return value === v;
+  }
+
+  function onClick(v: string) {
+    if (disabled) return;
+    if (multiple) {
+      const arr = Array.isArray(value) ? value : [];
+      value = toggleMultiple(arr, v);
+    } else {
+      value = toggleSingle(typeof value === 'string' ? value : '', v);
+    }
+  }
+</script>
+
+<div role="group" class="sh3-itg" class:sh3-itg--sm={size === 'sm'}>
+  {#each options as opt}
+    <button
+      type="button"
+      title={opt.tooltip}
+      aria-label={opt.tooltip}
+      aria-pressed={isActive(opt.value)}
+      {disabled}
+      class:sh3-itg__btn--active={isActive(opt.value)}
+      onclick={() => onClick(opt.value)}
+    >{@render opt.icon()}</button>
+  {/each}
+</div>
+
+<style>
+  .sh3-itg {
+    display: inline-flex;
+    background: var(--shell-bg-sunken);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-widget-radius);
+    padding: 2px;
+    gap: 2px;
+  }
+  .sh3-itg button {
+    width: 26px; height: 26px;
+    background: transparent;
+    color: var(--shell-fg-muted);
+    border: none;
+    border-radius: var(--shell-radius-sm);
+    cursor: pointer;
+    display: inline-flex; align-items: center; justify-content: center;
+    padding: 0;
+    transition: background var(--shell-motion-fast) var(--shell-ease-standard),
+                color var(--shell-motion-fast) var(--shell-ease-standard);
+  }
+  .sh3-itg--sm button { width: 22px; height: 22px; }
+  .sh3-itg button:hover:not(:disabled):not(.sh3-itg__btn--active) {
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg);
+    filter: none;
+  }
+  .sh3-itg__btn--active {
+    background: var(--shell-accent);
+    color: var(--shell-fg-on-accent);
+    font-weight: 600;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25), inset 0 0 0 1px color-mix(in srgb, var(--shell-fg-on-accent) 25%, transparent);
+  }
+  .sh3-itg button:focus-visible { outline: none; box-shadow: var(--shell-focus-ring); }
+  .sh3-itg button:disabled { opacity: 0.5; cursor: not-allowed; }
+</style>

package/dist/primitives/widgets/IconToggleGroup.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { Snippet } from 'svelte';
+type Option = {
+    value: string;
+    icon: Snippet;
+    tooltip?: string;
+};
+type $$ComponentProps = {
+    options: Option[];
+    value: string | string[];
+    multiple?: boolean;
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+};
+declare const IconToggleGroup: import("svelte").Component<$$ComponentProps, {}, "value">;
+type IconToggleGroup = ReturnType<typeof IconToggleGroup>;
+export default IconToggleGroup;

package/dist/primitives/widgets/IconToggleGroup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primitives/widgets/IconToggleGroup.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { toggleSingle, toggleMultiple } from './IconToggleGroup';
+describe('IconToggleGroup state', () => {
+    it('single mode replaces value', () => {
+        expect(toggleSingle('a', 'b')).toBe('b');
+    });
+    it('single mode toggling current value clears it', () => {
+        expect(toggleSingle('a', 'a')).toBe('');
+    });
+    it('multi mode adds new value', () => {
+        expect(toggleMultiple(['a'], 'b')).toEqual(['a', 'b']);
+    });
+    it('multi mode removes existing value', () => {
+        expect(toggleMultiple(['a', 'b'], 'a')).toEqual(['b']);
+    });
+    it('multi mode preserves order on add', () => {
+        expect(toggleMultiple(['a', 'c'], 'b')).toEqual(['a', 'c', 'b']);
+    });
+});

package/dist/primitives/widgets/NumberInput.d.ts

@@ -0,0 +1,6 @@
+export declare function clamp(value: number, min: number | undefined, max: number | undefined): number;
+export declare function applyStep(value: number, opts: {
+    min?: number;
+    step: number;
+}): number;
+export declare function formatNumber(value: number, precision: number | undefined): string;

package/dist/primitives/widgets/NumberInput.js

@@ -0,0 +1,19 @@
+export function clamp(value, min, max) {
+    let v = value;
+    if (min !== undefined && v < min)
+        v = min;
+    if (max !== undefined && v > max)
+        v = max;
+    return v;
+}
+export function applyStep(value, opts) {
+    var _a;
+    const base = (_a = opts.min) !== null && _a !== void 0 ? _a : 0;
+    const k = Math.round((value - base) / opts.step);
+    return base + k * opts.step;
+}
+export function formatNumber(value, precision) {
+    if (precision === undefined)
+        return String(value);
+    return value.toFixed(precision);
+}

package/dist/primitives/widgets/NumberInput.svelte

@@ -0,0 +1,167 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { clamp, applyStep, formatNumber } from './NumberInput';
+
+  let {
+    value = $bindable(0),
+    min,
+    max,
+    step = 1,
+    precision,
+    label,
+    prefix,
+    suffix,
+    disabled = false,
+    invalid = false,
+    size = 'md',
+  }: {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    label?: string;
+    prefix?: Snippet;
+    suffix?: Snippet;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+  } = $props();
+
+  const display = $derived(formatNumber(value, precision));
+
+  function commit(next: number) {
+    if (Number.isNaN(next)) return;
+    value = clamp(applyStep(next, { min, step }), min, max);
+  }
+
+  function bump(direction: 1 | -1) {
+    commit(value + direction * step);
+  }
+
+  let holdTimer: ReturnType<typeof setTimeout> | null = null;
+  let holdInterval: ReturnType<typeof setInterval> | null = null;
+  function startHold(direction: 1 | -1) {
+    if (disabled) return;
+    bump(direction);
+    holdTimer = setTimeout(() => {
+      let elapsed = 0;
+      holdInterval = setInterval(() => {
+        bump(direction);
+        elapsed += 60;
+        if (elapsed > 1500 && holdInterval) {
+          clearInterval(holdInterval);
+          holdInterval = setInterval(() => bump(direction), 20);
+        }
+      }, 60);
+    }, 350);
+  }
+  function stopHold() {
+    if (holdTimer) { clearTimeout(holdTimer); holdTimer = null; }
+    if (holdInterval) { clearInterval(holdInterval); holdInterval = null; }
+  }
+</script>
+
+<label class="sh3-num" class:sh3-num--invalid={invalid} class:sh3-num--sm={size === 'sm'}>
+  {#if label}<span class="sh3-num__label">{label}</span>{/if}
+  <span class="sh3-num__row">
+    {#if prefix}<span class="sh3-num__affix">{@render prefix()}</span>{/if}
+    <input
+      class="sh3-num__input"
+      type="number"
+      {min}
+      {max}
+      {step}
+      {disabled}
+      aria-invalid={invalid || undefined}
+      value={display}
+      oninput={(e) => commit(parseFloat((e.currentTarget as HTMLInputElement).value))}
+    />
+    {#if suffix}<span class="sh3-num__affix">{@render suffix()}</span>{/if}
+    <span class="sh3-num__steppers">
+      <button type="button" {disabled}
+              onpointerdown={() => startHold(1)}
+              onpointerup={stopHold}
+              onpointerleave={stopHold}
+              aria-label="Increase">▲</button>
+      <button type="button" {disabled}
+              onpointerdown={() => startHold(-1)}
+              onpointerup={stopHold}
+              onpointerleave={stopHold}
+              aria-label="Decrease">▼</button>
+    </span>
+  </span>
+</label>
+
+<style>
+  .sh3-num { display: inline-flex; flex-direction: column; gap: 4px; font-size: 0.8125rem; }
+  .sh3-num__label { color: var(--shell-fg-muted); font-size: 0.75rem; }
+  .sh3-num__row {
+    display: inline-flex;
+    align-items: stretch;
+    background: var(--shell-input-bg);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-widget-radius);
+    height: var(--shell-field-height-md);
+  }
+  .sh3-num--sm .sh3-num__row { height: var(--shell-field-height-sm); }
+  .sh3-num__row:focus-within {
+    border-color: var(--shell-input-border-focus);
+    box-shadow: var(--shell-focus-ring);
+  }
+  .sh3-num--invalid .sh3-num__row { border-color: var(--shell-error); }
+  .sh3-num__input {
+    flex: 1 1 auto;
+    min-width: 50px;
+    padding: 0 var(--shell-field-pad-x);
+    background: transparent;
+    border: none;
+    color: var(--shell-fg);
+    font: inherit;
+    outline: none;
+    -moz-appearance: textfield;
+    appearance: textfield;
+  }
+  /* Row owns the focus ring; suppress base.css's global input:focus-visible. */
+  .sh3-num__input:focus,
+  .sh3-num__input:focus-visible {
+    outline: none;
+    box-shadow: none;
+    border: none;
+  }
+  .sh3-num__input::-webkit-outer-spin-button,
+  .sh3-num__input::-webkit-inner-spin-button {
+    -webkit-appearance: none;
+    margin: 0;
+  }
+  .sh3-num__affix {
+    display: inline-flex;
+    align-items: center;
+    padding: 0 6px;
+    color: var(--shell-fg-muted);
+  }
+  .sh3-num__steppers {
+    display: inline-flex;
+    flex-direction: column;
+    border-left: 1px solid var(--shell-border);
+  }
+  .sh3-num__steppers button {
+    flex: 1;
+    width: 18px;
+    background: transparent;
+    color: var(--shell-fg-muted);
+    border: none;
+    border-radius: 0;
+    padding: 0;
+    cursor: pointer;
+    font-size: 8px;
+    line-height: 1;
+  }
+  .sh3-num__steppers button:hover:not(:disabled) {
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg);
+    filter: none;
+  }
+  .sh3-num__steppers button:disabled { cursor: not-allowed; opacity: 0.5; }
+  .sh3-num__steppers button + button { border-top: 1px solid var(--shell-border); }
+</style>

package/dist/primitives/widgets/NumberInput.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    label?: string;
+    prefix?: Snippet;
+    suffix?: Snippet;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+};
+declare const NumberInput: import("svelte").Component<$$ComponentProps, {}, "value">;
+type NumberInput = ReturnType<typeof NumberInput>;
+export default NumberInput;

package/dist/primitives/widgets/NumberInput.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primitives/widgets/NumberInput.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { clamp, applyStep, formatNumber } from './NumberInput';
+describe('NumberInput value math', () => {
+    it('clamps below min', () => {
+        expect(clamp(-5, 0, 10)).toBe(0);
+    });
+    it('clamps above max', () => {
+        expect(clamp(15, 0, 10)).toBe(10);
+    });
+    it('passes through when in range', () => {
+        expect(clamp(5, 0, 10)).toBe(5);
+    });
+    it('handles undefined min/max', () => {
+        expect(clamp(5, undefined, undefined)).toBe(5);
+    });
+    it('applyStep snaps to step grid relative to min', () => {
+        expect(applyStep(2.7, { min: 0, step: 0.5 })).toBe(2.5);
+        expect(applyStep(2.8, { min: 0, step: 0.5 })).toBe(3);
+    });
+    it('applyStep with min=1 snaps to 1, 1.5, 2, ...', () => {
+        expect(applyStep(1.7, { min: 1, step: 0.5 })).toBe(1.5);
+    });
+    it('formatNumber respects precision', () => {
+        expect(formatNumber(3.14159, 2)).toBe('3.14');
+        expect(formatNumber(3.14159, 0)).toBe('3');
+        expect(formatNumber(3, undefined)).toBe('3');
+    });
+});

package/dist/primitives/widgets/RangeSlider.d.ts

@@ -0,0 +1,2 @@
+export type Pair = [number, number];
+export declare function constrainPair(current: Pair, which: 'low' | 'high', next: number): Pair;

package/dist/primitives/widgets/RangeSlider.js

@@ -0,0 +1,7 @@
+export function constrainPair(current, which, next) {
+    const [lo, hi] = current;
+    if (which === 'low') {
+        return [Math.min(next, hi), hi];
+    }
+    return [lo, Math.max(next, lo)];
+}

package/dist/primitives/widgets/RangeSlider.svelte

@@ -0,0 +1,124 @@
+<script lang="ts">
+  import { valueToPercent } from './Slider';
+  import { constrainPair, type Pair } from './RangeSlider';
+
+  let {
+    value = $bindable<Pair>([0, 100]),
+    min = 0,
+    max = 100,
+    step = 1,
+    disabled = false,
+    invalid = false,
+    size = 'md',
+  }: {
+    value?: Pair;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+  } = $props();
+
+  const lowPct = $derived(valueToPercent(value[0], min, max));
+  const highPct = $derived(valueToPercent(value[1], min, max));
+
+  function setLow(n: number) { value = constrainPair(value, 'low', n); }
+  function setHigh(n: number) { value = constrainPair(value, 'high', n); }
+</script>
+
+<div class="sh3-range" class:sh3-range--sm={size === 'sm'} class:sh3-range--invalid={invalid}>
+  <div class="sh3-range__track">
+    <div class="sh3-range__fill"
+         style:--lo="{lowPct}%"
+         style:--hi="{highPct}%"></div>
+  </div>
+  <input type="range" class="sh3-range__native sh3-range__native--low"
+         {min} {max} {step} {disabled}
+         value={value[0]}
+         oninput={(e) => setLow(parseFloat((e.currentTarget as HTMLInputElement).value))} />
+  <input type="range" class="sh3-range__native sh3-range__native--high"
+         {min} {max} {step} {disabled}
+         value={value[1]}
+         oninput={(e) => setHigh(parseFloat((e.currentTarget as HTMLInputElement).value))} />
+</div>
+
+<style>
+  .sh3-range {
+    --thumb-size: 14px;
+    position: relative;
+    width: 200px; height: var(--thumb-size);
+  }
+  .sh3-range--sm { --thumb-size: 12px; }
+  .sh3-range__track {
+    position: absolute;
+    top: 50%; left: 0; right: 0;
+    height: 4px;
+    transform: translateY(-50%);
+    background: var(--shell-track-bg);
+    border: 1px solid var(--shell-track-border);
+    border-radius: var(--shell-widget-radius-pill);
+  }
+  .sh3-range__fill {
+    position: absolute;
+    top: 0; bottom: 0;
+    left: var(--lo);
+    width: calc(var(--hi) - var(--lo));
+    background: var(--shell-track-fill);
+    border-radius: inherit;
+  }
+  .sh3-range__native {
+    position: absolute;
+    top: 0; left: 0;
+    width: 100%; height: 100%;
+    margin: 0;
+    background: transparent;
+    -webkit-appearance: none;
+    appearance: none;
+    pointer-events: none;
+  }
+  /* See Slider.svelte — pin opacity at element level so disabled
+     thumb stays opaque rather than translucent. */
+  .sh3-range__native:disabled { opacity: 1; cursor: not-allowed; }
+  .sh3-range__native::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    width: var(--thumb-size); height: var(--thumb-size);
+    border-radius: 50%;
+    background: var(--shell-thumb-bg);
+    border: 2px solid var(--shell-thumb-border);
+    box-shadow: var(--shell-thumb-shadow);
+    pointer-events: auto;
+    cursor: pointer;
+    opacity: 1;
+  }
+  .sh3-range__native::-moz-range-thumb {
+    width: var(--thumb-size); height: var(--thumb-size);
+    border-radius: 50%;
+    background: var(--shell-thumb-bg);
+    border: 2px solid var(--shell-thumb-border);
+    box-shadow: var(--shell-thumb-shadow);
+    pointer-events: auto;
+    cursor: pointer;
+    opacity: 1;
+  }
+  .sh3-range__native:disabled::-webkit-slider-thumb {
+    background: var(--shell-fg-subtle);
+    border-color: var(--shell-border-strong);
+    cursor: not-allowed;
+    opacity: 1;
+  }
+  .sh3-range__native:disabled::-moz-range-thumb {
+    background: var(--shell-fg-subtle);
+    border-color: var(--shell-border-strong);
+    cursor: not-allowed;
+    opacity: 1;
+  }
+  .sh3-range:has(.sh3-range__native:disabled) .sh3-range__fill {
+    background: var(--shell-border-strong);
+  }
+  .sh3-range__native::-webkit-slider-runnable-track,
+  .sh3-range__native::-moz-range-track {
+    background: transparent;
+  }
+  .sh3-range--invalid .sh3-range__track { border-color: var(--shell-error); }
+</style>

package/dist/primitives/widgets/RangeSlider.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type Pair } from './RangeSlider';
+type $$ComponentProps = {
+    value?: Pair;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+};
+declare const RangeSlider: import("svelte").Component<$$ComponentProps, {}, "value">;
+type RangeSlider = ReturnType<typeof RangeSlider>;
+export default RangeSlider;

package/dist/primitives/widgets/RangeSlider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primitives/widgets/RangeSlider.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { constrainPair } from './RangeSlider';
+describe('RangeSlider thumb-no-cross', () => {
+    it('keeps low <= high when low pushes up', () => {
+        expect(constrainPair([3, 5], 'low', 7)).toEqual([5, 5]);
+    });
+    it('keeps low <= high when high pushes down', () => {
+        expect(constrainPair([3, 5], 'high', 1)).toEqual([3, 3]);
+    });
+    it('passes through when not crossing', () => {
+        expect(constrainPair([3, 5], 'low', 4)).toEqual([4, 5]);
+        expect(constrainPair([3, 5], 'high', 6)).toEqual([3, 6]);
+    });
+});

package/dist/primitives/widgets/Segmented.d.ts

@@ -0,0 +1,9 @@
+export interface SegmentedOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export declare function nextValue(opts: SegmentedOption[], current: string): string;
+export declare function prevValue(opts: SegmentedOption[], current: string): string;
+export declare function firstValue(opts: SegmentedOption[]): string | undefined;
+export declare function lastValue(opts: SegmentedOption[]): string | undefined;

package/dist/primitives/widgets/Segmented.js

@@ -0,0 +1,28 @@
+function activeOptions(opts) {
+    return opts.filter((o) => !o.disabled);
+}
+export function nextValue(opts, current) {
+    const active = activeOptions(opts);
+    if (active.length === 0)
+        return current;
+    const idx = active.findIndex((o) => o.value === current);
+    const next = active[(idx + 1 + active.length) % active.length];
+    return next.value;
+}
+export function prevValue(opts, current) {
+    const active = activeOptions(opts);
+    if (active.length === 0)
+        return current;
+    const idx = active.findIndex((o) => o.value === current);
+    const prev = active[(idx - 1 + active.length) % active.length];
+    return prev.value;
+}
+export function firstValue(opts) {
+    var _a;
+    return (_a = activeOptions(opts)[0]) === null || _a === void 0 ? void 0 : _a.value;
+}
+export function lastValue(opts) {
+    var _a;
+    const a = activeOptions(opts);
+    return (_a = a[a.length - 1]) === null || _a === void 0 ? void 0 : _a.value;
+}

package/dist/primitives/widgets/Segmented.svelte

@@ -0,0 +1,82 @@
+<script lang="ts">
+  import { type SegmentedOption, nextValue, prevValue, firstValue, lastValue } from './Segmented';
+
+  let {
+    options,
+    value = $bindable(),
+    size = 'md',
+    disabled = false,
+  }: {
+    options: SegmentedOption[];
+    value: string;
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+  } = $props();
+
+  function onKey(e: KeyboardEvent) {
+    if (disabled) return;
+    let next: string | undefined;
+    switch (e.key) {
+      case 'ArrowRight': case 'ArrowDown': next = nextValue(options, value); break;
+      case 'ArrowLeft': case 'ArrowUp':    next = prevValue(options, value); break;
+      case 'Home':                          next = firstValue(options); break;
+      case 'End':                           next = lastValue(options); break;
+      default: return;
+    }
+    e.preventDefault();
+    if (next !== undefined) value = next;
+  }
+</script>
+
+<div role="radiogroup" tabindex="-1" class="sh3-seg" class:sh3-seg--sm={size === 'sm'} onkeydown={onKey}>
+  {#each options as opt}
+    <button
+      type="button"
+      role="radio"
+      aria-checked={value === opt.value}
+      tabindex={value === opt.value ? 0 : -1}
+      disabled={disabled || opt.disabled}
+      class:sh3-seg__btn--active={value === opt.value}
+      onclick={() => { if (!opt.disabled && !disabled) value = opt.value; }}
+    >{opt.label}</button>
+  {/each}
+</div>
+
+<style>
+  .sh3-seg {
+    display: inline-flex;
+    background: var(--shell-bg-sunken);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-widget-radius-pill);
+    padding: 2px;
+    height: var(--shell-field-height-md);
+    gap: 0;
+  }
+  .sh3-seg--sm { height: var(--shell-field-height-sm); }
+  .sh3-seg button {
+    background: transparent;
+    color: var(--shell-fg-muted);
+    border: none;
+    padding: 0 var(--shell-field-pad-x);
+    border-radius: var(--shell-widget-radius-pill);
+    font-size: 0.8125rem;
+    cursor: pointer;
+    transition: background var(--shell-motion-fast) var(--shell-ease-standard),
+                color var(--shell-motion-fast) var(--shell-ease-standard);
+  }
+  .sh3-seg button:hover:not(:disabled):not(.sh3-seg__btn--active) {
+    color: var(--shell-fg);
+    filter: none;
+  }
+  .sh3-seg__btn--active {
+    background: var(--shell-accent);
+    color: var(--shell-fg-on-accent);
+    font-weight: 600;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25), inset 0 0 0 1px color-mix(in srgb, var(--shell-fg-on-accent) 25%, transparent);
+  }
+  .sh3-seg button:disabled { opacity: 0.5; cursor: not-allowed; }
+  .sh3-seg button:focus-visible {
+    outline: none;
+    box-shadow: var(--shell-focus-ring);
+  }
+</style>

package/dist/primitives/widgets/Segmented.svelte.d.ts

@@ -0,0 +1,10 @@
+import { type SegmentedOption } from './Segmented';
+type $$ComponentProps = {
+    options: SegmentedOption[];
+    value: string;
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+};
+declare const Segmented: import("svelte").Component<$$ComponentProps, {}, "value">;
+type Segmented = ReturnType<typeof Segmented>;
+export default Segmented;

package/dist/primitives/widgets/Segmented.test.d.ts

@@ -0,0 +1 @@
+export {};