@youcan/celeste 0.6.101 → 0.7.0

package/dist/es/chunks/TabsRoot.js

@@ -0,0 +1,102 @@
+import { t as createContext } from "./createContext.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as useDirection } from "./useDirection.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { t as useId } from "./useId.js";
+import { createBlock, defineComponent, openBlock, ref, renderSlot, shallowRef, toRefs, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tabs/TabsRoot.js
+var [injectTabsRootContext, provideTabsRootContext] = /* @__PURE__ */ createContext("TabsRoot");
+var TabsRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "TabsRoot",
+	props: {
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: "horizontal"
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		activationMode: {
+			type: String,
+			required: false,
+			default: "automatic"
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		unmountOnHide: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { orientation, unmountOnHide, dir: propDir } = toRefs(props);
+		const dir = useDirection(propDir);
+		useForwardExpose();
+		const modelValue = useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue,
+			passive: props.modelValue === void 0
+		});
+		const tabsList = ref();
+		const contentIds = shallowRef(/* @__PURE__ */ new Set());
+		provideTabsRootContext({
+			modelValue,
+			changeModelValue: (value) => {
+				modelValue.value = value;
+			},
+			orientation,
+			dir,
+			unmountOnHide,
+			activationMode: props.activationMode,
+			baseId: useId(void 0, "reka-tabs"),
+			tabsList,
+			contentIds,
+			registerContent: (value) => {
+				contentIds.value = new Set([...contentIds.value, value]);
+			},
+			unregisterContent: (value) => {
+				const newSet = new Set(contentIds.value);
+				newSet.delete(value);
+				contentIds.value = newSet;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				dir: unref(dir),
+				"data-orientation": unref(orientation),
+				"as-child": _ctx.asChild,
+				as: _ctx.as
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) })]),
+				_: 3
+			}, 8, [
+				"dir",
+				"data-orientation",
+				"as-child",
+				"as"
+			]);
+		};
+	}
+});
+//#endregion
+export { injectTabsRootContext as n, TabsRoot_default as t };

package/dist/es/chunks/Teleport.js

