@wirekyt/dom 0.0.1 → 0.0.2

package/dist/machines/tabs/index.d.ts

@@ -0,0 +1,113 @@
+import { n as AnatomyInstance } from "../../anatomy-DMuSMbOP.js";
+import { M as Service, S as EventObject, T as Machine } from "../../index-CFoN0L3C.js";
+import { b as PropTypes, g as RequiredBy, m as Rect, r as DirectionProperty, t as CommonProperties, y as NormalizeProps } from "../../index-BXfunVyD.js";
+import "../../index-BdeZuSX6.js";
+//#region src/machines/tabs/anatomy.d.ts
+declare const anatomy: AnatomyInstance<"root" | "list" | "trigger" | "content" | "indicator">;
+//#endregion
+//#region src/machines/tabs/types.d.ts
+interface ValueChangeDetails {
+  value: string;
+}
+interface FocusChangeDetails {
+  focusedValue: string;
+}
+interface NavigateDetails {
+  value: string;
+  node: HTMLAnchorElement;
+  href: string;
+}
+interface IntlTranslations {
+  listLabel?: string | undefined;
+}
+type ElementIds = Partial<{
+  root: string;
+  trigger: (value: string) => string;
+  list: string;
+  content: (value: string) => string;
+  indicator: string;
+}>;
+interface TabsProps extends DirectionProperty, CommonProperties {
+  ids?: ElementIds | undefined;
+  translations?: IntlTranslations | undefined;
+  loopFocus?: boolean | undefined;
+  value?: string | null | undefined;
+  defaultValue?: string | null | undefined;
+  orientation?: "horizontal" | "vertical" | undefined;
+  activationMode?: "manual" | "automatic" | undefined;
+  onValueChange?: ((details: ValueChangeDetails) => void) | undefined;
+  onFocusChange?: ((details: FocusChangeDetails) => void) | undefined;
+  composite?: boolean | undefined;
+  deselectable?: boolean | undefined;
+  navigate?: ((details: NavigateDetails) => void) | null | undefined;
+}
+type PropsWithDefault = "orientation" | "activationMode" | "loopFocus";
+type TabsSchema = {
+  state: "idle" | "focused";
+  props: RequiredBy<TabsProps, PropsWithDefault>;
+  context: {
+    ssr: boolean;
+    value: string | null;
+    focusedValue: string | null;
+    indicatorRect: Rect | null;
+    animateIndicator: boolean;
+  };
+  refs: {
+    indicatorCleanup: VoidFunction | null | undefined;
+    prevValue: string | null;
+  };
+  computed: {
+    focused: boolean;
+  };
+  action: string;
+  guard: string;
+  effect: string;
+  event: EventObject;
+};
+type TabsService = Service<TabsSchema>;
+type TabsMachine = Machine<TabsSchema>;
+interface TriggerProps {
+  value: string;
+  disabled?: boolean | undefined;
+}
+interface TriggerState {
+  selected: boolean;
+  focused: boolean;
+  disabled: boolean;
+}
+interface ContentProps {
+  value: string;
+}
+interface TabsApi<T extends PropTypes = PropTypes> {
+  value: string | null;
+  focusedValue: string | null;
+  setValue: (value: string) => void;
+  clearValue: VoidFunction;
+  setIndicatorRect: (value: string) => void;
+  syncTabIndex: VoidFunction;
+  focus: VoidFunction;
+  selectNext: (fromValue?: string) => void;
+  selectPrev: (fromValue?: string) => void;
+  getTriggerState: (props: TriggerProps) => TriggerState;
+  getRootProps: () => T["element"];
+  getListProps: () => T["element"];
+  getTriggerProps: (props: TriggerProps) => T["button"];
+  getContentProps: (props: ContentProps) => T["element"];
+  getIndicatorProps: () => T["element"];
+}
+//#endregion
+//#region src/machines/tabs/connect.d.ts
+declare function connect<T extends PropTypes>(service: Service<TabsSchema>, normalize: NormalizeProps<T>): TabsApi<T>;
+//#endregion
+//#region src/machines/tabs/machine.d.ts
+declare const machine: Machine<TabsSchema>;
+//#endregion
+//#region src/machines/tabs/props.d.ts
+declare const props: (keyof TabsProps)[];
+declare const splitProps: <Props extends Partial<TabsProps>>(props: Props) => [Partial<TabsProps>, Omit<Props, keyof TabsProps>];
+declare const triggerProps: (keyof TriggerProps)[];
+declare const splitTriggerProps: <Props extends TriggerProps>(props: Props) => [TriggerProps, Omit<Props, keyof TriggerProps>];
+declare const contentProps: "value"[];
+declare const splitContentProps: <Props extends ContentProps>(props: Props) => [ContentProps, Omit<Props, "value">];
+//#endregion
+export { type TabsApi as Api, type ContentProps, type ElementIds, type FocusChangeDetails, type IntlTranslations, type TabsMachine as Machine, type NavigateDetails, type TabsProps as Props, type TabsService as Service, type TriggerProps, type TriggerState, type ValueChangeDetails, anatomy, connect, contentProps, machine, props, splitContentProps, splitProps, splitTriggerProps, triggerProps };

