@torpor/ui 0.4.0 → 1.0.1

package/dist/Progress/Progress.torp

@@ -0,0 +1,88 @@
+import type { ClassValue, StyleValue } from "@torpor/view";
+
+interface ProgressProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Classes for the root element */
+	class?: ClassValue;
+	/** Styles for the root element */
+	style?: StyleValue;
+	/** The minimum value (default 0) */
+	min?: number;
+	/** The maximum value (default 100) */
+	max?: number;
+	/** The current value; omit it for an indeterminate progress bar */
+	value?: number;
+	/** A human-readable version of the current value, e.g. "3 of 10 files" */
+	valuetext?: string;
+	/** An accessible name for the progress bar */
+	ariaLabel?: string;
+}
+
+/**
+ * A progress bar that shows how far along an operation is, either with a
+ * specific value or as indeterminate when the extent is unknown.
+ *
+ * See [the WAI ARIA guidelines for Progress Bars](https://www.w3.org/WAI/ARIA/apg/patterns/progressbar/).
+ */
+export default function Progress($props: ProgressProps | undefined) {
+	function getMin(): number {
+		return $props?.min ?? 0;
+	}
+	function getMax(): number {
+		return $props?.max ?? 100;
+	}
+	function isIndeterminate(): boolean {
+		return $props?.value == null;
+	}
+
+	// The clamped value that is reported to assistive tech
+	function getValue(): number {
+		return Math.min(getMax(), Math.max(getMin(), $props?.value ?? getMin()));
+	}
+
+	// The percentage of the range that the value represents (0..100)
+	function getPct(): number {
+		const min = getMin();
+		const max = getMax();
+		if (max <= min) return 0;
+		return ((getValue() - min) / (max - min)) * 100;
+	}
+
+	@render {
+		<div
+			{$props?.id}
+			class={["torp-progress", $props?.class]}
+			{$props?.style}
+			role="progressbar"
+			aria-label={$props?.ariaLabel}
+			aria-valuemin={isIndeterminate() ? undefined : getMin()}
+			aria-valuemax={isIndeterminate() ? undefined : getMax()}
+			aria-valuenow={isIndeterminate() ? undefined : getValue()}
+			aria-valuetext={$props?.valuetext}
+			data-state={isIndeterminate() ? "indeterminate" : "determinate"}
+		>
+			<div
+				class="torp-progress-bar"
+				data-state={isIndeterminate() ? "indeterminate" : "determinate"}
+				style={isIndeterminate() ? undefined : `width: ${getPct()}%;`}
+			/>
+		</div>
+	}
+
+	@style {
+		/* Headless: layout only, so the bar fills the track proportionally.
+		   All appearance is up to the consuming theme */
+		.torp-progress {
+			position: relative;
+			overflow: hidden;
+		}
+		.torp-progress-bar {
+			position: absolute;
+			inset: 0 auto 0 0;
+		}
+		.torp-progress-bar[data-state="indeterminate"] {
+			width: 100%;
+		}
+	}
+}

package/dist/Progress/index.d.ts

@@ -0,0 +1,37 @@
+import { type SlotRender } from "@torpor/view";
+
+
+interface ProgressProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Classes for the root element */
+	class?: ClassValue;
+	/** Styles for the root element */
+	style?: StyleValue;
+	/** The minimum value (default 0) */
+	min?: number;
+	/** The maximum value (default 100) */
+	max?: number;
+	/** The current value; omit it for an indeterminate progress bar */
+	value?: number;
+	/** A human-readable version of the current value, e.g. "3 of 10 files" */
+	valuetext?: string;
+	/** An accessible name for the progress bar */
+	ariaLabel?: string;
+}
+
+/**
+ * A progress bar that shows how far along an operation is, either with a
+ * specific value or as indeterminate when the extent is unknown.
+ *
+ * See [the WAI ARIA guidelines for Progress Bars](https://www.w3.org/WAI/ARIA/apg/patterns/progressbar/).
+ */
+declare function Progress(
+	$parent: ParentNode,
+	$anchor: Node | null,
+	$props: ProgressProps | undefined,
+	$context?: Record<PropertyKey, any>,
+	$slots?: Record<string, SlotRender>,
+): void;
+
+export { Progress };