@@ -0,0 +1,45 @@
+import { a as useMounted } from "./dist.js";
+import { t as injectConfigProviderContext } from "./ConfigProvider.js";
+import { Teleport, computed, createBlock, createCommentVNode, defineComponent, openBlock, renderSlot, unref } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Teleport/Teleport.js
+var Teleport_default = /* @__PURE__ */ defineComponent({
+	__name: "Teleport",
+	props: {
+		to: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		defer: {
+			type: Boolean,
+			required: false
+		},
+		forceMount: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const configContext = injectConfigProviderContext({});
+		const target = computed(() => props.to ?? configContext.teleportTo?.value ?? "body");
+		const isMounted = useMounted();
+		return (_ctx, _cache) => {
+			return unref(isMounted) || _ctx.forceMount ? (openBlock(), createBlock(Teleport, {
+				key: 0,
+				to: target.value,
+				disabled: _ctx.disabled,
+				defer: _ctx.defer
+			}, [renderSlot(_ctx.$slots, "default")], 8, [
+				"to",
+				"disabled",
+				"defer"
+			])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+//#endregion
+export { Teleport_default as t };

package/dist/es/chunks/ToggleGroupRoot.js

@@ -0,0 +1,176 @@
+import { t as isEqual } from "./ohash.D__AXeF1.js";
+import { t as createContext } from "./createContext.js";
+import { t as isValueEqualOrExist } from "./isValueEqualOrExist.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as useDirection } from "./useDirection.js";
+import { t as useFormControl } from "./useFormControl.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { t as VisuallyHiddenInput_default } from "./VisuallyHiddenInput.js";
+import { t as RovingFocusGroup_default } from "./RovingFocusGroup.js";
+import { computed, createBlock, createCommentVNode, createVNode, defineComponent, openBlock, renderSlot, resolveDynamicComponent, toRefs, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useSingleOrMultipleValue.js
+/**
+* Validates the props and it makes sure that the types are coherent with each other
+*
+* 1. If type, defaultValue, and modelValue are all undefined, throw an error.
+* 2. If modelValue and defaultValue are defined and not of the same type, throw an error.
+* 3. If type is defined:
+*    a. If type is 'single' and either modelValue or defaultValue is an array, log an error and return 'multiple'.
+*    b. If type is 'multiple' and neither modelValue nor defaultValue is an array, log an error and return 'single'.
+* 4. Return 'multiple' if modelValue is an array, else return 'single'.
+*/
+function validateProps({ type, defaultValue, modelValue }) {
+	const value = modelValue || defaultValue;
+	if (modelValue !== void 0 || defaultValue !== void 0) return Array.isArray(value) ? "multiple" : "single";
+	else return type ?? "single";
+}
+function getDefaultType({ type, defaultValue, modelValue }) {
+	if (type) return type;
+	return validateProps({
+		type,
+		defaultValue,
+		modelValue
+	});
+}
+function getDefaultValue({ type, defaultValue }) {
+	if (defaultValue !== void 0) return defaultValue;
+	return type === "single" ? void 0 : [];
+}
+function useSingleOrMultipleValue(props, emits) {
+	const type = computed(() => getDefaultType(props));
+	const modelValue = useVModel(props, "modelValue", emits, {
+		defaultValue: getDefaultValue(props),
+		passive: props.modelValue === void 0,
+		deep: true
+	});
+	function changeModelValue(value) {
+		if (type.value === "single") modelValue.value = isEqual(value, modelValue.value) ? void 0 : value;
+		else {
+			const modelValueArray = Array.isArray(modelValue.value) ? [...modelValue.value || []] : [modelValue.value].filter(Boolean);
+			if (isValueEqualOrExist(modelValueArray, value)) {
+				const index = modelValueArray.findIndex((i) => isEqual(i, value));
+				modelValueArray.splice(index, 1);
+			} else modelValueArray.push(value);
+			modelValue.value = modelValueArray;
+		}
+	}
+	return {
+		modelValue,
+		changeModelValue,
+		isSingle: computed(() => type.value === "single")
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/ToggleGroup/ToggleGroupRoot.js
+var [injectToggleGroupRootContext, provideToggleGroupRootContext] = /* @__PURE__ */ createContext("ToggleGroupRoot");
+var ToggleGroupRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "ToggleGroupRoot",
+	props: {
+		rovingFocus: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		orientation: {
+			type: String,
+			required: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		loop: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { loop, rovingFocus, disabled, dir: propDir } = toRefs(props);
+		const dir = useDirection(propDir);
+		const { forwardRef, currentElement } = useForwardExpose();
+		const { modelValue, changeModelValue, isSingle } = useSingleOrMultipleValue(props, emits);
+		const isFormControl = useFormControl(currentElement);
+		provideToggleGroupRootContext({
+			isSingle,
+			modelValue,
+			changeModelValue,
+			dir,
+			orientation: props.orientation,
+			loop,
+			rovingFocus,
+			disabled
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(unref(rovingFocus) ? unref(RovingFocusGroup_default) : unref(Primitive)), {
+				"as-child": "",
+				orientation: unref(rovingFocus) ? _ctx.orientation : void 0,
+				dir: unref(dir),
+				loop: unref(rovingFocus) ? unref(loop) : void 0
+			}, {
+				default: withCtx(() => [createVNode(unref(Primitive), {
+					ref: unref(forwardRef),
+					role: "group",
+					"as-child": _ctx.asChild,
+					as: _ctx.as
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) }), unref(isFormControl) && _ctx.name ? (openBlock(), createBlock(VisuallyHiddenInput_default, {
+						key: 0,
+						name: _ctx.name,
+						required: _ctx.required,
+						value: unref(modelValue)
+					}, null, 8, [
+						"name",
+						"required",
+						"value"
+					])) : createCommentVNode("v-if", true)]),
+					_: 3
+				}, 8, ["as-child", "as"])]),
+				_: 3
+			}, 8, [
+				"orientation",
+				"dir",
+				"loop"
+			]);
+		};
+	}
+});
+//#endregion
+export { injectToggleGroupRootContext as n, ToggleGroupRoot_default as t };

package/dist/es/chunks/TooltipProvider.js

@@ -0,0 +1,75 @@
+import { t as createContext } from "./createContext.js";
+import { y as useTimeoutFn } from "./dist.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { defineComponent, ref, renderSlot, toRefs } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/TooltipProvider.js
+var [injectTooltipProviderContext, provideTooltipProviderContext] = /* @__PURE__ */ createContext("TooltipProvider");
+var TooltipProvider_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "TooltipProvider",
+	props: {
+		delayDuration: {
+			type: Number,
+			required: false,
+			default: 700
+		},
+		skipDelayDuration: {
+			type: Number,
+			required: false,
+			default: 300
+		},
+		disableHoverableContent: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		disableClosingTrigger: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		ignoreNonKeyboardFocus: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		content: {
+			type: Object,
+			required: false
+		}
+	},
+	setup(__props) {
+		const { delayDuration, skipDelayDuration, disableHoverableContent, disableClosingTrigger, ignoreNonKeyboardFocus, disabled, content } = toRefs(__props);
+		useForwardExpose();
+		const isOpenDelayed = ref(true);
+		const isPointerInTransitRef = ref(false);
+		const { start: startTimer, stop: clearTimer } = useTimeoutFn(() => {
+			isOpenDelayed.value = true;
+		}, skipDelayDuration, { immediate: false });
+		provideTooltipProviderContext({
+			isOpenDelayed,
+			delayDuration,
+			onOpen() {
+				clearTimer();
+				isOpenDelayed.value = false;
+			},
+			onClose() {
+				startTimer();
+			},
+			isPointerInTransitRef,
+			disableHoverableContent,
+			disableClosingTrigger,
+			disabled,
+			ignoreNonKeyboardFocus,
+			content
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+//#endregion
+export { injectTooltipProviderContext as n, TooltipProvider_default as t };

package/dist/es/chunks/TooltipRoot.js

@@ -0,0 +1,127 @@
+import { t as createContext } from "./createContext.js";
+import { s as useVModel, y as useTimeoutFn } from "./dist.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { t as PopperRoot_default } from "./PopperRoot.js";
+import { n as injectTooltipProviderContext } from "./TooltipProvider.js";
+import { computed, createBlock, defineComponent, openBlock, ref, renderSlot, unref, watch, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/utils.js
+var TOOLTIP_OPEN = "tooltip.open";
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tooltip/TooltipRoot.js
+var [injectTooltipRootContext, provideTooltipRootContext] = /* @__PURE__ */ createContext("TooltipRoot");
+var TooltipRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "TooltipRoot",
+	props: {
+		defaultOpen: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		delayDuration: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		disableHoverableContent: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		disableClosingTrigger: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		ignoreNonKeyboardFocus: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		}
+	},
+	emits: ["update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		useForwardExpose();
+		const providerContext = injectTooltipProviderContext();
+		const disableHoverableContent = computed(() => props.disableHoverableContent ?? providerContext.disableHoverableContent.value);
+		const disableClosingTrigger = computed(() => props.disableClosingTrigger ?? providerContext.disableClosingTrigger.value);
+		const disableTooltip = computed(() => props.disabled ?? providerContext.disabled.value);
+		const delayDuration = computed(() => props.delayDuration ?? providerContext.delayDuration.value);
+		const ignoreNonKeyboardFocus = computed(() => props.ignoreNonKeyboardFocus ?? providerContext.ignoreNonKeyboardFocus.value);
+		const open = useVModel(props, "open", emit, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		watch(open, (isOpen) => {
+			if (!providerContext.onClose) return;
+			if (isOpen) {
+				providerContext.onOpen();
+				document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+			} else providerContext.onClose();
+		});
+		const wasOpenDelayedRef = ref(false);
+		const trigger = ref();
+		const stateAttribute = computed(() => {
+			if (!open.value) return "closed";
+			return wasOpenDelayedRef.value ? "delayed-open" : "instant-open";
+		});
+		const { start: startTimer, stop: clearTimer } = useTimeoutFn(() => {
+			wasOpenDelayedRef.value = true;
+			open.value = true;
+		}, delayDuration, { immediate: false });
+		function handleOpen() {
+			clearTimer();
+			wasOpenDelayedRef.value = false;
+			open.value = true;
+		}
+		function handleClose() {
+			clearTimer();
+			open.value = false;
+		}
+		function handleDelayedOpen() {
+			startTimer();
+		}
+		provideTooltipRootContext({
+			contentId: "",
+			open,
+			stateAttribute,
+			trigger,
+			onTriggerChange(el) {
+				trigger.value = el;
+			},
+			onTriggerEnter() {
+				if (providerContext.isOpenDelayed.value) handleDelayedOpen();
+				else handleOpen();
+			},
+			onTriggerLeave() {
+				if (disableHoverableContent.value) handleClose();
+				else clearTimer();
+			},
+			onOpen: handleOpen,
+			onClose: handleClose,
+			disableHoverableContent,
+			disableClosingTrigger,
+			disabled: disableTooltip,
+			ignoreNonKeyboardFocus
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(PopperRoot_default), null, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { open: unref(open) })]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+export { injectTooltipRootContext as n, TOOLTIP_OPEN as r, TooltipRoot_default as t };

package/dist/es/chunks/VisuallyHidden.js

@@ -0,0 +1,59 @@
+import { t as Primitive } from "./Primitive.js";
+import { createBlock, defineComponent, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/VisuallyHidden/VisuallyHidden.js
+var VisuallyHidden_default = /* @__PURE__ */ defineComponent({
+	__name: "VisuallyHidden",
+	props: {
+		feature: {
+			type: String,
+			required: false,
+			default: "focusable"
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "span"
+		}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				as: _ctx.as,
+				"as-child": _ctx.asChild,
+				"aria-hidden": _ctx.feature === "focusable" || _ctx.feature === "fully-hidden" ? "true" : void 0,
+				"data-hidden": _ctx.feature === "fully-hidden" ? "" : void 0,
+				tabindex: _ctx.feature === "fully-hidden" ? "-1" : void 0,
+				style: {
+					position: "absolute",
+					border: 0,
+					width: "1px",
+					height: "1px",
+					padding: 0,
+					margin: "-1px",
+					overflow: "hidden",
+					clip: "rect(0, 0, 0, 0)",
+					clipPath: "inset(50%)",
+					whiteSpace: "nowrap",
+					wordWrap: "normal",
+					top: "-1px",
+					left: "-1px"
+				}
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"aria-hidden",
+				"data-hidden",
+				"tabindex"
+			]);
+		};
+	}
+});
+//#endregion
+export { VisuallyHidden_default as t };