package/dist/machines/tabs/index.js

@@ -0,0 +1,533 @@
+import { t as createAnatomy } from "../../create-anatomy-B2q3wiaw.js";
+import { c as itemById, f as queryAll, l as nextById, p as contains, r as resizeObserverBorderBox, u as prevById, w as isAnchorElement, z as dataAttr } from "../../dom-query-e7fh0TEH.js";
+import { f as isSafari } from "../../platform-BDB0wXUk.js";
+import { g as isOpeningInNewTab, l as isComposingEvent, r as getEventKey, s as getEventTarget } from "../../event-bTItRgiw.js";
+import { r as getFocusables } from "../../tabbable-CDA1YMjZ.js";
+import { i as raf } from "../../raf-Dhvm7f1e.js";
+import { t as clickIfLink } from "../../navigate-CJOaL3vx.js";
+import { f as last, o as first } from "../../array-C4KbHsha.js";
+import { t as isEqual } from "../../equal-DtrP8DPh.js";
+import { F as toPx, L as callAll, n as createSplitProps } from "../../utils-Cht5XaHf.js";
+import { i as setup } from "../../core-CJ0MZr3D.js";
+import { t as createProps } from "../../create-props-CgtcN_Qu.js";
+//#region src/machines/tabs/anatomy.ts
+const anatomy = createAnatomy("tabs").parts("root", "list", "trigger", "content", "indicator");
+const parts = anatomy.build();
+//#endregion
+//#region src/machines/tabs/dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `tabs:${ctx.id}`;
+const getListId = (ctx) => ctx.ids?.list ?? `tabs:${ctx.id}:list`;
+const getContentId = (ctx, value) => ctx.ids?.content?.(value) ?? `tabs:${ctx.id}:content-${value}`;
+const getTriggerId = (ctx, value) => ctx.ids?.trigger?.(value) ?? `tabs:${ctx.id}:trigger-${value}`;
+const getIndicatorId = (ctx) => ctx.ids?.indicator ?? `tabs:${ctx.id}:indicator`;
+const getListEl = (ctx) => ctx.getById(getListId(ctx));
+const getContentEl = (ctx, value) => ctx.getById(getContentId(ctx, value));
+const getTriggerEl = (ctx, value) => value != null ? ctx.getById(getTriggerId(ctx, value)) : null;
+const getIndicatorEl = (ctx) => ctx.getById(getIndicatorId(ctx));
+const getElements = (ctx) => {
+	const selector = `[role=tab][data-ownedby='${CSS.escape(getListId(ctx))}']:not([disabled])`;
+	return queryAll(getListEl(ctx), selector);
+};
+const getFirstTriggerEl = (ctx) => first(getElements(ctx));
+const getLastTriggerEl = (ctx) => last(getElements(ctx));
+const getNextTriggerEl = (ctx, opts) => nextById(getElements(ctx), getTriggerId(ctx, opts.value), opts.loopFocus);
+const getPrevTriggerEl = (ctx, opts) => prevById(getElements(ctx), getTriggerId(ctx, opts.value), opts.loopFocus);
+const getOffsetRect = (el) => ({
+	x: el?.offsetLeft ?? 0,
+	y: el?.offsetTop ?? 0,
+	width: el?.offsetWidth ?? 0,
+	height: el?.offsetHeight ?? 0
+});
+const getRectByValue = (ctx, value) => {
+	const tab = itemById(getElements(ctx), getTriggerId(ctx, value));
+	return getOffsetRect(tab);
+};
+//#endregion
+//#region src/machines/tabs/connect.ts
+function connect(service, normalize) {
+	const { state, send, context, prop, scope } = service;
+	const translations = prop("translations");
+	const focused = state.matches("focused");
+	const isVertical = prop("orientation") === "vertical";
+	const isHorizontal = prop("orientation") === "horizontal";
+	const composite = prop("composite");
+	function getTriggerState(props) {
+		return {
+			selected: context.get("value") === props.value,
+			focused: context.get("focusedValue") === props.value,
+			disabled: !!props.disabled
+		};
+	}
+	return {
+		value: context.get("value"),
+		focusedValue: context.get("focusedValue"),
+		setValue(value) {
+			send({
+				type: "SET_VALUE",
+				value
+			});
+		},
+		clearValue() {
+			send({ type: "CLEAR_VALUE" });
+		},
+		setIndicatorRect(value) {
+			const id = getTriggerId(scope, value);
+			send({
+				type: "SET_INDICATOR_RECT",
+				id
+			});
+		},
+		syncTabIndex() {
+			send({ type: "SYNC_TAB_INDEX" });
+		},
+		selectNext(fromValue) {
+			send({
+				type: "TAB_FOCUS",
+				value: fromValue,
+				src: "selectNext"
+			});
+			send({
+				type: "ARROW_NEXT",
+				src: "selectNext"
+			});
+		},
+		selectPrev(fromValue) {
+			send({
+				type: "TAB_FOCUS",
+				value: fromValue,
+				src: "selectPrev"
+			});
+			send({
+				type: "ARROW_PREV",
+				src: "selectPrev"
+			});
+		},
+		focus() {
+			const value = context.get("value");
+			if (!value) return;
+			getTriggerEl(scope, value)?.focus();
+		},
+		getRootProps() {
+			return normalize.element({
+				...parts.root.attrs,
+				id: getRootId(scope),
+				"data-orientation": prop("orientation"),
+				"data-focus": dataAttr(focused),
+				dir: prop("dir")
+			});
+		},
+		getListProps() {
+			return normalize.element({
+				...parts.list.attrs,
+				id: getListId(scope),
+				role: "tablist",
+				dir: prop("dir"),
+				"data-focus": dataAttr(focused),
+				"aria-orientation": prop("orientation"),
+				"data-orientation": prop("orientation"),
+				"aria-label": translations?.listLabel,
+				onKeyDown(event) {
+					if (event.defaultPrevented) return;
+					if (isComposingEvent(event)) return;
+					if (!contains(event.currentTarget, getEventTarget(event))) return;
+					const exec = {
+						ArrowDown() {
+							if (isHorizontal) return;
+							send({
+								type: "ARROW_NEXT",
+								key: "ArrowDown"
+							});
+						},
+						ArrowUp() {
+							if (isHorizontal) return;
+							send({
+								type: "ARROW_PREV",
+								key: "ArrowUp"
+							});
+						},
+						ArrowLeft() {
+							if (isVertical) return;
+							send({
+								type: "ARROW_PREV",
+								key: "ArrowLeft"
+							});
+						},
+						ArrowRight() {
+							if (isVertical) return;
+							send({
+								type: "ARROW_NEXT",
+								key: "ArrowRight"
+							});
+						},
+						Home() {
+							send({ type: "HOME" });
+						},
+						End() {
+							send({ type: "END" });
+						}
+					}[getEventKey(event, {
+						dir: prop("dir"),
+						orientation: prop("orientation")
+					})];
+					if (exec) {
+						event.preventDefault();
+						exec(event);
+						return;
+					}
+				}
+			});
+		},
+		getTriggerState,
+		getTriggerProps(props) {
+			const { value, disabled } = props;
+			const triggerState = getTriggerState(props);
+			return normalize.button({
+				...parts.trigger.attrs,
+				role: "tab",
+				type: "button",
+				disabled,
+				dir: prop("dir"),
+				"data-orientation": prop("orientation"),
+				"data-disabled": dataAttr(disabled),
+				"aria-disabled": disabled,
+				"data-value": value,
+				"aria-selected": triggerState.selected,
+				"data-selected": dataAttr(triggerState.selected),
+				"data-focus": dataAttr(triggerState.focused),
+				"aria-controls": triggerState.selected ? getContentId(scope, value) : void 0,
+				"data-ownedby": getListId(scope),
+				"data-ssr": dataAttr(context.get("ssr")),
+				id: getTriggerId(scope, value),
+				tabIndex: triggerState.selected && composite ? 0 : -1,
+				onFocus() {
+					send({
+						type: "TAB_FOCUS",
+						value
+					});
+				},
+				onBlur(event) {
+					if (event.relatedTarget?.getAttribute("role") !== "tab") send({ type: "TAB_BLUR" });
+				},
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					if (isOpeningInNewTab(event)) return;
+					if (disabled) return;
+					if (isSafari()) event.currentTarget.focus();
+					send({
+						type: "TAB_CLICK",
+						value
+					});
+				}
+			});
+		},
+		getContentProps(props) {
+			const { value } = props;
+			const selected = context.get("value") === value;
+			return normalize.element({
+				...parts.content.attrs,
+				dir: prop("dir"),
+				id: getContentId(scope, value),
+				tabIndex: composite ? 0 : -1,
+				"aria-labelledby": getTriggerId(scope, value),
+				role: "tabpanel",
+				"data-ownedby": getListId(scope),
+				"data-selected": dataAttr(selected),
+				"data-orientation": prop("orientation"),
+				hidden: !selected
+			});
+		},
+		getIndicatorProps() {
+			const rect = context.get("indicatorRect");
+			const animateIndicator = context.get("animateIndicator");
+			return normalize.element({
+				id: getIndicatorId(scope),
+				...parts.indicator.attrs,
+				dir: prop("dir"),
+				"data-orientation": prop("orientation"),
+				hidden: isRectEmpty(rect),
+				onTransitionEnd(event) {
+					if (getEventTarget(event) !== event.currentTarget) return;
+					send({ type: "INDICATOR_TRANSITION_END" });
+				},
+				style: {
+					"--transition-property": "left, right, top, bottom, width, height",
+					"--left": toPx(rect?.x),
+					"--top": toPx(rect?.y),
+					"--width": toPx(rect?.width),
+					"--height": toPx(rect?.height),
+					position: "absolute",
+					willChange: animateIndicator ? "var(--transition-property)" : "auto",
+					transitionProperty: animateIndicator ? "var(--transition-property)" : "none",
+					transitionDuration: animateIndicator ? "var(--transition-duration, 150ms)" : "0ms",
+					transitionTimingFunction: "var(--transition-timing-function)",
+					[isHorizontal ? "left" : "top"]: isHorizontal ? "var(--left)" : "var(--top)"
+				}
+			});
+		}
+	};
+}
+const isRectEmpty = (rect) => rect == null || rect.width === 0 && rect.height === 0 && rect.x === 0 && rect.y === 0;
+//#endregion
+//#region src/machines/tabs/machine.ts
+const { createMachine } = setup();
+const machine = createMachine({
+	props({ props }) {
+		return {
+			dir: "ltr",
+			orientation: "horizontal",
+			activationMode: "automatic",
+			loopFocus: true,
+			composite: true,
+			navigate(details) {
+				clickIfLink(details.node);
+			},
+			defaultValue: null,
+			...props
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop, bindable }) {
+		return {
+			value: bindable(() => ({
+				defaultValue: prop("defaultValue"),
+				value: prop("value"),
+				onChange(value) {
+					prop("onValueChange")?.({ value });
+				}
+			})),
+			focusedValue: bindable(() => ({
+				defaultValue: prop("value") || prop("defaultValue"),
+				sync: true,
+				onChange(value) {
+					prop("onFocusChange")?.({ focusedValue: value });
+				}
+			})),
+			ssr: bindable(() => ({ defaultValue: true })),
+			indicatorRect: bindable(() => ({ defaultValue: null })),
+			animateIndicator: bindable(() => ({ defaultValue: false }))
+		};
+	},
+	refs() {
+		return {
+			indicatorCleanup: null,
+			prevValue: null
+		};
+	},
+	watch({ context, prop, track, action }) {
+		track([() => context.get("value")], () => {
+			action([
+				"syncIndicatorAnimation",
+				"syncIndicatorRect",
+				"syncTabIndex",
+				"navigateIfNeeded"
+			]);
+		});
+		track([() => prop("dir"), () => prop("orientation")], () => {
+			action(["syncIndicatorRect"]);
+		});
+	},
+	on: {
+		SET_VALUE: { actions: ["setValue"] },
+		CLEAR_VALUE: { actions: ["clearValue"] },
+		SET_INDICATOR_RECT: { actions: ["setIndicatorRect"] },
+		SYNC_TAB_INDEX: { actions: ["syncTabIndex"] },
+		INDICATOR_TRANSITION_END: { actions: ["clearIndicatorAnimation"] }
+	},
+	entry: [
+		"syncPrevValue",
+		"syncIndicatorRect",
+		"syncTabIndex",
+		"syncSsr"
+	],
+	exit: ["cleanupObserver"],
+	states: {
+		idle: { on: {
+			TAB_FOCUS: {
+				target: "focused",
+				actions: ["setFocusedValue"]
+			},
+			TAB_CLICK: {
+				target: "focused",
+				actions: ["setFocusedValue", "setValue"]
+			}
+		} },
+		focused: { on: {
+			TAB_CLICK: { actions: ["setFocusedValue", "setValue"] },
+			ARROW_PREV: [{
+				guard: "selectOnFocus",
+				actions: ["focusPrevTab", "selectFocusedTab"]
+			}, { actions: ["focusPrevTab"] }],
+			ARROW_NEXT: [{
+				guard: "selectOnFocus",
+				actions: ["focusNextTab", "selectFocusedTab"]
+			}, { actions: ["focusNextTab"] }],
+			HOME: [{
+				guard: "selectOnFocus",
+				actions: ["focusFirstTab", "selectFocusedTab"]
+			}, { actions: ["focusFirstTab"] }],
+			END: [{
+				guard: "selectOnFocus",
+				actions: ["focusLastTab", "selectFocusedTab"]
+			}, { actions: ["focusLastTab"] }],
+			TAB_FOCUS: { actions: ["setFocusedValue"] },
+			TAB_BLUR: {
+				target: "idle",
+				actions: ["clearFocusedValue"]
+			}
+		} }
+	},
+	implementations: {
+		guards: { selectOnFocus: ({ prop }) => prop("activationMode") === "automatic" },
+		actions: {
+			selectFocusedTab({ context, prop }) {
+				raf(() => {
+					const focusedValue = context.get("focusedValue");
+					if (!focusedValue) return;
+					const value = prop("deselectable") && context.get("value") === focusedValue ? null : focusedValue;
+					context.set("value", value);
+				});
+			},
+			setFocusedValue({ context, event, flush }) {
+				if (event.value == null) return;
+				flush(() => {
+					context.set("focusedValue", event.value);
+				});
+			},
+			clearFocusedValue({ context }) {
+				context.set("focusedValue", null);
+			},
+			setValue({ context, event, prop }) {
+				const nullable = prop("deselectable") && context.get("value") === context.get("focusedValue");
+				context.set("value", nullable ? null : event.value);
+			},
+			clearValue({ context }) {
+				context.set("value", null);
+			},
+			focusFirstTab({ scope }) {
+				raf(() => {
+					getFirstTriggerEl(scope)?.focus();
+				});
+			},
+			focusLastTab({ scope }) {
+				raf(() => {
+					getLastTriggerEl(scope)?.focus();
+				});
+			},
+			focusNextTab({ context, prop, scope, event }) {
+				const focusedValue = event.value ?? context.get("focusedValue");
+				if (!focusedValue) return;
+				const triggerEl = getNextTriggerEl(scope, {
+					value: focusedValue,
+					loopFocus: prop("loopFocus")
+				});
+				raf(() => {
+					if (prop("composite")) triggerEl?.focus();
+					else if (triggerEl?.dataset.value != null) context.set("focusedValue", triggerEl.dataset.value);
+				});
+			},
+			focusPrevTab({ context, prop, scope, event }) {
+				const focusedValue = event.value ?? context.get("focusedValue");
+				if (!focusedValue) return;
+				const triggerEl = getPrevTriggerEl(scope, {
+					value: focusedValue,
+					loopFocus: prop("loopFocus")
+				});
+				raf(() => {
+					if (prop("composite")) triggerEl?.focus();
+					else if (triggerEl?.dataset.value != null) context.set("focusedValue", triggerEl.dataset.value);
+				});
+			},
+			syncTabIndex({ context, scope }) {
+				raf(() => {
+					const value = context.get("value");
+					if (!value) return;
+					const contentEl = getContentEl(scope, value);
+					if (!contentEl) return;
+					if (getFocusables(contentEl).length > 0) contentEl.removeAttribute("tabindex");
+					else contentEl.setAttribute("tabindex", "0");
+				});
+			},
+			cleanupObserver({ refs }) {
+				const cleanup = refs.get("indicatorCleanup");
+				if (cleanup) cleanup();
+			},
+			setIndicatorRect({ context, event, scope }) {
+				const value = event.id ?? context.get("value");
+				if (!getIndicatorEl(scope)) return;
+				if (!value) return;
+				if (!getTriggerEl(scope, value)) return;
+				context.set("indicatorRect", getRectByValue(scope, value));
+			},
+			syncSsr({ context }) {
+				context.set("ssr", false);
+			},
+			syncPrevValue({ context, refs }) {
+				refs.set("prevValue", context.get("value"));
+			},
+			syncIndicatorAnimation({ context, refs }) {
+				const prevValue = refs.get("prevValue");
+				const nextValue = context.get("value");
+				const animate = prevValue != null && nextValue != null && prevValue !== nextValue;
+				context.set("animateIndicator", animate);
+				refs.set("prevValue", nextValue);
+			},
+			clearIndicatorAnimation({ context }) {
+				context.set("animateIndicator", false);
+			},
+			syncIndicatorRect({ context, refs, scope }) {
+				const cleanup = refs.get("indicatorCleanup");
+				if (cleanup) cleanup();
+				if (!getIndicatorEl(scope)) return;
+				const exec = () => {
+					const triggerEl = getTriggerEl(scope, context.get("value"));
+					if (!triggerEl) return;
+					const rect = getOffsetRect(triggerEl);
+					context.set("indicatorRect", (prev) => isEqual(prev, rect) ? prev : rect);
+				};
+				exec();
+				const triggerEls = getElements(scope);
+				const listEl = getListEl(scope);
+				const indicatorCleanup = callAll(...triggerEls.map((el) => resizeObserverBorderBox.observe(el, exec)), ...listEl ? [resizeObserverBorderBox.observe(listEl, exec)] : []);
+				refs.set("indicatorCleanup", indicatorCleanup);
+			},
+			navigateIfNeeded({ context, prop, scope }) {
+				const value = context.get("value");
+				if (!value) return;
+				const triggerEl = getTriggerEl(scope, value);
+				if (isAnchorElement(triggerEl)) prop("navigate")?.({
+					value,
+					node: triggerEl,
+					href: triggerEl.href
+				});
+			}
+		}
+	}
+});
+//#endregion
+//#region src/machines/tabs/props.ts
+const props = createProps()([
+	"activationMode",
+	"composite",
+	"deselectable",
+	"dir",
+	"getRootNode",
+	"id",
+	"ids",
+	"loopFocus",
+	"navigate",
+	"onFocusChange",
+	"onValueChange",
+	"orientation",
+	"translations",
+	"value",
+	"defaultValue"
+]);
+const splitProps = createSplitProps(props);
+const triggerProps = createProps()(["disabled", "value"]);
+const splitTriggerProps = createSplitProps(triggerProps);
+const contentProps = createProps()(["value"]);
+const splitContentProps = createSplitProps(contentProps);
+//#endregion
+export { anatomy, connect, contentProps, machine, props, splitContentProps, splitProps, splitTriggerProps, triggerProps };