sh3-core 0.12.0 → 0.13.0

package/dist/primitives/widgets/FilePicker.svelte

@@ -0,0 +1,79 @@
+<script lang="ts">
+  import { extractValue, displayName, type FilePickerValue } from './FilePicker';
+
+  let {
+    value = $bindable<FilePickerValue>(null),
+    multiple = false,
+    accept,
+    disabled = false,
+    invalid = false,
+    size = 'md',
+    buttonLabel = 'Choose file...',
+  }: {
+    value?: FilePickerValue;
+    multiple?: boolean;
+    accept?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+    buttonLabel?: string;
+  } = $props();
+
+  function onChange(e: Event) {
+    const target = e.currentTarget as HTMLInputElement;
+    value = extractValue(target.files, multiple);
+  }
+
+  const display = $derived(displayName(value));
+</script>
+
+<label class="sh3-fp" class:sh3-fp--sm={size === 'sm'} class:sh3-fp--invalid={invalid}>
+  <input
+    class="sh3-fp__native"
+    type="file"
+    {accept}
+    {multiple}
+    {disabled}
+    onchange={onChange}
+  />
+  <span class="sh3-fp__btn" tabindex="-1">{buttonLabel}</span>
+  <span class="sh3-fp__name">{display || 'no file'}</span>
+</label>
+
+<style>
+  .sh3-fp {
+    display: inline-flex;
+    align-items: stretch;
+    height: var(--shell-field-height-md);
+    border: 1px solid var(--shell-border);
+    border-radius: var(--shell-widget-radius);
+    background: var(--shell-input-bg);
+    overflow: hidden;
+    cursor: pointer;
+    font-size: 0.8125rem;
+  }
+  .sh3-fp--sm { height: var(--shell-field-height-sm); }
+  .sh3-fp--invalid { border-color: var(--shell-error); }
+  .sh3-fp:focus-within { box-shadow: var(--shell-focus-ring); border-color: var(--shell-input-border-focus); }
+
+  .sh3-fp__native {
+    position: absolute;
+    width: 1px; height: 1px;
+    opacity: 0;
+    pointer-events: none;
+  }
+  .sh3-fp__btn {
+    display: inline-flex; align-items: center;
+    padding: 0 var(--shell-field-pad-x);
+    background: var(--shell-bg-elevated);
+    color: var(--shell-fg);
+    border-right: 1px solid var(--shell-border);
+  }
+  .sh3-fp__name {
+    display: inline-flex; align-items: center;
+    padding: 0 var(--shell-field-pad-x);
+    color: var(--shell-fg-muted);
+    flex: 1; min-width: 0;
+    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  }
+</style>

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

@@ -0,0 +1,13 @@
+import { type FilePickerValue } from './FilePicker';
+type $$ComponentProps = {
+    value?: FilePickerValue;
+    multiple?: boolean;
+    accept?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: 'sm' | 'md';
+    buttonLabel?: string;
+};
+declare const FilePicker: import("svelte").Component<$$ComponentProps, {}, "value">;
+type FilePicker = ReturnType<typeof FilePicker>;
+export default FilePicker;

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

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

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

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { extractValue, displayName } from './FilePicker';
+// Test stubs — File and DataTransfer aren't available in node test env, so
+// we structurally fake FileList/File. The helpers only read `length`, indexed
+// access, and `.name` so this is sufficient.
+function mkFile(name) {
+    return { name };
+}
+function mkList(...files) {
+    const list = files;
+    Object.defineProperty(list, 'item', {
+        value: (i) => { var _a; return (_a = files[i]) !== null && _a !== void 0 ? _a : null; },
+    });
+    return list;
+}
+describe('FilePicker value extraction', () => {
+    it('returns null when FileList is empty (single)', () => {
+        expect(extractValue(mkList(), false)).toBe(null);
+    });
+    it('returns first File in single mode', () => {
+        const r = extractValue(mkList(mkFile('a.txt'), mkFile('b.txt')), false);
+        expect(r.name).toBe('a.txt');
+    });
+    it('returns array in multiple mode', () => {
+        const r = extractValue(mkList(mkFile('a.txt'), mkFile('b.txt')), true);
+        expect(r).toHaveLength(2);
+        expect(r[0].name).toBe('a.txt');
+    });
+    it('returns [] when FileList empty in multiple mode', () => {
+        expect(extractValue(null, true)).toEqual([]);
+    });
+    it('displayName: null → empty', () => {
+        expect(displayName(null)).toBe('');
+    });
+    it('displayName: single file → name', () => {
+        expect(displayName(mkFile('cat.png'))).toBe('cat.png');
+    });
+    it('displayName: multiple files → "N files"', () => {
+        expect(displayName([mkFile('a.txt'), mkFile('b.txt')])).toBe('2 files');
+    });
+    it('displayName: single in array → just the name', () => {
+        expect(displayName([mkFile('one.txt')])).toBe('one.txt');
+    });
+});

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

@@ -0,0 +1,2 @@
+export declare function toggleSingle(current: string, candidate: string): string;
+export declare function toggleMultiple(current: string[], candidate: string): string[];

package/dist/primitives/widgets/IconToggleGroup.js

@@ -0,0 +1,8 @@
+export function toggleSingle(current, candidate) {
+    return current === candidate ? '' : candidate;
+}
+export function toggleMultiple(current, candidate) {
+    if (current.includes(candidate))
+        return current.filter((v) => v !== candidate);
+    return [...current, candidate];
+}

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 {};