@wirekyt/dom 0.0.1 → 0.0.2

package/dist/machines/steps/index.js

@@ -0,0 +1,325 @@
+import { t as createAnatomy } from "../../create-anatomy-B2q3wiaw.js";
+import { z as dataAttr } from "../../dom-query-e7fh0TEH.js";
+import { c as fromLength } from "../../array-C4KbHsha.js";
+import { E as isValueWithinRange, n as createSplitProps } from "../../utils-Cht5XaHf.js";
+import { p as memo, r as createMachine } from "../../core-CJ0MZr3D.js";
+import { t as createProps } from "../../create-props-CgtcN_Qu.js";
+//#region src/machines/steps/anatomy.ts
+const anatomy = createAnatomy("steps").parts("root", "list", "item", "trigger", "indicator", "separator", "content", "nextTrigger", "prevTrigger", "progress");
+const parts = anatomy.build();
+//#endregion
+//#region src/machines/steps/dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `steps:${ctx.id}`;
+const getListId = (ctx) => ctx.ids?.list ?? `steps:${ctx.id}:list`;
+const getTriggerId = (ctx, index) => ctx.ids?.triggerId?.(index) ?? `steps:${ctx.id}:trigger:${index}`;
+const getContentId = (ctx, index) => ctx.ids?.contentId?.(index) ?? `steps:${ctx.id}:content:${index}`;
+//#endregion
+//#region src/machines/steps/connect.ts
+function connect(service, normalize) {
+	const { context, send, computed, prop, scope } = service;
+	const step = context.get("step");
+	const count = prop("count");
+	const percent = computed("percent");
+	const hasNextStep = computed("hasNextStep");
+	const hasPrevStep = computed("hasPrevStep");
+	const isStepValid = (index) => {
+		return prop("isStepValid")?.(index) ?? true;
+	};
+	const isStepSkippable = (index) => {
+		return prop("isStepSkippable")?.(index) ?? false;
+	};
+	const getItemState = (props) => ({
+		triggerId: getTriggerId(scope, props.index),
+		contentId: getContentId(scope, props.index),
+		current: props.index === step,
+		completed: props.index < step,
+		incomplete: props.index > step,
+		index: props.index,
+		first: props.index === 0,
+		last: props.index === count - 1,
+		skippable: isStepSkippable(props.index),
+		isValid: () => isStepValid(props.index)
+	});
+	const goToNextStep = () => {
+		send({
+			type: "STEP.NEXT",
+			src: "next.trigger.click"
+		});
+	};
+	const goToPrevStep = () => {
+		send({
+			type: "STEP.PREV",
+			src: "prev.trigger.click"
+		});
+	};
+	const resetStep = () => {
+		send({
+			type: "STEP.RESET",
+			src: "reset.trigger.click"
+		});
+	};
+	const setStep = (value) => {
+		send({
+			type: "STEP.SET",
+			value,
+			src: "api.setValue"
+		});
+	};
+	return {
+		value: step,
+		count,
+		percent,
+		hasNextStep,
+		hasPrevStep,
+		isCompleted: computed("completed"),
+		isStepValid,
+		isStepSkippable,
+		goToNextStep,
+		goToPrevStep,
+		resetStep,
+		getItemState,
+		setStep,
+		getRootProps() {
+			return normalize.element({
+				...parts.root.attrs,
+				id: getRootId(scope),
+				dir: prop("dir"),
+				"data-orientation": prop("orientation"),
+				style: { "--percent": `${percent}%` }
+			});
+		},
+		getListProps() {
+			const triggerIds = fromLength(count).map((_, index) => getTriggerId(scope, index));
+			return normalize.element({
+				...parts.list.attrs,
+				dir: prop("dir"),
+				id: getListId(scope),
+				role: "tablist",
+				"aria-owns": triggerIds.join(" "),
+				"aria-orientation": prop("orientation"),
+				"data-orientation": prop("orientation")
+			});
+		},
+		getItemProps(props) {
+			const itemState = getItemState(props);
+			return normalize.element({
+				...parts.item.attrs,
+				dir: prop("dir"),
+				"aria-current": itemState.current ? "step" : void 0,
+				"data-orientation": prop("orientation"),
+				"data-skippable": dataAttr(itemState.skippable)
+			});
+		},
+		getTriggerProps(props) {
+			const itemState = getItemState(props);
+			return normalize.button({
+				...parts.trigger.attrs,
+				id: itemState.triggerId,
+				role: "tab",
+				dir: prop("dir"),
+				tabIndex: !prop("linear") || itemState.current ? 0 : -1,
+				"aria-selected": itemState.current,
+				"aria-controls": itemState.contentId,
+				"data-state": itemState.current ? "open" : "closed",
+				"data-orientation": prop("orientation"),
+				"data-complete": dataAttr(itemState.completed),
+				"data-current": dataAttr(itemState.current),
+				"data-incomplete": dataAttr(itemState.incomplete),
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					if (prop("linear")) return;
+					send({
+						type: "STEP.SET",
+						value: props.index,
+						src: "trigger.click"
+					});
+				}
+			});
+		},
+		getContentProps(props) {
+			const itemState = getItemState(props);
+			return normalize.element({
+				...parts.content.attrs,
+				dir: prop("dir"),
+				id: itemState.contentId,
+				role: "tabpanel",
+				tabIndex: 0,
+				hidden: !itemState.current,
+				"data-state": itemState.current ? "open" : "closed",
+				"data-orientation": prop("orientation"),
+				"aria-labelledby": itemState.triggerId
+			});
+		},
+		getIndicatorProps(props) {
+			const itemState = getItemState(props);
+			return normalize.element({
+				...parts.indicator.attrs,
+				dir: prop("dir"),
+				"aria-hidden": true,
+				"data-complete": dataAttr(itemState.completed),
+				"data-current": dataAttr(itemState.current),
+				"data-incomplete": dataAttr(itemState.incomplete)
+			});
+		},
+		getSeparatorProps(props) {
+			const itemState = getItemState(props);
+			return normalize.element({
+				...parts.separator.attrs,
+				dir: prop("dir"),
+				"data-orientation": prop("orientation"),
+				"data-complete": dataAttr(itemState.completed),
+				"data-current": dataAttr(itemState.current),
+				"data-incomplete": dataAttr(itemState.incomplete)
+			});
+		},
+		getNextTriggerProps() {
+			return normalize.button({
+				...parts.nextTrigger.attrs,
+				dir: prop("dir"),
+				type: "button",
+				disabled: !hasNextStep,
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					goToNextStep();
+				}
+			});
+		},
+		getPrevTriggerProps() {
+			return normalize.button({
+				dir: prop("dir"),
+				...parts.prevTrigger.attrs,
+				type: "button",
+				disabled: !hasPrevStep,
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					goToPrevStep();
+				}
+			});
+		},
+		getProgressProps() {
+			return normalize.element({
+				dir: prop("dir"),
+				...parts.progress.attrs,
+				role: "progressbar",
+				"aria-valuenow": percent,
+				"aria-valuemin": 0,
+				"aria-valuemax": 100,
+				"aria-valuetext": `${percent}% complete`,
+				"data-complete": dataAttr(percent === 100)
+			});
+		}
+	};
+}
+//#endregion
+//#region src/machines/steps/machine.ts
+const machine = createMachine({
+	props({ props }) {
+		return {
+			defaultStep: 0,
+			count: 1,
+			linear: false,
+			orientation: "horizontal",
+			...props
+		};
+	},
+	context({ prop, bindable }) {
+		return { step: bindable(() => ({
+			defaultValue: prop("defaultStep"),
+			value: prop("step"),
+			onChange(value) {
+				prop("onStepChange")?.({ step: value });
+				if (value == prop("count")) prop("onStepComplete")?.();
+			}
+		})) };
+	},
+	computed: {
+		percent: memo(({ context, prop }) => [context.get("step"), prop("count")], ([step, count]) => step / count * 100),
+		hasNextStep: ({ context, prop }) => context.get("step") < prop("count"),
+		hasPrevStep: ({ context }) => context.get("step") > 0,
+		completed: ({ context, prop }) => context.get("step") === prop("count")
+	},
+	initialState() {
+		return "idle";
+	},
+	entry: ["validateStepIndex"],
+	states: { idle: { on: {
+		"STEP.SET": [{
+			guard: "isValidStepNavigation",
+			actions: ["setStep"]
+		}, { actions: ["invokeOnStepInvalid"] }],
+		"STEP.NEXT": [{
+			guard: "isCurrentStepValid",
+			actions: ["goToNextStep"]
+		}, { actions: ["invokeOnStepInvalid"] }],
+		"STEP.PREV": { actions: ["goToPrevStep"] },
+		"STEP.RESET": { actions: ["resetStep"] }
+	} } },
+	implementations: {
+		guards: {
+			isCurrentStepValid({ context, prop }) {
+				const current = context.get("step");
+				if (prop("isStepSkippable")?.(current)) return true;
+				const isStepValid = prop("isStepValid");
+				if (!isStepValid) return true;
+				return isStepValid(current);
+			},
+			isValidStepNavigation({ context, event, prop }) {
+				const current = context.get("step");
+				if (event.value <= current) return true;
+				if (prop("isStepSkippable")?.(current)) return true;
+				const isStepValid = prop("isStepValid");
+				if (!isStepValid) return true;
+				return isStepValid(current);
+			}
+		},
+		actions: {
+			goToNextStep({ context, prop }) {
+				const count = prop("count");
+				context.set("step", Math.min(context.get("step") + 1, count));
+			},
+			goToPrevStep({ context }) {
+				context.set("step", Math.max(context.get("step") - 1, 0));
+			},
+			resetStep({ context }) {
+				context.set("step", 0);
+			},
+			setStep({ context, event }) {
+				context.set("step", event.value);
+			},
+			validateStepIndex({ context, prop }) {
+				validateStepIndex(prop("count"), context.get("step"));
+			},
+			invokeOnStepInvalid({ context, event, prop }) {
+				prop("onStepInvalid")?.({
+					step: context.get("step"),
+					action: event.type === "STEP.NEXT" ? "next" : "set",
+					targetStep: event.value
+				});
+			}
+		}
+	}
+});
+const validateStepIndex = (count, step) => {
+	if (!isValueWithinRange(step, 0, count)) throw new RangeError(`[wirekyt/steps] step index ${step} is out of bounds`);
+};
+//#endregion
+//#region src/machines/steps/props.ts
+const props = createProps()([
+	"count",
+	"defaultStep",
+	"dir",
+	"getRootNode",
+	"id",
+	"ids",
+	"isStepSkippable",
+	"isStepValid",
+	"linear",
+	"onStepChange",
+	"onStepComplete",
+	"onStepInvalid",
+	"orientation",
+	"step"
+]);
+const splitProps = createSplitProps(props);
+//#endregion
+export { anatomy, connect, machine, props, splitProps };

