@sprawlify/primitives 0.0.1

package/dist/machines/accordion/index.d.mts

@@ -0,0 +1,83 @@
+import { n as AnatomyInstance } from "../../create-anatomy-B3XYc-qG.mjs";
+import { p as Machine, u as EventObject, y as Service } from "../../types-DDTcG99l.mjs";
+import { b as NormalizeProps, g as RequiredBy, r as DirectionProperty, t as CommonProperties, x as PropTypes } from "../../index-C0MKXQmE.mjs";
+
+//#region src/machines/accordion/accordion.anatomy.d.ts
+declare const anatomy: AnatomyInstance<"root" | "item" | "itemIndicator" | "itemContent" | "itemTrigger">;
+//#endregion
+//#region src/machines/accordion/accordion.types.d.ts
+interface ValueChangeDetails {
+  value: string[];
+}
+interface FocusChangeDetails {
+  value: string | null;
+}
+type ElementIds = Partial<{
+  root: string;
+  item: (value: string) => string;
+  itemContent: (value: string) => string;
+  itemTrigger: (value: string) => string;
+}>;
+interface AccordionProps extends DirectionProperty, CommonProperties {
+  ids?: ElementIds | undefined;
+  multiple?: boolean | undefined;
+  collapsible?: boolean | undefined;
+  value?: string[] | undefined;
+  defaultValue?: string[] | undefined;
+  disabled?: boolean | undefined;
+  onValueChange?: ((details: ValueChangeDetails) => void) | undefined;
+  onFocusChange?: ((details: FocusChangeDetails) => void) | undefined;
+  orientation?: "horizontal" | "vertical" | undefined;
+}
+type PropsWithDefault = "multiple" | "collapsible" | "orientation";
+type AccordionSchema = {
+  state: "idle" | "focused";
+  props: RequiredBy<AccordionProps, PropsWithDefault>;
+  context: {
+    value: string[];
+    focusedValue: string | null;
+  };
+  computed: {
+    isHorizontal: boolean;
+  };
+  action: string;
+  guard: string;
+  effect: string;
+  event: EventObject;
+};
+type AccordionService = Service<AccordionSchema>;
+type AccordionMachine = Machine<AccordionSchema>;
+interface ItemProps {
+  value: string;
+  disabled?: boolean | undefined;
+}
+interface ItemState {
+  expanded: boolean;
+  focused: boolean;
+  disabled: boolean;
+}
+interface AccordionApi<T extends PropTypes = PropTypes> {
+  focusedValue: string | null;
+  value: string[];
+  setValue: (value: string[]) => void;
+  getItemState: (props: ItemProps) => ItemState;
+  getRootProps: () => T["element"];
+  getItemProps: (props: ItemProps) => T["element"];
+  getItemContentProps: (props: ItemProps) => T["element"];
+  getItemTriggerProps: (props: ItemProps) => T["button"];
+  getItemIndicatorProps: (props: ItemProps) => T["element"];
+}
+//#endregion
+//#region src/machines/accordion/accordion.connect.d.ts
+declare function connect<T extends PropTypes>(service: Service<AccordionSchema>, normalize: NormalizeProps<T>): AccordionApi<T>;
+//#endregion
+//#region src/machines/accordion/accordion.machine.d.ts
+declare const machine: Machine<AccordionSchema>;
+//#endregion
+//#region src/machines/accordion/accordion.props.d.ts
+declare const props: (keyof AccordionProps)[];
+declare const splitProps: <Props extends Partial<AccordionProps>>(props: Props) => [Partial<AccordionProps>, Omit<Props, keyof AccordionProps>];
+declare const itemProps: (keyof ItemProps)[];
+declare const splitItemProps: <Props extends ItemProps>(props: Props) => [ItemProps, Omit<Props, keyof ItemProps>];
+//#endregion
+export { type AccordionApi as Api, type ElementIds, type FocusChangeDetails, type ItemProps, type ItemState, type AccordionMachine as Machine, type AccordionProps as Props, type AccordionService as Service, type ValueChangeDetails, anatomy, connect, itemProps, machine, props, splitItemProps, splitProps };