package/dist/Progress/index.js

@@ -0,0 +1,2 @@
+import Progress from "./Progress.torp";
+export { Progress };

package/dist/Rating/Rating.torp

@@ -0,0 +1,225 @@
+import type { Bindable, ClassValue, StyleValue } from "@torpor/view";
+import $handle from "../utils/$handle";
+import {
+	type FieldContext,
+	FieldContextName,
+	type FormContext,
+	FormContextName,
+} from "../Form/FormTypes";
+import FormValues from "../Form/FormValues.torp";
+import createFormField from "../utils/formField";
+
+interface RatingProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Classes for the root element */
+	class?: ClassValue;
+	/** Styles for the root element */
+	style?: StyleValue;
+	/** The maximum rating, i.e. the number of stars (default 5) */
+	max?: number;
+	/** The current rating */
+	value?: Bindable<number>;
+	/** If set to true, the user cannot interact with this rating */
+	disabled?: boolean;
+	/** If set to false, clicking or re-selecting the current rating does not clear it (default true) */
+	allowClear?: boolean;
+	/** An accessible name for the rating */
+	ariaLabel?: string;
+	/** The name of the component's form data field */
+	name?: string;
+	/** Raised when the rating has changed */
+	onchange?: (value: number) => void;
+}
+
+/**
+ * A star rating input, where the user selects a value from 1 to a maximum
+ * number of stars by clicking or by using the keyboard.
+ *
+ * Implements the radio group pattern: each star is a radio button, the star
+ * matching the current rating is checked, and arrow keys move the rating.
+ *
+ * See [the WAI ARIA guidelines for Rating](https://www.w3.org/WAI/ARIA/apg/patterns/rating/).
+ */
+export default function Rating($props: RatingProps | undefined) {
+	let stars: (HTMLButtonElement | undefined)[] = [];
+	let root: HTMLElement;
+
+	// Wire up the enclosing Form and Field, if any
+	const form = createFormField(
+		$props?.name,
+		$context[FormContextName] as FormContext | undefined,
+		$context[FieldContextName] as FieldContext | undefined,
+	);
+
+	function getMax(): number {
+		const max = $props?.max ?? 5;
+		return max > 0 ? Math.floor(max) : 5;
+	}
+	function getDisabled(): boolean {
+		return $props?.disabled === true;
+	}
+
+	let $state = $watch({
+		value: 0,
+		hover: 0,
+		get stars(): number[] {
+			return Array.from({ length: getMax() }, (_, i) => i + 1);
+		},
+	});
+
+	$bind($state, $props, "value");
+
+	// Keep the stored value clamped, so that out-of-range initial values
+	// don't later surface as user changes
+	$run(() => {
+		const clamped = clamp($state.value);
+		if (clamped !== $state.value) {
+			$state.value = clamped;
+		}
+	});
+
+	// Dispatch the change event when the value changes
+	$handle((first) => {
+		const value = $state.value;
+		if (!first) $props?.onchange?.(value);
+	});
+
+	function clamp(value: number): number {
+		return Math.min(getMax(), Math.max(0, value));
+	}
+
+	function getValue(): number {
+		return clamp($state.value);
+	}
+
+	function setValue(value: number, focus = false) {
+		const next = clamp(value);
+		if (next !== $state.value) {
+			$state.value = next;
+		}
+		if (focus) {
+			stars[next - 1]?.focus();
+		}
+	}
+
+	// The number of filled stars to display, taking the hovered star into
+	// account for the mouse preview
+	function getDisplayValue(): number {
+		return getDisabled() ? getValue() : Math.max(getValue(), $state.hover);
+	}
+
+	function handleClick(value: number) {
+		if (getDisabled()) return;
+		if (value === $state.value && ($props?.allowClear ?? true)) {
+			setValue(0);
+		} else {
+			setValue(value);
+		}
+		form.handleInput();
+	}
+
+	function handleKey(e: KeyboardEvent) {
+		if (getDisabled()) return;
+
+		switch (e.key) {
+			case "ArrowRight":
+			case "ArrowUp": {
+				e.preventDefault();
+				setValue(Math.max(1, $state.value + 1), true);
+				form.handleInput();
+				break;
+			}
+			case "ArrowLeft":
+			case "ArrowDown": {
+				e.preventDefault();
+				setValue($state.value <= 1 ? 1 : $state.value - 1, true);
+				form.handleInput();
+				break;
+			}
+			case "Home": {
+				e.preventDefault();
+				setValue(1, true);
+				form.handleInput();
+				break;
+			}
+			case "End": {
+				e.preventDefault();
+				setValue(getMax(), true);
+				form.handleInput();
+				break;
+			}
+		}
+	}
+
+	// Only blur when focus leaves the whole rating
+	function handleFocusOut(e: FocusEvent) {
+		if (!root.contains(e.relatedTarget as Node | null)) {
+			form.handleBlur();
+		}
+	}
+
+	// Roving tabindex: the star matching the current rating (or the first
+	// star when there is no rating) is the single tab stop
+	function tabStop(value: number): boolean {
+		return value === ($state.value > 0 ? $state.value : 1);
+	}
+
+	@render {
+		<div
+			{$props?.id}
+			class={["torp-rating", getDisabled() ? "torp-rating-disabled" : undefined, $props?.class]}
+			{$props?.style}
+			role="radiogroup"
+			aria-label={$props?.ariaLabel}
+			aria-disabled={getDisabled() ? "true" : undefined}
+			data-valid={form.valid ? "valid" : "invalid"}
+			aria-describedby={form.messageId}
+			aria-invalid={form.inField && !form.valid ? "true" : undefined}
+			onmouseleave={() => ($state.hover = 0)}
+			onfocusout={handleFocusOut}
+			&ref={root}
+		>
+			@for (let value of $state.stars) {
+				@key = value
+				<button
+					type="button"
+					class="torp-rating-star"
+					role="radio"
+					tabindex={tabStop(value) ? 0 : -1}
+					aria-checked={value === getValue() ? "true" : "false"}
+					aria-label={`${value} ${value === 1 ? "star" : "stars"}`}
+					aria-disabled={getDisabled() ? "true" : undefined}
+					data-state={value <= getDisplayValue() ? "filled" : "empty"}
+					onmount={(el) => {
+						stars[value - 1] = el;
+						return () => {
+							if (stars[value - 1] === el) {
+								stars[value - 1] = undefined;
+							}
+						};
+					}}
+					onclick={() => handleClick(value)}
+					onkeydown={handleKey}
+					onmouseenter={() => {
+						if (!getDisabled()) $state.hover = value;
+					}}
+				>
+					<slot item={{ value: value, filled: value <= getDisplayValue() }}>
+						<span aria-hidden="true">★</span>
+					</slot>
+				</button>
+			}
+		</div>
+
+		<FormValues name={form.name} value={getValue() > 0 ? getValue() : undefined} />
+	}
+
+	@style {
+		/* Headless: layout only, so the stars sit in a row. All appearance is
+		   up to the consuming theme */
+		.torp-rating {
+			display: inline-flex;
+		}
+	}
+}