package/dist/machines/switch/index.cjs

@@ -0,0 +1,307 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_create_anatomy = require("../../create-anatomy-BwDn25ph.cjs");
+const require_dom_query = require("../../dom-query-CQzY93XU.cjs");
+const require_platform = require("../../platform-BZS-dkZN.cjs");
+const require_event = require("../../event-DDz-mMhM.cjs");
+const require_form = require("../../form-CoupKpuP.cjs");
+const require_press = require("../../press-BdD5suLQ.cjs");
+const require_visually_hidden = require("../../visually-hidden-BgSCFLz_.cjs");
+const require_utils = require("../../utils-BH-oBBz2.cjs");
+const require_core = require("../../core-BNMw-JId.cjs");
+const require_focus_visible = require("../../focus-visible-G4cmlWqq.cjs");
+const require_create_props = require("../../create-props-CjLx2oS8.cjs");
+//#region src/machines/switch/anatomy.ts
+const anatomy = require_create_anatomy.createAnatomy("switch").parts("root", "label", "control", "thumb");
+const parts = anatomy.build();
+//#endregion
+//#region src/machines/switch/dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `switch:${ctx.id}`;
+const getLabelId = (ctx) => ctx.ids?.label ?? `switch:${ctx.id}:label`;
+const getThumbId = (ctx) => ctx.ids?.thumb ?? `switch:${ctx.id}:thumb`;
+const getControlId = (ctx) => ctx.ids?.control ?? `switch:${ctx.id}:control`;
+const getHiddenInputId = (ctx) => ctx.ids?.hiddenInput ?? `switch:${ctx.id}:input`;
+const getRootEl = (ctx) => ctx.getById(getRootId(ctx));
+const getHiddenInputEl = (ctx) => ctx.getById(getHiddenInputId(ctx));
+//#endregion
+//#region src/machines/switch/connect.ts
+function connect(service, normalize) {
+	const { context, send, prop, scope } = service;
+	const disabled = !!prop("disabled");
+	const readOnly = !!prop("readOnly");
+	const required = !!prop("required");
+	const checked = !!context.get("checked");
+	const focused = !disabled && context.get("focused");
+	const focusVisible = !disabled && context.get("focusVisible");
+	const dataAttrs = {
+		"data-active": require_dom_query.dataAttr(!disabled && context.get("active")),
+		"data-focus": require_dom_query.dataAttr(focused),
+		"data-focus-visible": require_dom_query.dataAttr(focusVisible),
+		"data-readonly": require_dom_query.dataAttr(readOnly),
+		"data-hover": require_dom_query.dataAttr(context.get("hovered")),
+		"data-disabled": require_dom_query.dataAttr(disabled),
+		"data-state": checked ? "checked" : "unchecked",
+		"data-invalid": require_dom_query.dataAttr(prop("invalid")),
+		"data-required": require_dom_query.dataAttr(required)
+	};
+	return {
+		checked,
+		disabled,
+		focused,
+		setChecked(checked) {
+			send({
+				type: "CHECKED.SET",
+				checked,
+				isTrusted: false
+			});
+		},
+		toggleChecked() {
+			send({
+				type: "CHECKED.TOGGLE",
+				checked,
+				isTrusted: false
+			});
+		},
+		getRootProps() {
+			return normalize.label({
+				...parts.root.attrs,
+				...dataAttrs,
+				dir: prop("dir"),
+				id: getRootId(scope),
+				htmlFor: getHiddenInputId(scope),
+				onPointerMove() {
+					if (disabled) return;
+					send({
+						type: "CONTEXT.SET",
+						context: { hovered: true }
+					});
+				},
+				onPointerLeave() {
+					if (disabled) return;
+					send({
+						type: "CONTEXT.SET",
+						context: { hovered: false }
+					});
+				},
+				onClick(event) {
+					if (disabled) return;
+					if (require_event.getEventTarget(event) === getHiddenInputEl(scope)) event.stopPropagation();
+					if (require_platform.isSafari()) getHiddenInputEl(scope)?.focus();
+				}
+			});
+		},
+		getLabelProps() {
+			return normalize.element({
+				...parts.label.attrs,
+				...dataAttrs,
+				dir: prop("dir"),
+				id: getLabelId(scope)
+			});
+		},
+		getThumbProps() {
+			return normalize.element({
+				...parts.thumb.attrs,
+				...dataAttrs,
+				dir: prop("dir"),
+				id: getThumbId(scope),
+				"aria-hidden": true
+			});
+		},
+		getControlProps() {
+			return normalize.element({
+				...parts.control.attrs,
+				...dataAttrs,
+				dir: prop("dir"),
+				id: getControlId(scope),
+				"aria-hidden": true
+			});
+		},
+		getHiddenInputProps() {
+			return normalize.input({
+				id: getHiddenInputId(scope),
+				type: "checkbox",
+				required: prop("required"),
+				defaultChecked: checked,
+				disabled,
+				"aria-labelledby": getLabelId(scope),
+				"aria-invalid": prop("invalid"),
+				name: prop("name"),
+				form: prop("form"),
+				value: prop("value"),
+				style: require_visually_hidden.visuallyHiddenStyle,
+				onFocus() {
+					const focusVisible = require_focus_visible.isFocusVisible();
+					send({
+						type: "CONTEXT.SET",
+						context: {
+							focused: true,
+							focusVisible
+						}
+					});
+				},
+				onBlur() {
+					send({
+						type: "CONTEXT.SET",
+						context: {
+							focused: false,
+							focusVisible: false
+						}
+					});
+				},
+				onClick(event) {
+					if (readOnly) {
+						event.preventDefault();
+						return;
+					}
+					const checked = event.currentTarget.checked;
+					send({
+						type: "CHECKED.SET",
+						checked,
+						isTrusted: true
+					});
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region src/machines/switch/machine.ts
+const { not } = require_core.createGuards();
+const machine = require_core.createMachine({
+	props({ props }) {
+		return {
+			defaultChecked: false,
+			label: "switch",
+			value: "on",
+			...props
+		};
+	},
+	initialState() {
+		return "ready";
+	},
+	context({ prop, bindable }) {
+		return {
+			checked: bindable(() => ({
+				defaultValue: prop("defaultChecked"),
+				value: prop("checked"),
+				onChange(value) {
+					prop("onCheckedChange")?.({ checked: value });
+				}
+			})),
+			fieldsetDisabled: bindable(() => ({ defaultValue: false })),
+			focusVisible: bindable(() => ({ defaultValue: false })),
+			active: bindable(() => ({ defaultValue: false })),
+			focused: bindable(() => ({ defaultValue: false })),
+			hovered: bindable(() => ({ defaultValue: false }))
+		};
+	},
+	computed: { isDisabled: ({ context, prop }) => prop("disabled") || context.get("fieldsetDisabled") },
+	watch({ track, prop, context, action }) {
+		track([() => prop("disabled")], () => {
+			action(["removeFocusIfNeeded"]);
+		});
+		track([() => context.get("checked")], () => {
+			action(["syncInputElement"]);
+		});
+	},
+	effects: [
+		"trackFormControlState",
+		"trackPressEvent",
+		"trackFocusVisible"
+	],
+	on: {
+		"CHECKED.TOGGLE": [{
+			guard: not("isTrusted"),
+			actions: ["toggleChecked", "dispatchChangeEvent"]
+		}, { actions: ["toggleChecked"] }],
+		"CHECKED.SET": [{
+			guard: not("isTrusted"),
+			actions: ["setChecked", "dispatchChangeEvent"]
+		}, { actions: ["setChecked"] }],
+		"CONTEXT.SET": { actions: ["setContext"] }
+	},
+	states: { ready: {} },
+	implementations: {
+		guards: { isTrusted: ({ event }) => !!event.isTrusted },
+		effects: {
+			trackPressEvent({ computed, scope, context }) {
+				if (computed("isDisabled")) return;
+				return require_press.trackPress({
+					pointerNode: getRootEl(scope),
+					keyboardNode: getHiddenInputEl(scope),
+					isValidKey: (event) => event.key === " ",
+					onPress: () => context.set("active", false),
+					onPressStart: () => context.set("active", true),
+					onPressEnd: () => context.set("active", false)
+				});
+			},
+			trackFocusVisible({ computed, scope }) {
+				if (computed("isDisabled")) return;
+				return require_focus_visible.trackFocusVisible({ root: scope.getRootNode() });
+			},
+			trackFormControlState({ context, send, scope }) {
+				return require_form.trackFormControl(getHiddenInputEl(scope), {
+					onFieldsetDisabledChange(disabled) {
+						context.set("fieldsetDisabled", disabled);
+					},
+					onFormReset() {
+						send({
+							type: "CHECKED.SET",
+							checked: !!context.initial("checked"),
+							src: "form-reset"
+						});
+					}
+				});
+			}
+		},
+		actions: {
+			setContext({ context, event }) {
+				for (const key in event.context) context.set(key, event.context[key]);
+			},
+			syncInputElement({ context, scope }) {
+				const inputEl = getHiddenInputEl(scope);
+				if (!inputEl) return;
+				require_form.setElementChecked(inputEl, !!context.get("checked"));
+			},
+			removeFocusIfNeeded({ context, prop }) {
+				if (prop("disabled")) context.set("focused", false);
+			},
+			setChecked({ context, event }) {
+				context.set("checked", event.checked);
+			},
+			toggleChecked({ context }) {
+				context.set("checked", !context.get("checked"));
+			},
+			dispatchChangeEvent({ context, scope }) {
+				queueMicrotask(() => {
+					require_form.dispatchInputCheckedEvent(getHiddenInputEl(scope), { checked: context.get("checked") });
+				});
+			}
+		}
+	}
+});
+//#endregion
+//#region src/machines/switch/props.ts
+const props = require_create_props.createProps()([
+	"checked",
+	"defaultChecked",
+	"dir",
+	"disabled",
+	"form",
+	"getRootNode",
+	"id",
+	"ids",
+	"invalid",
+	"label",
+	"name",
+	"onCheckedChange",
+	"readOnly",
+	"required",
+	"value"
+]);
+const splitProps = require_utils.createSplitProps(props);
+//#endregion
+exports.anatomy = anatomy;
+exports.connect = connect;
+exports.machine = machine;
+exports.props = props;
+exports.splitProps = splitProps;

package/dist/machines/switch/index.d.cts

@@ -0,0 +1,80 @@
+import { n as AnatomyInstance } from "../../anatomy-DMuSMbOP.cjs";
+import { M as Service, S as EventObject, T as Machine } from "../../index-BKgxIVbE.cjs";
+import { b as PropTypes, g as RequiredBy, r as DirectionProperty, t as CommonProperties, y as NormalizeProps } from "../../index-BXfunVyD.cjs";
+import "../../index-BF6G2RiC.cjs";
+//#region src/machines/switch/anatomy.d.ts
+declare const anatomy: AnatomyInstance<"root" | "thumb" | "label" | "control">;
+//#endregion
+//#region src/machines/switch/types.d.ts
+interface CheckedChangeDetails {
+  checked: boolean;
+}
+type ElementIds = Partial<{
+  root: string;
+  hiddenInput: string;
+  control: string;
+  label: string;
+  thumb: string;
+}>;
+interface SwitchProps extends DirectionProperty, CommonProperties {
+  ids?: ElementIds | undefined;
+  label?: string | undefined;
+  disabled?: boolean | undefined;
+  invalid?: boolean | undefined;
+  required?: boolean | undefined;
+  readOnly?: boolean | undefined;
+  onCheckedChange?: ((details: CheckedChangeDetails) => void) | undefined;
+  checked?: boolean | undefined;
+  defaultChecked?: boolean | undefined;
+  name?: string | undefined;
+  form?: string | undefined;
+  value?: string | number | undefined;
+}
+type PropsWithDefault = "value";
+type ComputedContext = Readonly<{
+  isDisabled: boolean;
+}>;
+interface PrivateContext {
+  active: boolean;
+  focused: boolean;
+  focusVisible: boolean;
+  hovered: boolean;
+  fieldsetDisabled: boolean;
+  checked: boolean;
+}
+interface SwitchSchema {
+  props: RequiredBy<SwitchProps, PropsWithDefault>;
+  context: PrivateContext;
+  state: "ready";
+  computed: ComputedContext;
+  event: EventObject;
+  action: string;
+  effect: string;
+  guard: string;
+}
+type SwitchService = Service<SwitchSchema>;
+type SwitchMachine = Machine<SwitchSchema>;
+interface SwitchApi<T extends PropTypes = PropTypes> {
+  checked: boolean;
+  disabled: boolean | undefined;
+  focused: boolean | undefined;
+  setChecked: (checked: boolean) => void;
+  toggleChecked: VoidFunction;
+  getRootProps: () => T["label"];
+  getLabelProps: () => T["element"];
+  getThumbProps: () => T["element"];
+  getControlProps: () => T["element"];
+  getHiddenInputProps: () => T["input"];
+}
+//#endregion
+//#region src/machines/switch/connect.d.ts
+declare function connect<T extends PropTypes>(service: SwitchService, normalize: NormalizeProps<T>): SwitchApi<T>;
+//#endregion
+//#region src/machines/switch/machine.d.ts
+declare const machine: Machine<SwitchSchema>;
+//#endregion
+//#region src/machines/switch/props.d.ts
+declare const props: (keyof SwitchProps)[];
+declare const splitProps: <Props extends Partial<SwitchProps>>(props: Props) => [Partial<SwitchProps>, Omit<Props, keyof SwitchProps>];
+//#endregion
+export { type SwitchApi as Api, type CheckedChangeDetails, type ElementIds, type SwitchMachine as Machine, type SwitchProps as Props, type SwitchService as Service, anatomy, connect, machine, props, splitProps };