@manafishrov/ui 1.5.0 → 1.5.2

package/dist/node_modules/.bun/@zag-js_tags-input@1.38.2/node_modules/@zag-js/tags-input/dist/tags-input.machine.js

@@ -0,0 +1,639 @@
+import { removeAt as e, uniq as t } from "../../../../../@zag-js_utils@1.38.2/node_modules/@zag-js/utils/dist/array.js";
+import { isEqual as n } from "../../../../../@zag-js_utils@1.38.2/node_modules/@zag-js/utils/dist/equal.js";
+import { warn as r } from "../../../../../@zag-js_utils@1.38.2/node_modules/@zag-js/utils/dist/warning.js";
+import { createGuards as i, createMachine as a } from "../../../../../@zag-js_core@1.38.2/node_modules/@zag-js/core/dist/create-machine.js";
+import { isCaretAtStart as o } from "../../../../../@zag-js_dom-query@1.38.2/node_modules/@zag-js/dom-query/dist/caret.js";
+import { contains as s } from "../../../../../@zag-js_dom-query@1.38.2/node_modules/@zag-js/dom-query/dist/node.js";
+import { setElementValue as c, trackFormControl as l } from "../../../../../@zag-js_dom-query@1.38.2/node_modules/@zag-js/dom-query/dist/form.js";
+import { raf as u } from "../../../../../@zag-js_dom-query@1.38.2/node_modules/@zag-js/dom-query/dist/raf.js";
+import { trackInteractOutside as d } from "../../../../../@zag-js_interact-outside@1.38.2/node_modules/@zag-js/interact-outside/dist/index.js";
+import { autoResizeInput as f } from "../../../../../@zag-js_auto-resize@1.38.2/node_modules/@zag-js/auto-resize/dist/autoresize-input.js";
+import { createLiveRegion as p } from "../../../../../@zag-js_live-region@1.38.2/node_modules/@zag-js/live-region/dist/index.js";
+import { dispatchInputEvent as m, getEditInputEl as h, getFirstEl as g, getHiddenInputEl as _, getIndexOfId as v, getInputEl as y, getItemEls as b, getItemId as x, getLastEl as S, getNextEl as C, getPrevEl as w, getTagElAtIndex as T, getTagInputEl as E } from "./tags-input.dom.js";
+//#region ../../node_modules/.bun/@zag-js+tags-input@1.38.2/node_modules/@zag-js/tags-input/dist/tags-input.machine.mjs
+var { and: D, not: O, or: k } = i(), A = a({
+	props({ props: e }) {
+		return {
+			dir: "ltr",
+			addOnPaste: !1,
+			editable: !0,
+			validate: () => !0,
+			allowDuplicates: !1,
+			delimiter: ",",
+			defaultValue: [],
+			defaultInputValue: "",
+			max: Infinity,
+			...e,
+			translations: {
+				clearTriggerLabel: "Clear all tags",
+				deleteTagTriggerLabel: (e) => `Delete tag ${e}`,
+				tagAdded: (e) => `Added tag ${e}`,
+				tagsPasted: (e) => `Pasted ${e.length} tags`,
+				tagEdited: (e) => `Editing tag ${e}. Press enter to save or escape to cancel.`,
+				tagUpdated: (e) => `Tag update to ${e}`,
+				tagDeleted: (e) => `Tag ${e} deleted`,
+				tagSelected: (e) => `Tag ${e} selected. Press enter to edit, delete or backspace to remove.`,
+				...e.translations
+			}
+		};
+	},
+	initialState({ prop: e }) {
+		return e("autoFocus") ? "focused:input" : "idle";
+	},
+	refs() {
+		return {
+			liveRegion: null,
+			log: {
+				current: null,
+				prev: null
+			}
+		};
+	},
+	context({ bindable: e, prop: t }) {
+		return {
+			value: e(() => ({
+				defaultValue: t("defaultValue"),
+				value: t("value"),
+				isEqual: n,
+				hash(e) {
+					return e.join(", ");
+				},
+				onChange(e) {
+					t("onValueChange")?.({ value: e });
+				}
+			})),
+			inputValue: e(() => ({
+				sync: !0,
+				defaultValue: t("defaultInputValue"),
+				value: t("inputValue"),
+				onChange(e) {
+					t("onInputValueChange")?.({ inputValue: e });
+				}
+			})),
+			fieldsetDisabled: e(() => ({ defaultValue: !1 })),
+			editedTagValue: e(() => ({ defaultValue: "" })),
+			editedTagId: e(() => ({ defaultValue: null })),
+			editedTagIndex: e(() => ({
+				defaultValue: null,
+				sync: !0
+			})),
+			highlightedTagId: e(() => ({
+				defaultValue: null,
+				sync: !0,
+				onChange(e) {
+					t("onHighlightChange")?.({ highlightedValue: e });
+				}
+			}))
+		};
+	},
+	computed: {
+		count: ({ context: e }) => e.get("value").length,
+		valueAsString: ({ context: e }) => e.hash("value"),
+		trimmedInputValue: ({ context: e }) => e.get("inputValue").trim(),
+		isDisabled: ({ prop: e }) => !!e("disabled"),
+		isInteractive: ({ prop: e }) => !(e("readOnly") || e("disabled")),
+		isAtMax: ({ context: e, prop: t }) => e.get("value").length === t("max"),
+		isOverflowing: ({ context: e, prop: t }) => e.get("value").length > t("max")
+	},
+	watch({ track: e, context: t, action: n, computed: r, refs: i }) {
+		e([() => t.get("editedTagValue")], () => {
+			n(["syncEditedTagInputValue"]);
+		}), e([() => t.get("inputValue")], () => {
+			n(["syncInputValue"]);
+		}), e([() => t.get("highlightedTagId")], () => {
+			n(["logHighlightedTag"]);
+		}), e([() => r("isOverflowing")], () => {
+			n(["invokeOnInvalid"]);
+		}), e([() => JSON.stringify(i.get("log"))], () => {
+			n(["announceLog"]);
+		});
+	},
+	effects: ["trackLiveRegion", "trackFormControlState"],
+	exit: ["clearLog"],
+	on: {
+		DOUBLE_CLICK_TAG: {
+			guard: "isTagEditable",
+			target: "editing:tag",
+			actions: ["setEditedId"]
+		},
+		POINTER_DOWN_TAG: {
+			target: "navigating:tag",
+			actions: ["highlightTag", "focusInput"]
+		},
+		CLICK_DELETE_TAG: {
+			target: "focused:input",
+			actions: ["deleteTag"]
+		},
+		SET_INPUT_VALUE: { actions: ["setInputValue"] },
+		SET_VALUE: { actions: ["setValue"] },
+		CLEAR_TAG: { actions: ["deleteTag"] },
+		SET_VALUE_AT_INDEX: { actions: ["setValueAtIndex"] },
+		CLEAR_VALUE: { actions: [
+			"clearTags",
+			"clearInputValue",
+			"focusInput"
+		] },
+		ADD_TAG: { actions: ["addTag"] },
+		INSERT_TAG: {
+			guard: D(k(O("isAtMax"), "allowOverflow"), O("isInputValueEmpty")),
+			actions: ["addTag", "clearInputValue"]
+		},
+		EXTERNAL_BLUR: [{
+			guard: "addOnBlur",
+			actions: ["raiseInsertTagEvent"]
+		}, {
+			guard: "clearOnBlur",
+			actions: ["clearInputValue"]
+		}]
+	},
+	states: {
+		idle: { on: {
+			FOCUS: { target: "focused:input" },
+			POINTER_DOWN: {
+				guard: O("hasHighlightedTag"),
+				target: "focused:input"
+			}
+		} },
+		"focused:input": {
+			tags: ["focused"],
+			entry: ["focusInput", "clearHighlightedId"],
+			effects: ["trackInteractOutside"],
+			on: {
+				TYPE: { actions: ["setInputValue"] },
+				BLUR: [
+					{
+						guard: "addOnBlur",
+						target: "idle",
+						actions: ["raiseInsertTagEvent"]
+					},
+					{
+						guard: "clearOnBlur",
+						target: "idle",
+						actions: ["clearInputValue"]
+					},
+					{ target: "idle" }
+				],
+				ENTER: { actions: ["raiseInsertTagEvent"] },
+				DELIMITER_KEY: { actions: ["raiseInsertTagEvent"] },
+				ARROW_LEFT: {
+					guard: D("hasTags", "isCaretAtStart"),
+					target: "navigating:tag",
+					actions: ["highlightLastTag"]
+				},
+				BACKSPACE: {
+					target: "navigating:tag",
+					guard: D("hasTags", "isCaretAtStart"),
+					actions: ["highlightLastTag"]
+				},
+				DELETE: {
+					guard: "hasHighlightedTag",
+					actions: ["deleteHighlightedTag", "highlightTagAtIndex"]
+				},
+				PASTE: [{
+					guard: "addOnPaste",
+					actions: ["setInputValue", "addTagFromPaste"]
+				}, { actions: ["setInputValue"] }]
+			}
+		},
+		"navigating:tag": {
+			tags: ["focused"],
+			effects: ["trackInteractOutside"],
+			on: {
+				ARROW_RIGHT: [{
+					guard: D("hasTags", "isCaretAtStart", O("isLastTagHighlighted")),
+					actions: ["highlightNextTag"]
+				}, { target: "focused:input" }],
+				ARROW_LEFT: [{
+					guard: O("isCaretAtStart"),
+					target: "focused:input"
+				}, { actions: ["highlightPrevTag"] }],
+				BLUR: {
+					target: "idle",
+					actions: ["clearHighlightedId"]
+				},
+				ENTER: {
+					guard: D("isTagEditable", "hasHighlightedTag"),
+					target: "editing:tag",
+					actions: ["setEditedId", "focusEditedTagInput"]
+				},
+				ARROW_DOWN: { target: "focused:input" },
+				ESCAPE: { target: "focused:input" },
+				TYPE: {
+					target: "focused:input",
+					actions: ["setInputValue"]
+				},
+				BACKSPACE: [
+					{
+						guard: O("isCaretAtStart"),
+						target: "focused:input"
+					},
+					{
+						guard: "isFirstTagHighlighted",
+						actions: ["deleteHighlightedTag", "highlightFirstTag"]
+					},
+					{
+						guard: "hasHighlightedTag",
+						actions: ["deleteHighlightedTag", "highlightPrevTag"]
+					},
+					{ actions: ["highlightLastTag"] }
+				],
+				DELETE: [{
+					guard: O("isCaretAtStart"),
+					target: "focused:input"
+				}, {
+					target: "focused:input",
+					actions: ["deleteHighlightedTag", "highlightTagAtIndex"]
+				}],
+				PASTE: [{
+					guard: "addOnPaste",
+					target: "focused:input",
+					actions: ["setInputValue", "addTagFromPaste"]
+				}, {
+					target: "focused:input",
+					actions: ["setInputValue"]
+				}]
+			}
+		},
+		"editing:tag": {
+			tags: ["editing", "focused"],
+			entry: ["focusEditedTagInput"],
+			effects: ["autoResize"],
+			on: {
+				TAG_INPUT_TYPE: { actions: ["setEditedTagValue"] },
+				TAG_INPUT_ESCAPE: {
+					target: "navigating:tag",
+					actions: [
+						"clearEditedTagValue",
+						"focusInput",
+						"clearEditedId",
+						"highlightTagAtIndex"
+					]
+				},
+				TAG_INPUT_BLUR: [{
+					guard: "isInputRelatedTarget",
+					target: "navigating:tag",
+					actions: [
+						"clearEditedTagValue",
+						"clearHighlightedId",
+						"clearEditedId"
+					]
+				}, {
+					target: "idle",
+					actions: [
+						"clearEditedTagValue",
+						"clearHighlightedId",
+						"clearEditedId",
+						"raiseExternalBlurEvent"
+					]
+				}],
+				TAG_INPUT_ENTER: [{
+					guard: "isEditedTagEmpty",
+					target: "navigating:tag",
+					actions: [
+						"deleteHighlightedTag",
+						"focusInput",
+						"clearEditedId",
+						"highlightTagAtIndex"
+					]
+				}, {
+					target: "navigating:tag",
+					actions: [
+						"submitEditedTagValue",
+						"focusInput",
+						"clearEditedId",
+						"highlightTagAtIndex"
+					]
+				}]
+			}
+		}
+	},
+	implementations: {
+		guards: {
+			isInputRelatedTarget: ({ scope: e, event: t }) => t.relatedTarget === y(e),
+			isAtMax: ({ computed: e }) => e("isAtMax"),
+			hasHighlightedTag: ({ context: e }) => e.get("highlightedTagId") != null,
+			isFirstTagHighlighted: ({ context: e, scope: t }) => x(t, {
+				value: e.get("value")[0],
+				index: 0
+			}) === e.get("highlightedTagId"),
+			isEditedTagEmpty: ({ context: e }) => e.get("editedTagValue").trim() === "",
+			isLastTagHighlighted: ({ context: e, scope: t }) => {
+				let n = e.get("value"), r = n.length - 1;
+				return x(t, {
+					value: n[r],
+					index: r
+				}) === e.get("highlightedTagId");
+			},
+			isInputValueEmpty: ({ context: e }) => e.get("inputValue").trim().length === 0,
+			hasTags: ({ context: e }) => e.get("value").length > 0,
+			allowOverflow: ({ prop: e }) => !!e("allowOverflow"),
+			autoFocus: ({ prop: e }) => !!e("autoFocus"),
+			addOnBlur: ({ prop: e }) => e("blurBehavior") === "add",
+			clearOnBlur: ({ prop: e }) => e("blurBehavior") === "clear",
+			addOnPaste: ({ prop: e }) => !!e("addOnPaste"),
+			isTagEditable: ({ prop: e }) => !!e("editable"),
+			isCaretAtStart: ({ scope: e }) => o(y(e))
+		},
+		effects: {
+			trackInteractOutside({ scope: e, prop: t, send: n }) {
+				return d(y(e), {
+					exclude(t) {
+						return b(e).some((e) => s(e, t));
+					},
+					onFocusOutside: t("onFocusOutside"),
+					onPointerDownOutside: t("onPointerDownOutside"),
+					onInteractOutside(e) {
+						t("onInteractOutside")?.(e), !e.defaultPrevented && n({
+							type: "BLUR",
+							src: "interact-outside"
+						});
+					}
+				});
+			},
+			trackFormControlState({ context: e, send: t, scope: n }) {
+				return l(_(n), {
+					onFieldsetDisabledChange(t) {
+						e.set("fieldsetDisabled", t);
+					},
+					onFormReset() {
+						t({
+							type: "SET_VALUE",
+							value: e.initial("value"),
+							src: "form-reset"
+						});
+					}
+				});
+			},
+			autoResize({ context: e, prop: t, scope: n }) {
+				let r;
+				return queueMicrotask(() => {
+					let i = e.get("editedTagValue"), a = e.get("editedTagIndex");
+					!i || a == null || !t("editable") || (r = f(E(n, {
+						value: i,
+						index: a
+					})));
+				}), () => {
+					r?.();
+				};
+			},
+			trackLiveRegion({ scope: e, refs: t }) {
+				let n = p({
+					level: "assertive",
+					document: e.getDoc()
+				});
+				return t.set("liveRegion", n), () => n.destroy();
+			}
+		},
+		actions: {
+			raiseInsertTagEvent({ send: e }) {
+				e({ type: "INSERT_TAG" });
+			},
+			raiseExternalBlurEvent({ send: e, event: t }) {
+				e({
+					type: "EXTERNAL_BLUR",
+					id: t.id
+				});
+			},
+			dispatchChangeEvent({ scope: e, computed: t }) {
+				m(e, t("valueAsString"));
+			},
+			highlightNextTag({ context: e, scope: t }) {
+				let n = e.get("highlightedTagId");
+				if (n == null) return;
+				let r = C(t, n);
+				e.set("highlightedTagId", r?.id ?? null);
+			},
+			highlightFirstTag({ context: e, scope: t }) {
+				u(() => {
+					let n = g(t);
+					e.set("highlightedTagId", n?.id ?? null);
+				});
+			},
+			highlightLastTag({ context: e, scope: t }) {
+				let n = S(t);
+				e.set("highlightedTagId", n?.id ?? null);
+			},
+			highlightPrevTag({ context: e, scope: t }) {
+				let n = e.get("highlightedTagId");
+				if (n == null) return;
+				let r = w(t, n);
+				e.set("highlightedTagId", r?.id ?? null);
+			},
+			highlightTag({ context: e, event: t }) {
+				e.set("highlightedTagId", t.id);
+			},
+			highlightTagAtIndex({ context: e, scope: t }) {
+				u(() => {
+					let n = e.get("editedTagIndex");
+					if (n == null) return;
+					let r = T(t, n);
+					r != null && (e.set("highlightedTagId", r.id), e.set("editedTagIndex", null));
+				});
+			},
+			deleteTag({ context: t, scope: n, event: r, refs: i }) {
+				let a = v(n, r.id), o = t.get("value")[a], s = i.get("log");
+				i.set("log", {
+					prev: s.current,
+					current: {
+						type: "delete",
+						value: o
+					}
+				}), t.set("value", (t) => e(t, a));
+			},
+			deleteHighlightedTag({ context: t, scope: n, refs: r }) {
+				let i = t.get("highlightedTagId");
+				if (i == null) return;
+				let a = v(n, i);
+				t.set("editedTagIndex", a);
+				let o = t.get("value"), s = r.get("log");
+				r.set("log", {
+					prev: s.current,
+					current: {
+						type: "delete",
+						value: o[a]
+					}
+				}), t.set("value", (t) => e(t, a));
+			},
+			setEditedId({ context: e, event: t, scope: n }) {
+				let r = e.get("highlightedTagId"), i = t.id ?? r;
+				e.set("editedTagId", i);
+				let a = v(n, i), o = e.get("value")[a];
+				e.set("editedTagIndex", a), e.set("editedTagValue", o);
+			},
+			clearEditedId({ context: e }) {
+				e.set("editedTagId", null);
+			},
+			clearEditedTagValue({ context: e }) {
+				e.set("editedTagValue", "");
+			},
+			setEditedTagValue({ context: e, event: t }) {
+				e.set("editedTagValue", t.value);
+			},
+			submitEditedTagValue({ context: e, scope: t, refs: n, prop: r }) {
+				let i = e.get("editedTagId");
+				if (!i) return;
+				let a = v(t, i), o = e.get("editedTagValue"), s = e.get("value"), c = s.some((e, t) => t !== a && e === o);
+				if (!r("allowDuplicates") && c || s[a] === o) return;
+				e.set("value", (e) => {
+					let t = e.slice();
+					return t[a] = o, t;
+				});
+				let l = n.get("log");
+				n.set("log", {
+					prev: l.current,
+					current: {
+						type: "update",
+						value: o
+					}
+				});
+			},
+			setValueAtIndex({ context: e, event: t, refs: n, prop: i }) {
+				if (t.value) {
+					let r = e.get("value"), a = r.some((e, n) => n !== t.index && e === t.value);
+					if (!i("allowDuplicates") && a || r[t.index] === t.value) return;
+					e.set("value", (e) => {
+						let n = e.slice();
+						return n[t.index] = t.value, n;
+					});
+					let o = n.get("log");
+					n.set("log", {
+						prev: o.current,
+						current: {
+							type: "update",
+							value: t.value
+						}
+					});
+				} else r("You need to provide a value for the tag");
+			},
+			focusEditedTagInput({ context: e, scope: t }) {
+				u(() => {
+					let n = e.get("editedTagId");
+					n && h(t, n)?.select();
+				});
+			},
+			setInputValue({ context: e, event: t }) {
+				e.set("inputValue", t.value);
+			},
+			clearHighlightedId({ context: e }) {
+				e.set("highlightedTagId", null);
+			},
+			focusInput({ scope: e }) {
+				u(() => {
+					y(e)?.focus();
+				});
+			},
+			clearInputValue({ context: e }) {
+				u(() => {
+					e.set("inputValue", "");
+				});
+			},
+			syncInputValue({ context: e, scope: t }) {
+				let n = y(t);
+				n && c(n, e.get("inputValue"));
+			},
+			syncEditedTagInputValue({ context: e, event: t, scope: n }) {
+				let r = e.get("editedTagId") || e.get("highlightedTagId") || t.id;
+				if (r == null) return;
+				let i = h(n, r);
+				i && c(i, e.get("editedTagValue"));
+			},
+			addTag({ context: e, event: n, computed: r, prop: i, refs: a }) {
+				let o = n.value ?? r("trimmedInputValue"), s = e.get("value");
+				if (i("validate")?.({
+					inputValue: o,
+					value: Array.from(s)
+				})) {
+					let n = i("allowDuplicates") ? s.concat(o) : t(s.concat(o));
+					e.set("value", n);
+					let r = a.get("log");
+					a.set("log", {
+						prev: r.current,
+						current: {
+							type: "add",
+							value: o
+						}
+					});
+				} else i("onValueInvalid")?.({ reason: "invalidTag" });
+			},
+			addTagFromPaste({ context: e, computed: n, prop: r, refs: i }) {
+				u(() => {
+					let a = n("trimmedInputValue"), o = e.get("value");
+					if (r("validate")?.({
+						inputValue: a,
+						value: Array.from(o)
+					})) {
+						let n = r("delimiter"), s = n ? a.split(n).map((e) => e.trim()) : [a], c = r("allowDuplicates") ? o.concat(...s) : t(o.concat(...s));
+						e.set("value", c);
+						let l = i.get("log");
+						i.set("log", {
+							prev: l.current,
+							current: {
+								type: "paste",
+								values: s
+							}
+						});
+					} else r("onValueInvalid")?.({ reason: "invalidTag" });
+					e.set("inputValue", "");
+				});
+			},
+			clearTags({ context: e, refs: t }) {
+				e.set("value", []);
+				let n = t.get("log");
+				t.set("log", {
+					prev: n.current,
+					current: { type: "clear" }
+				});
+			},
+			setValue({ context: e, event: t }) {
+				e.set("value", t.value);
+			},
+			invokeOnInvalid({ prop: e, computed: t }) {
+				t("isOverflowing") && e("onValueInvalid")?.({ reason: "rangeOverflow" });
+			},
+			clearLog({ refs: e }) {
+				let t = e.get("log");
+				t.prev = t.current = null;
+			},
+			logHighlightedTag({ refs: e, context: t, scope: n }) {
+				let r = t.get("highlightedTagId"), i = e.get("log");
+				if (r == null || !i.current) return;
+				let a = v(n, r), o = t.get("value")[a], s = e.get("log");
+				e.set("log", {
+					prev: s.current,
+					current: {
+						type: "select",
+						value: o
+					}
+				});
+			},
+			announceLog({ refs: e, prop: t }) {
+				let n = e.get("liveRegion"), r = t("translations"), i = e.get("log");
+				if (!i.current || n == null) return;
+				let a = n, { current: o, prev: s } = i, c;
+				switch (o.type) {
+					case "add":
+						c = r.tagAdded(o.value);
+						break;
+					case "delete":
+						c = r.tagDeleted(o.value);
+						break;
+					case "update":
+						c = r.tagUpdated(o.value);
+						break;
+					case "paste":
+						c = r.tagsPasted(o.values);
+						break;
+					case "select":
+						c = r.tagSelected(o.value), s?.type === "delete" ? c = `${r.tagDeleted(s.value)}. ${c}` : s?.type === "update" && (c = `${r.tagUpdated(s.value)}. ${c}`);
+						break;
+					default: break;
+				}
+				c && a.announce(c);
+			}
+		}
+	}
+});
+//#endregion
+export { A as machine };
+
+//# sourceMappingURL=tags-input.machine.js.map