package/dist/Rating/index.d.ts

@@ -0,0 +1,44 @@
+import { type SlotRender } from "@torpor/view";
+
+
+interface RatingProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Classes for the root element */
+	class?: ClassValue;
+	/** Styles for the root element */
+	style?: StyleValue;
+	/** The maximum rating, i.e. the number of stars (default 5) */
+	max?: number;
+	/** The current rating */
+	value?: Bindable<number>;
+	/** If set to true, the user cannot interact with this rating */
+	disabled?: boolean;
+	/** If set to false, clicking or re-selecting the current rating does not clear it (default true) */
+	allowClear?: boolean;
+	/** An accessible name for the rating */
+	ariaLabel?: string;
+	/** The name of the component's form data field */
+	name?: string;
+	/** Raised when the rating has changed */
+	onchange?: (value: number) => void;
+}
+
+/**
+ * A star rating input, where the user selects a value from 1 to a maximum
+ * number of stars by clicking or by using the keyboard.
+ *
+ * Implements the radio group pattern: each star is a radio button, the star
+ * matching the current rating is checked, and arrow keys move the rating.
+ *
+ * See [the WAI ARIA guidelines for Rating](https://www.w3.org/WAI/ARIA/apg/patterns/rating/).
+ */
+declare function Rating(
+	$parent: ParentNode,
+	$anchor: Node | null,
+	$props: RatingProps | undefined,
+	$context?: Record<PropertyKey, any>,
+	$slots?: Record<string, SlotRender>,
+): void;
+
+export { Rating };