package/dist/machines/accordion/index.mjs

@@ -0,0 +1,322 @@
+import { t as createAnatomy } from "../../create-anatomy-BbDZbHpC.mjs";
+import { Rt as isSafari, S as queryAll, b as prevById, lt as getEventKey, vn as dataAttr, y as nextById } from "../../dom-query-DFCRhyj1.mjs";
+import { Ct as last, _t as first, ft as add, i as warn, kt as remove, u as createSplitProps } from "../../utils-BZyrxWWR.mjs";
+import { a as createMachine, i as createGuards } from "../../core-DCFNMTZF.mjs";
+import { t as createProps } from "../../create-props-BnF_vl-E.mjs";
+
+//#region src/machines/accordion/accordion.anatomy.ts
+const anatomy = createAnatomy("accordion").parts("root", "item", "itemTrigger", "itemContent", "itemIndicator");
+const parts = anatomy.build();
+
+//#endregion
+//#region src/machines/accordion/accordion.dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `accordion:${ctx.id}`;
+const getItemId = (ctx, value) => ctx.ids?.item?.(value) ?? `accordion:${ctx.id}:item:${value}`;
+const getItemContentId = (ctx, value) => ctx.ids?.itemContent?.(value) ?? `accordion:${ctx.id}:content:${value}`;
+const getItemTriggerId = (ctx, value) => ctx.ids?.itemTrigger?.(value) ?? `accordion:${ctx.id}:trigger:${value}`;
+const getRootEl = (ctx) => ctx.getById(getRootId(ctx));
+const getTriggerEls = (ctx) => {
+	const selector = `[aria-controls][data-ownedby='${CSS.escape(getRootId(ctx))}']:not([disabled])`;
+	return queryAll(getRootEl(ctx), selector);
+};
+const getFirstTriggerEl = (ctx) => first(getTriggerEls(ctx));
+const getLastTriggerEl = (ctx) => last(getTriggerEls(ctx));
+const getNextTriggerEl = (ctx, id) => nextById(getTriggerEls(ctx), getItemTriggerId(ctx, id));
+const getPrevTriggerEl = (ctx, id) => prevById(getTriggerEls(ctx), getItemTriggerId(ctx, id));
+
+//#endregion
+//#region src/machines/accordion/accordion.connect.ts
+function connect(service, normalize) {
+	const { send, context, prop, scope, computed } = service;
+	const focusedValue = context.get("focusedValue");
+	const value = context.get("value");
+	const multiple = prop("multiple");
+	function setValue(value$1) {
+		let nextValue = value$1;
+		if (!multiple && nextValue.length > 1) nextValue = [nextValue[0]];
+		send({
+			type: "VALUE.SET",
+			value: nextValue
+		});
+	}
+	function getItemState(props$1) {
+		return {
+			expanded: value.includes(props$1.value),
+			focused: focusedValue === props$1.value,
+			disabled: Boolean(props$1.disabled ?? prop("disabled"))
+		};
+	}
+	return {
+		focusedValue,
+		value,
+		setValue,
+		getItemState,
+		getRootProps() {
+			return normalize.element({
+				...parts.root.attrs,
+				dir: prop("dir"),
+				id: getRootId(scope),
+				"data-orientation": prop("orientation")
+			});
+		},
+		getItemProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				...parts.item.attrs,
+				dir: prop("dir"),
+				id: getItemId(scope, props$1.value),
+				"data-state": itemState.expanded ? "open" : "closed",
+				"data-focus": dataAttr(itemState.focused),
+				"data-disabled": dataAttr(itemState.disabled),
+				"data-orientation": prop("orientation")
+			});
+		},
+		getItemContentProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				...parts.itemContent.attrs,
+				dir: prop("dir"),
+				role: "region",
+				id: getItemContentId(scope, props$1.value),
+				"aria-labelledby": getItemTriggerId(scope, props$1.value),
+				hidden: !itemState.expanded,
+				"data-state": itemState.expanded ? "open" : "closed",
+				"data-disabled": dataAttr(itemState.disabled),
+				"data-focus": dataAttr(itemState.focused),
+				"data-orientation": prop("orientation")
+			});
+		},
+		getItemIndicatorProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				...parts.itemIndicator.attrs,
+				dir: prop("dir"),
+				"aria-hidden": true,
+				"data-state": itemState.expanded ? "open" : "closed",
+				"data-disabled": dataAttr(itemState.disabled),
+				"data-focus": dataAttr(itemState.focused),
+				"data-orientation": prop("orientation")
+			});
+		},
+		getItemTriggerProps(props$1) {
+			const { value: value$1 } = props$1;
+			const itemState = getItemState(props$1);
+			return normalize.button({
+				...parts.itemTrigger.attrs,
+				type: "button",
+				dir: prop("dir"),
+				id: getItemTriggerId(scope, value$1),
+				"aria-controls": getItemContentId(scope, value$1),
+				"aria-expanded": itemState.expanded,
+				disabled: itemState.disabled,
+				"data-orientation": prop("orientation"),
+				"aria-disabled": itemState.disabled,
+				"data-state": itemState.expanded ? "open" : "closed",
+				"data-ownedby": getRootId(scope),
+				onFocus() {
+					if (itemState.disabled) return;
+					send({
+						type: "TRIGGER.FOCUS",
+						value: value$1
+					});
+				},
+				onBlur() {
+					if (itemState.disabled) return;
+					send({ type: "TRIGGER.BLUR" });
+				},
+				onClick(event) {
+					if (itemState.disabled) return;
+					if (isSafari()) event.currentTarget.focus();
+					send({
+						type: "TRIGGER.CLICK",
+						value: value$1
+					});
+				},
+				onKeyDown(event) {
+					if (event.defaultPrevented) return;
+					if (itemState.disabled) return;
+					const exec = {
+						ArrowDown() {
+							if (computed("isHorizontal")) return;
+							send({
+								type: "GOTO.NEXT",
+								value: value$1
+							});
+						},
+						ArrowUp() {
+							if (computed("isHorizontal")) return;
+							send({
+								type: "GOTO.PREV",
+								value: value$1
+							});
+						},
+						ArrowRight() {
+							if (!computed("isHorizontal")) return;
+							send({
+								type: "GOTO.NEXT",
+								value: value$1
+							});
+						},
+						ArrowLeft() {
+							if (!computed("isHorizontal")) return;
+							send({
+								type: "GOTO.PREV",
+								value: value$1
+							});
+						},
+						Home() {
+							send({
+								type: "GOTO.FIRST",
+								value: value$1
+							});
+						},
+						End() {
+							send({
+								type: "GOTO.LAST",
+								value: value$1
+							});
+						}
+					}[getEventKey(event, {
+						dir: prop("dir"),
+						orientation: prop("orientation")
+					})];
+					if (exec) {
+						exec(event);
+						event.preventDefault();
+					}
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/machines/accordion/accordion.machine.ts
+const { and, not } = createGuards();
+const machine = createMachine({
+	props({ props: props$1 }) {
+		return {
+			collapsible: false,
+			multiple: false,
+			orientation: "vertical",
+			defaultValue: [],
+			...props$1
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop, bindable }) {
+		return {
+			focusedValue: bindable(() => ({
+				defaultValue: null,
+				sync: true,
+				onChange(value) {
+					prop("onFocusChange")?.({ value });
+				}
+			})),
+			value: bindable(() => ({
+				defaultValue: prop("defaultValue"),
+				value: prop("value"),
+				onChange(value) {
+					prop("onValueChange")?.({ value });
+				}
+			}))
+		};
+	},
+	computed: { isHorizontal: ({ prop }) => prop("orientation") === "horizontal" },
+	on: { "VALUE.SET": { actions: ["setValue"] } },
+	states: {
+		idle: { on: { "TRIGGER.FOCUS": {
+			target: "focused",
+			actions: ["setFocusedValue"]
+		} } },
+		focused: { on: {
+			"GOTO.NEXT": { actions: ["focusNextTrigger"] },
+			"GOTO.PREV": { actions: ["focusPrevTrigger"] },
+			"TRIGGER.CLICK": [{
+				guard: and("isExpanded", "canToggle"),
+				actions: ["collapse"]
+			}, {
+				guard: not("isExpanded"),
+				actions: ["expand"]
+			}],
+			"GOTO.FIRST": { actions: ["focusFirstTrigger"] },
+			"GOTO.LAST": { actions: ["focusLastTrigger"] },
+			"TRIGGER.BLUR": {
+				target: "idle",
+				actions: ["clearFocusedValue"]
+			}
+		} }
+	},
+	implementations: {
+		guards: {
+			canToggle: ({ prop }) => !!prop("collapsible") || !!prop("multiple"),
+			isExpanded: ({ context, event }) => context.get("value").includes(event.value)
+		},
+		actions: {
+			collapse({ context, prop, event }) {
+				const next = prop("multiple") ? remove(context.get("value"), event.value) : [];
+				context.set("value", next);
+			},
+			expand({ context, prop, event }) {
+				const next = prop("multiple") ? add(context.get("value"), event.value) : [event.value];
+				context.set("value", next);
+			},
+			focusFirstTrigger({ scope }) {
+				getFirstTriggerEl(scope)?.focus();
+			},
+			focusLastTrigger({ scope }) {
+				getLastTriggerEl(scope)?.focus();
+			},
+			focusNextTrigger({ context, scope }) {
+				const focusedValue = context.get("focusedValue");
+				if (!focusedValue) return;
+				getNextTriggerEl(scope, focusedValue)?.focus();
+			},
+			focusPrevTrigger({ context, scope }) {
+				const focusedValue = context.get("focusedValue");
+				if (!focusedValue) return;
+				getPrevTriggerEl(scope, focusedValue)?.focus();
+			},
+			setFocusedValue({ context, event }) {
+				context.set("focusedValue", event.value);
+			},
+			clearFocusedValue({ context }) {
+				context.set("focusedValue", null);
+			},
+			setValue({ context, event }) {
+				context.set("value", event.value);
+			},
+			coarseValue({ context, prop }) {
+				if (!prop("multiple") && context.get("value").length > 1) {
+					warn(`The value of accordion should be a single value when multiple is false.`);
+					context.set("value", [context.get("value")[0]]);
+				}
+			}
+		}
+	}
+});
+
+//#endregion
+//#region src/machines/accordion/accordion.props.ts
+const props = createProps()([
+	"collapsible",
+	"dir",
+	"disabled",
+	"getRootNode",
+	"id",
+	"ids",
+	"multiple",
+	"onFocusChange",
+	"onValueChange",
+	"orientation",
+	"value",
+	"defaultValue"
+]);
+const splitProps = createSplitProps(props);
+const itemProps = createProps()(["value", "disabled"]);
+const splitItemProps = createSplitProps(itemProps);
+
+//#endregion
+export { anatomy, connect, itemProps, machine, props, splitItemProps, splitProps };

package/dist/machines/async-list/index.cjs

@@ -0,0 +1,311 @@
+require('../../dom-query-CWZdWUGp.cjs');
+const require_utils = require('../../utils-_6frwjgJ.cjs');
+const require_core = require('../../core-CQFbMdTl.cjs');
+
+//#region src/machines/async-list/async-list.connect.ts
+function connect(service) {
+	const { state, context, send } = service;
+	const loading = state.matches("loading", "sorting");
+	const sorting = state.matches("sorting");
+	const items = context.get("items");
+	const cursor = context.get("cursor");
+	const empty = items.length === 0;
+	const hasMore = cursor != null;
+	return {
+		items,
+		sortDescriptor: context.get("sortDescriptor"),
+		loading,
+		sorting,
+		empty,
+		hasMore,
+		error: context.get("error"),
+		filterText: context.get("filterText"),
+		cursor,
+		abort() {
+			send({ type: "ABORT" });
+		},
+		reload() {
+			send({ type: "RELOAD" });
+		},
+		loadMore() {
+			send({ type: "LOAD_MORE" });
+		},
+		sort(sortDescriptor) {
+			send({
+				type: "SORT",
+				sortDescriptor
+			});
+		},
+		setFilterText(filterText) {
+			send({
+				type: "FILTER",
+				filterText
+			});
+		},
+		clearFilter() {
+			send({
+				type: "FILTER",
+				filterText: ""
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/machines/async-list/async-list.machine.ts
+const machine = require_core.createMachine({
+	props({ props }) {
+		require_utils.ensureProps(props, ["load"], "load is required");
+		return props;
+	},
+	context({ prop, bindable }) {
+		return {
+			items: bindable(() => ({ defaultValue: prop("initialItems") ?? [] })),
+			cursor: bindable(() => ({ defaultValue: null })),
+			filterText: bindable(() => ({ defaultValue: prop("initialFilterText") ?? "" })),
+			sortDescriptor: bindable(() => ({ defaultValue: prop("initialSortDescriptor") })),
+			error: bindable(() => ({ defaultValue: void 0 }))
+		};
+	},
+	refs() {
+		return {
+			abort: null,
+			seq: 0
+		};
+	},
+	watch({ prop, track, send }) {
+		track([() => hashDeps(prop("dependencies"))], () => {
+			send({ type: "RELOAD" });
+		});
+	},
+	initialState() {
+		return "idle";
+	},
+	on: { RELOAD: {
+		target: "loading",
+		reenter: true,
+		actions: ["clearItems"]
+	} },
+	entry: ["loadIfNeeded"],
+	states: {
+		idle: { on: {
+			LOAD_MORE: {
+				guard: "hasCursor",
+				target: "loading"
+			},
+			SORT: [{
+				guard: "hasSortFn",
+				target: "sorting",
+				actions: [
+					"setSortDescriptor",
+					"clearCursor",
+					"performSort"
+				]
+			}, {
+				target: "loading",
+				actions: ["setSortDescriptor", "clearCursor"]
+			}],
+			FILTER: {
+				target: "loading",
+				actions: ["setFilterText", "clearCursor"]
+			}
+		} },
+		loading: {
+			entry: ["performFetch"],
+			exit: ["cancelFetch"],
+			on: {
+				SUCCESS: {
+					target: "idle",
+					actions: [
+						"setItems",
+						"setCursor",
+						"clearError",
+						"invokeOnSuccess"
+					]
+				},
+				ERROR: {
+					target: "idle",
+					actions: ["setError", "invokeOnError"]
+				},
+				ABORT: {
+					target: "idle",
+					actions: ["cancelFetch"]
+				},
+				FILTER: {
+					reenter: true,
+					target: "loading",
+					actions: ["setFilterText", "clearCursor"]
+				}
+			}
+		},
+		sorting: { on: {
+			SUCCESS: {
+				target: "idle",
+				actions: [
+					"setItems",
+					"setCursor",
+					"clearError",
+					"invokeOnSuccess"
+				]
+			},
+			ERROR: {
+				target: "idle",
+				actions: ["setError", "invokeOnError"]
+			},
+			ABORT: {
+				target: "idle",
+				actions: ["cancelSort"]
+			},
+			FILTER: {
+				target: "loading",
+				actions: [
+					"setFilterText",
+					"clearCursor",
+					"cancelSort"
+				]
+			},
+			RELOAD: {
+				target: "loading",
+				actions: ["clearItems", "cancelSort"]
+			},
+			SORT: [{
+				guard: "hasSortFn",
+				target: "sorting",
+				reenter: true,
+				actions: [
+					"setSortDescriptor",
+					"clearCursor",
+					"cancelSort",
+					"performSort"
+				]
+			}, {
+				target: "loading",
+				actions: [
+					"setSortDescriptor",
+					"clearCursor",
+					"cancelSort"
+				]
+			}]
+		} }
+	},
+	implementations: {
+		guards: {
+			hasCursor({ context }) {
+				return context.get("cursor") != null;
+			},
+			hasSortFn({ prop }) {
+				return prop("sort") != null;
+			}
+		},
+		actions: {
+			loadIfNeeded({ prop, send }) {
+				if (!prop("autoReload")) return;
+				send({ type: "RELOAD" });
+			},
+			performFetch({ context, prop, refs, send, event }) {
+				refs.set("abort", new AbortController());
+				const abort = refs.get("abort");
+				context.set("error", void 0);
+				const seq = refs.get("seq") + 1;
+				refs.set("seq", seq);
+				const isLoadMore = event.type === "LOAD_MORE";
+				prop("load")({
+					signal: abort?.signal,
+					cursor: isLoadMore ? context.get("cursor") : null,
+					filterText: event.filterText ?? context.get("filterText"),
+					sortDescriptor: event.sortDescriptor ?? context.get("sortDescriptor")
+				}).then(({ items, cursor }) => {
+					if (seq !== refs.get("seq")) return;
+					send({
+						type: "SUCCESS",
+						items,
+						cursor,
+						append: isLoadMore
+					});
+				}).catch((error) => {
+					if (seq !== refs.get("seq")) return;
+					if (isAbortError(error)) return;
+					send({
+						type: "ERROR",
+						error
+					});
+				});
+			},
+			performSort({ context, prop, send, event, refs }) {
+				const sortFn = prop("sort");
+				require_utils.ensure(sortFn, () => "[sprawlify-js/async-list] sort is required");
+				const currentItems = context.get("items");
+				const filterText = context.get("filterText");
+				const seq = refs.get("seq") + 1;
+				refs.set("seq", seq);
+				Promise.resolve(sortFn({
+					items: currentItems,
+					descriptor: event.sortDescriptor,
+					filterText
+				})).then((r) => {
+					if (seq !== refs.get("seq")) return;
+					send({
+						type: "SUCCESS",
+						items: r?.items ?? currentItems,
+						cursor: void 0,
+						append: false
+					});
+				}).catch((e) => {
+					if (seq !== refs.get("seq")) return;
+					send({
+						type: "ERROR",
+						error: e
+					});
+				});
+			},
+			setSortDescriptor({ context, event }) {
+				context.set("sortDescriptor", event.sortDescriptor);
+			},
+			setFilterText({ context, event }) {
+				context.set("filterText", event.filterText);
+			},
+			invokeOnSuccess({ prop, event }) {
+				prop("onSuccess")?.({ items: event.items });
+			},
+			invokeOnError({ prop, event }) {
+				prop("onError")?.({ error: event.error });
+			},
+			clearItems({ context }) {
+				context.set("items", []);
+			},
+			setItems({ context, event }) {
+				context.set("items", (prev) => event.append ? [...prev, ...event.items] : event.items);
+			},
+			setCursor({ context, event }) {
+				context.set("cursor", event.cursor);
+			},
+			setError({ context, event }) {
+				context.set("error", event.error);
+			},
+			clearError({ context }) {
+				context.set("error", void 0);
+			},
+			clearCursor({ context }) {
+				context.set("cursor", null);
+			},
+			cancelFetch({ refs }) {
+				refs.get("abort")?.abort();
+				refs.set("abort", null);
+			},
+			cancelSort({ refs }) {
+				const seq = refs.get("seq") + 1;
+				refs.set("seq", seq);
+			}
+		}
+	}
+});
+function isAbortError(err) {
+	return err instanceof Error && err.name === "AbortError";
+}
+function hashDeps(deps = []) {
+	return deps.filter(Boolean).join(",");
+}
+
+//#endregion
+exports.connect = connect;
+exports.machine = machine;