package/dist/Rating/index.js

@@ -0,0 +1,2 @@
+import Rating from "./Rating.torp";
+export { Rating };

package/dist/SegmentedControl/SegmentedControl.torp

@@ -0,0 +1,233 @@
+import type { Bindable, ClassValue, StyleValue } from "@torpor/view";
+import $handle from "../utils/$handle";
+import {
+	type FieldContext,
+	FieldContextName,
+	type FormContext,
+	FormContextName,
+} from "../Form/FormTypes";
+import FormValues from "../Form/FormValues.torp";
+import { createFocusGroup } from "../utils/focusGroup";
+import { createItemGroup } from "../utils/createItemGroup";
+import createFormField from "../utils/formField";
+import type { FocusTarget } from "../utils/focusItem";
+import {
+	type ItemState,
+	type SegmentedControlContext,
+	SegmentedControlContextName,
+} from "./SegmentedControlTypes";
+
+interface SegmentedControlProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Classes for the root element */
+	class?: ClassValue;
+	/** Styles for the root element */
+	style?: StyleValue;
+	/** The value of the active segment */
+	value?: Bindable<string | undefined>;
+	/** If set to true, the user cannot interact with any segments */
+	disabled?: boolean;
+	/** An accessible name for the control */
+	ariaLabel?: string;
+	/** The name of the component's form data field */
+	name?: string;
+	/** Raised when the active segment has changed */
+	onchange?: (value: string) => void;
+}
+
+/**
+ * A compact group of segments, of which exactly one is active. The user moves
+ * between segments with the arrow keys, or selects one directly.
+ *
+ * See [the WAI ARIA guidelines for Radio Groups](https://www.w3.org/WAI/ARIA/apg/patterns/radiogroup/).
+ *
+ * The structure of a SegmentedControl is:
+ *
+ * ```
+ * <SegmentedControl ariaLabel="View">
+ * 	<SegmentedItem value="day">Day</SegmentedItem>
+ * 	<SegmentedItem value="week">Week</SegmentedItem>
+ * </SegmentedControl>
+ * ```
+ */
+export default function SegmentedControl($props: SegmentedControlProps | undefined) {
+	let nextItemIndex = 0;
+	let root: HTMLElement;
+
+	// Wire up the enclosing Form and Field, if any
+	const form = createFormField(
+		$props?.name,
+		$context[FormContextName] as FormContext | undefined,
+		$context[FieldContextName] as FieldContext | undefined,
+	);
+
+	let $state = $watch({
+		value: $props?.value ?? "",
+	});
+
+	$bind($state, $props, "value");
+
+	const group = createItemGroup<ItemState>({
+		state: $state,
+		type: "single",
+		selectedProperty: "active",
+		allowDeselect: false,
+		disabled: () => $props?.disabled,
+		// Select the first enabled item as items register, when nothing is
+		// selected yet; this is a default, not a user change, so it doesn't
+		// raise onchange
+		onRegister: (item) => {
+			if ($state.value === "" && !item.disabled) {
+				skipNextChange = true;
+				$state.value = item.value;
+			}
+		},
+	});
+
+	// The focus group owns the roving-tabindex bookkeeping; the selection
+	// group above stays the source of truth for the active segment
+	const focusGroup = createFocusGroup<ItemState>();
+
+	// Set the context to pass down to items
+	const context: SegmentedControlContext = {
+		registerItem,
+		removeItem: (itemIndex) => {
+			group.removeItem(itemIndex);
+			focusGroup.removeItem(itemIndex);
+		},
+		triggerItem: (value) => {
+			group.toggleItem(value);
+			form.handleInput();
+		},
+		handleItemKey,
+	};
+	$context[SegmentedControlContextName] = context;
+
+	// Dispatch the change event when the value changes
+	let skipNextChange = false;
+	$handle((first) => {
+		const value = $state.value;
+		if (skipNextChange) {
+			skipNextChange = false;
+			return;
+		}
+		if (!first && value !== "") $props?.onchange?.(value);
+	});
+
+	function registerItem(
+		index: number | undefined,
+		value: string | undefined,
+		disabled: boolean | undefined,
+	): ItemState {
+		// If an index wasn't set for the item, set it automatically
+		if (index === undefined) {
+			index = nextItemIndex++;
+		}
+
+		// If we already have an item with this index, just return it
+		const existing = group.itemStates.find((item) => item.index === index);
+		if (existing) {
+			return existing;
+		}
+
+		// If a value wasn't set for the item, set it to the index
+		if (value === undefined) {
+			value = index.toString();
+		}
+
+		const itemState: ItemState = $watch({
+			index,
+			value,
+			active: false,
+			disabled: disabled ?? false,
+			parentDisabled: $props?.disabled ?? false,
+			setFocused: () => {},
+		});
+		group.registerItem(itemState);
+		focusGroup.registerItem(itemState);
+
+		return itemState;
+	}
+
+	function handleItemKey(index: number, e: KeyboardEvent) {
+		switch (e.key) {
+			case "ArrowRight":
+			case "ArrowDown": {
+				e.preventDefault();
+				move(index, "next");
+				break;
+			}
+			case "ArrowLeft":
+			case "ArrowUp": {
+				e.preventDefault();
+				move(index, "previous");
+				break;
+			}
+			case "Home": {
+				e.preventDefault();
+				move(index, "start");
+				break;
+			}
+			case "End": {
+				e.preventDefault();
+				move(index, "end");
+				break;
+			}
+		}
+	}
+
+	// Moving with the keyboard both selects and focuses the target segment,
+	// like a radio group
+	function move(index: number, target: FocusTarget) {
+		const before = focusGroup.getFocusIndex();
+		focusGroup.moveFocus(index, target);
+		const next = focusGroup.getFocusIndex();
+		if (next !== before) {
+			const item = focusGroup.itemStates[next];
+			if (item) {
+				group.toggleItem(item.value);
+				form.handleInput();
+			}
+		}
+	}
+
+	// Only blur when focus leaves the whole control
+	function handleFocusOut(e: FocusEvent) {
+		if (!root.contains(e.relatedTarget as Node | null)) {
+			form.handleBlur();
+		}
+	}
+
+	@render {
+		<div
+			{$props?.id}
+			class={[
+				"torp-segmented-control",
+				$props?.disabled ? "torp-segmented-control-disabled" : undefined,
+				$props?.class,
+			]}
+			{$props?.style}
+			role="radiogroup"
+			aria-label={$props?.ariaLabel}
+			aria-disabled={$props?.disabled ? "true" : undefined}
+			data-valid={form.valid ? "valid" : "invalid"}
+			aria-describedby={form.messageId}
+			aria-invalid={form.inField && !form.valid ? "true" : undefined}
+			onfocusout={handleFocusOut}
+			&ref={root}
+		>
+			<slot />
+		</div>
+
+		<FormValues name={form.name} value={$state.value} />
+	}
+
+	@style {
+		/* Headless: layout only, so the segments sit in a row. All appearance
+		   is up to the consuming theme */
+		.torp-segmented-control {
+			display: inline-flex;
+		}
+	}
+}

package/dist/SegmentedControl/SegmentedControlTypes.ts

@@ -0,0 +1,26 @@
+export const SegmentedControlContextName: unique symbol = Symbol.for("torp.SegmentedControl");
+
+export interface SegmentedControlContext {
+	/** Called from an item when it is added */
+	registerItem: (
+		index: number | undefined,
+		value: string | undefined,
+		disabled: boolean | undefined,
+	) => ItemState;
+	/** Called from an item when it is removed */
+	removeItem: (index: number) => void;
+	/** Called from an item when it is selected */
+	triggerItem: (value: string) => void;
+	/** Called from an item when it receives a keyboard event */
+	handleItemKey: (index: number, e: KeyboardEvent) => void;
+}
+
+export interface ItemState {
+	index: number;
+	value: string;
+	active: boolean;
+	disabled: boolean;
+	parentDisabled: boolean;
+	/** Called in the SegmentedControl when an item needs to be focused */
+	setFocused: () => void;
+}