@sprawlify/vue 0.0.64 → 0.0.66

package/dist/fieldset-DzhN7Zrg.js

@@ -0,0 +1,278 @@
+import { t as __exportAll } from "./chunk-BN_g-Awi.js";
+import { c as useEnvironmentContext, s as DEFAULT_ENVIRONMENT } from "./providers-B2CNPFg1.js";
+import { n as unrefElement, r as createContext, t as useForwardExpose } from "./use-forward-expose-4p5AGAI3.js";
+import { t as sprawlify } from "./factory-BH3WrWd2.js";
+import { computed, createBlock, createCommentVNode, defineComponent, guardReactiveProps, mergeDefaults, mergeProps, normalizeProps, onBeforeUnmount, onMounted, openBlock, reactive, ref, renderSlot, toValue, unref, useId, withCtx } from "vue";
+import { dataAttr } from "@sprawlify/primitives/dom-query";
+import { createAnatomy } from "@sprawlify/primitives/anatomy";
+
+//#region src/components/fieldset/use-fieldset-context.ts
+const [FieldsetProvider, useFieldsetContext] = createContext("FieldsetContext");
+
+//#endregion
+//#region src/components/fieldset/fieldset-context.vue?vue&type=script&setup=true&lang.ts
+var fieldset_context_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "fieldset-context",
+	setup(__props) {
+		const fieldset = useFieldsetContext();
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(fieldset))));
+		};
+	}
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset-context.vue
+var fieldset_context_default = fieldset_context_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/fieldset/fieldset-error-text.vue?vue&type=script&setup=true&lang.ts
+var fieldset_error_text_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "fieldset-error-text",
+	props: { asChild: {
+		type: Boolean,
+		required: false
+	} },
+	setup(__props) {
+		const fieldset = useFieldsetContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return unref(fieldset).invalid ? (openBlock(), createBlock(unref(sprawlify).span, mergeProps({ key: 0 }, unref(fieldset).getErrorTextProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"])) : createCommentVNode("v-if", true);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset-error-text.vue
+var fieldset_error_text_default = fieldset_error_text_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/fieldset/fieldset-helper-text.vue?vue&type=script&setup=true&lang.ts
+var fieldset_helper_text_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "fieldset-helper-text",
+	props: { asChild: {
+		type: Boolean,
+		required: false
+	} },
+	setup(__props) {
+		const fieldset = useFieldsetContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).span, mergeProps(unref(fieldset).getHelperTextProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset-helper-text.vue
+var fieldset_helper_text_default = fieldset_helper_text_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/fieldset/fieldset-legend.vue?vue&type=script&setup=true&lang.ts
+var fieldset_legend_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "fieldset-legend",
+	props: { asChild: {
+		type: Boolean,
+		required: false
+	} },
+	setup(__props) {
+		const fieldset = useFieldsetContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).legend, mergeProps(unref(fieldset).getLegendProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset-legend.vue
+var fieldset_legend_default = fieldset_legend_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/fieldset/fieldset-root-provider.vue?vue&type=script&setup=true&lang.ts
+var fieldset_root_provider_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "fieldset-root-provider",
+	props: {
+		value: {
+			type: null,
+			required: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const fieldset = computed(() => props.value);
+		FieldsetProvider(fieldset);
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).fieldset, mergeProps(fieldset.value.getRootProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset-root-provider.vue
+var fieldset_root_provider_default = fieldset_root_provider_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/fieldset/fieldset-anatomy.ts
+const fieldsetAnatomy = createAnatomy("fieldset").parts("root", "errorText", "helperText", "legend");
+const parts = fieldsetAnatomy.build();
+
+//#endregion
+//#region src/components/fieldset/use-fieldset.ts
+const useFieldset = (props = {}) => {
+	const env = useEnvironmentContext(DEFAULT_ENVIRONMENT);
+	const state = reactive({
+		hasErrorText: false,
+		hasHelperText: false
+	});
+	const rootRef = ref(null);
+	const uuid = useId();
+	const ids = computed(() => {
+		const id = toValue(props).id ?? uuid;
+		return {
+			legendId: `fieldset::${id}::legend`,
+			errorTextId: `fieldset::${id}::error-text`,
+			helperTextId: `fieldset::${id}::helper-text`
+		};
+	});
+	onMounted(() => {
+		const rootNode = unrefElement(rootRef);
+		if (!rootNode) return;
+		const checkTextElements = () => {
+			const { errorTextId, helperTextId } = ids.value;
+			const docOrShadowRoot = env.value.getRootNode();
+			state.hasErrorText = !!docOrShadowRoot.getElementById(errorTextId);
+			state.hasHelperText = !!docOrShadowRoot.getElementById(helperTextId);
+		};
+		checkTextElements();
+		const observer = new (env.value.getWindow()).MutationObserver(checkTextElements);
+		observer.observe(rootNode, {
+			childList: true,
+			subtree: true
+		});
+		onBeforeUnmount(() => {
+			observer.disconnect();
+		});
+	});
+	return computed(() => {
+		const { disabled, invalid } = toValue(props);
+		const { legendId, errorTextId, helperTextId } = ids.value;
+		const describedByIds = [];
+		if (state.hasErrorText && invalid) describedByIds.push(errorTextId);
+		if (state.hasHelperText) describedByIds.push(helperTextId);
+		const describedBy = describedByIds.length > 0 ? describedByIds.join(" ") : void 0;
+		const getRootProps = () => ({
+			...parts.root.attrs,
+			disabled,
+			"data-disabled": dataAttr(!!disabled),
+			"data-invalid": dataAttr(invalid),
+			"aria-labelledby": legendId,
+			"aria-describedby": describedBy
+		});
+		const getLegendProps = () => ({
+			id: legendId,
+			...parts.legend.attrs,
+			"data-disabled": dataAttr(!!disabled),
+			"data-invalid": dataAttr(invalid)
+		});
+		const getHelperTextProps = () => ({
+			id: helperTextId,
+			...parts.helperText.attrs
+		});
+		const getErrorTextProps = () => ({
+			id: errorTextId,
+			...parts.errorText.attrs,
+			"aria-live": "polite"
+		});
+		return {
+			refs: { rootRef },
+			ids: {
+				legend: legendId,
+				errorText: errorTextId,
+				helperText: helperTextId
+			},
+			disabled,
+			invalid,
+			getRootProps,
+			getLegendProps,
+			getHelperTextProps,
+			getErrorTextProps
+		};
+	});
+};
+
+//#endregion
+//#region src/components/fieldset/fieldset-root.vue?vue&type=script&setup=true&lang.ts
+var fieldset_root_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "fieldset-root",
+	props: /* @__PURE__ */ mergeDefaults({
+		disabled: {
+			type: [Boolean, String],
+			required: false
+		},
+		id: {
+			type: String,
+			required: false
+		},
+		invalid: {
+			type: Boolean,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		}
+	}, {
+		disabled: void 0,
+		invalid: void 0
+	}),
+	setup(__props) {
+		const fieldset = useFieldset(__props);
+		FieldsetProvider(fieldset);
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(sprawlify).fieldset, mergeProps(unref(fieldset).getRootProps(), {
+				ref: unref(fieldset).refs.rootRef,
+				"as-child": __props.asChild
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset-root.vue
+var fieldset_root_default = fieldset_root_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+//#region src/components/fieldset/fieldset.ts
+var fieldset_exports = /* @__PURE__ */ __exportAll({
+	Context: () => fieldset_context_default,
+	ErrorText: () => fieldset_error_text_default,
+	HelperText: () => fieldset_helper_text_default,
+	Legend: () => fieldset_legend_default,
+	Root: () => fieldset_root_default,
+	RootProvider: () => fieldset_root_provider_default
+});
+
+//#endregion
+export { fieldset_root_provider_default as a, fieldset_error_text_default as c, fieldsetAnatomy as i, fieldset_context_default as l, fieldset_root_default as n, fieldset_legend_default as o, useFieldset as r, fieldset_helper_text_default as s, fieldset_exports as t, useFieldsetContext as u };

package/dist/index-B66Om_3U.d.ts

@@ -0,0 +1,22 @@
+import { Machine, MachineSchema, Service, mergeProps as mergeProps$1 } from "@sprawlify/primitives/core";
+import * as _sprawlify_primitives_types0 from "@sprawlify/primitives/types";
+import * as Vue from "vue";
+import { ComputedRef, Ref } from "vue";
+
+//#region src/core/normalize-props.d.ts
+type ReservedProps = {
+  key?: string | number | symbol | undefined;
+  ref?: Vue.VNodeRef | undefined;
+};
+type Attrs<T> = T & ReservedProps;
+type PropTypes = Vue.NativeElements & {
+  element: Attrs<Vue.HTMLAttributes>;
+  style: Vue.CSSProperties;
+};
+declare const normalizeProps$1: _sprawlify_primitives_types0.NormalizeProps<PropTypes>;
+//#endregion
+//#region src/core/machine.d.ts
+type MaybeRef$1<T> = T | Ref<T> | ComputedRef<T>;
+declare function useMachine<T extends MachineSchema>(machine: Machine<T>, userProps?: MaybeRef$1<Partial<T["props"]>>): Service<T>;
+//#endregion
+export { normalizeProps$1 as i, useMachine as n, PropTypes as r, mergeProps$1 as t };

package/dist/index-DqRk-Yea.d.ts

@@ -0,0 +1,199 @@
+import { ComputedRef, MaybeRef, Ref } from "vue";
+import { CollectionItem, CollectionItem as CollectionItem$1, CollectionOptions, FilePathTreeNode, FilePathTreeNode as FilePathTreeNode$1, FlatTreeNode, GridCollection as GridCollection$1, GridCollectionOptions, ListCollection as ListCollection$1, SelectionMode, TreeCollection, TreeCollection as TreeCollection$1, TreeCollectionOptions, TreeCollectionOptions as TreeCollectionOptions$1, TreeNode, TreeNode as TreeNode$1 } from "@sprawlify/primitives/collection";
+import * as asyncList from "@sprawlify/primitives/machines/async-list";
+
+//#region src/components/collection/grid-collection.d.ts
+declare const createGridCollection: <T extends CollectionItem$1>(options: GridCollectionOptions<T>) => GridCollection$1<T>;
+//#endregion
+//#region src/components/collection/list-collection.d.ts
+declare const createListCollection: <T extends CollectionItem>(options: CollectionOptions<T>) => ListCollection$1<T>;
+//#endregion
+//#region src/components/collection/tree-collection.d.ts
+declare const createTreeCollection: <T extends TreeNode>(options: TreeCollectionOptions<T>) => TreeCollection<T>;
+declare const createFileTreeCollection: (paths: string[]) => TreeCollection<FilePathTreeNode>;
+//#endregion
+//#region src/components/collection/use-async-list.d.ts
+interface UseAsyncListProps<T, C = string> extends asyncList.Props<T, C> {}
+interface UseAsyncListReturn<T, C = string> extends ComputedRef<asyncList.Api<T, C>> {}
+declare const useAsyncList: <T, C = string>(props?: MaybeRef<UseAsyncListProps<T, C>>) => UseAsyncListReturn<T, C>;
+//#endregion
+//#region src/components/collection/use-list-collection.d.ts
+interface UseListCollectionProps<T> extends Omit<CollectionOptions<T>, 'items'> {
+  /**
+   * The initial items to display in the collection.
+   */
+  initialItems: T[] | readonly T[];
+  /**
+   * The filter function to use to filter the items.
+   */
+  filter?: (itemText: string, filterText: string, item: T) => boolean;
+  /**
+   * The maximum number of items to display in the collection.
+   * Useful for performance when you have a large number of items.
+   */
+  limit?: number;
+}
+declare function useListCollection<T>(props: MaybeRef<UseListCollectionProps<T>>): UseListCollectionReturn<T>;
+interface UseListCollectionReturn<T> {
+  /**
+   * The collection of items.
+   */
+  collection: Ref<ListCollection$1<T>>;
+  /**
+   * The function to filter the items.
+   */
+  filter: (inputValue: string) => void;
+  /**
+   * The function to set the items.
+   */
+  set: (items: T[]) => void;
+  /**
+   * The function to reset the items.
+   */
+  reset: () => void;
+  /**
+   * The function to clear the items.
+   */
+  clear: () => void;
+  /**
+   * The function to insert items at a specific index.
+   */
+  insert: (index: number, ...items: T[]) => void;
+  /**
+   * The function to insert items before a specific value.
+   */
+  insertBefore: (value: string, ...items: T[]) => void;
+  /**
+   * The function to insert items after a specific value.
+   */
+  insertAfter: (value: string, ...items: T[]) => void;
+  /**
+   * The function to remove items.
+   */
+  remove: (...itemOrValues: Array<T | string>) => void;
+  /**
+   * The function to move an item to a specific index.
+   */
+  move: (value: string, to: number) => void;
+  /**
+   * The function to move an item before a specific value.
+   */
+  moveBefore: (value: string, ...values: string[]) => void;
+  /**
+   * The function to move an item after a specific value.
+   */
+  moveAfter: (value: string, ...values: string[]) => void;
+  /**
+   * The function to reorder items.
+   */
+  reorder: (from: number, to: number) => void;
+  /**
+   * The function to append items.
+   */
+  append: (...items: T[]) => void;
+  /**
+   * The function to upsert an item.
+   */
+  upsert: (value: string, item: T, mode?: 'append' | 'prepend') => void;
+  /**
+   * The function to prepend items.
+   */
+  prepend: (...items: T[]) => void;
+  /**
+   * The function to update an item.
+   */
+  update: (value: string, item: T) => void;
+}
+//#endregion
+//#region src/components/collection/use-list-selection.d.ts
+interface UseListSelectionProps<T extends CollectionItem> {
+  /**
+   * The selection mode.
+   */
+  selectionMode?: SelectionMode;
+  /**
+   * Whether the selection is deselectable.
+   */
+  deselectable?: boolean;
+  /**
+   * The initial selected values.
+   */
+  initialSelectedValues?: string[];
+  /**
+   * Whether to reset the selection when the collection changes.
+   */
+  resetOnCollectionChange?: boolean;
+  /**
+   * The collection to use.
+   */
+  collection: ListCollection$1<T>;
+}
+declare function useListSelection<T extends CollectionItem>(props: MaybeRef<UseListSelectionProps<T>>): UseListSelectionReturn;
+interface UseListSelectionReturn {
+  /**
+   * The selected values as an array.
+   */
+  selectedValues: Ref<string[]>;
+  /**
+   * Whether the selection is empty.
+   */
+  isEmpty: Ref<boolean>;
+  /**
+   * The first selected value.
+   */
+  firstSelectedValue: Ref<string | null>;
+  /**
+   * The last selected value.
+   */
+  lastSelectedValue: Ref<string | null>;
+  /**
+   * Check if a value is selected.
+   */
+  isSelected: (value: string | null) => boolean;
+  /**
+   * Check if a value can be selected.
+   */
+  canSelect: (value: string) => boolean;
+  /**
+   * Select a value.
+   */
+  select: (value: string, forceToggle?: boolean) => void;
+  /**
+   * Deselect a value.
+   */
+  deselect: (value: string) => void;
+  /**
+   * Toggle selection of a value.
+   */
+  toggle: (value: string) => void;
+  /**
+   * Replace the selection with a single value.
+   */
+  replace: (value: string | null) => void;
+  /**
+   * Extend the selection from anchor to target.
+   */
+  extend: (anchorValue: string, targetValue: string) => void;
+  /**
+   * Set the selected values.
+   */
+  setSelectedValues: (values: string[]) => void;
+  /**
+   * Clear the selection.
+   */
+  clear: () => void;
+  /**
+   * Clear all selections.
+   */
+  resetSelection: () => void;
+  /**
+   * Returns true if all items from the collection are selected.
+   */
+  isAllSelected: () => boolean;
+  /**
+   * Returns true if at least one item from the collection is selected.
+   */
+  isSomeSelected: () => boolean;
+}
+//#endregion
+export { createGridCollection as C, GridCollectionOptions as S, CollectionItem as _, UseListCollectionReturn as a, createListCollection as b, UseAsyncListReturn as c, FlatTreeNode as d, TreeCollection$1 as f, createTreeCollection as g, createFileTreeCollection as h, UseListCollectionProps as i, useAsyncList as l, TreeNode$1 as m, UseListSelectionReturn as n, useListCollection as o, TreeCollectionOptions$1 as p, useListSelection as r, UseAsyncListProps as s, UseListSelectionProps as t, FilePathTreeNode$1 as u, CollectionOptions as v, GridCollection$1 as x, ListCollection$1 as y };

package/dist/index-rHf4D8np.d.ts

@@ -0,0 +1,57 @@
+import { t as PolymorphicProps } from "./factory-D_ge_w76.js";
+import { n as RootProps, t as RootEmits } from "./presence-types-Bv1E60Cw.js";
+import { a as Optional, r as EmitFn$1 } from "./types-Bj-dS2Hc.js";
+import * as vue13 from "vue";
+import { HTMLAttributes, MaybeRef } from "vue";
+import * as presence from "@sprawlify/primitives/machines/presence";
+
+//#region src/components/presence/presence.vue.d.ts
+interface PresenceBaseProps extends RootProps, PolymorphicProps {}
+interface PresenceProps extends PresenceBaseProps,
+/**
+ * @vue-ignore
+ */
+HTMLAttributes {}
+interface PresenceEmits extends RootEmits {}
+declare const _default: typeof __VLS_export;
+declare const __VLS_export: __VLS_WithSlots<vue13.DefineComponent<PresenceProps, {}, {}, {}, {}, vue13.ComponentOptionsMixin, vue13.ComponentOptionsMixin, {
+  exitComplete: () => any;
+}, string, vue13.PublicProps, Readonly<PresenceProps> & Readonly<{
+  onExitComplete?: (() => any) | undefined;
+}>, {
+  immediate: boolean;
+  lazyMount: boolean;
+  present: boolean;
+  skipAnimationOnMount: boolean;
+  unmountOnExit: boolean;
+}, {}, {}, {}, string, vue13.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/presence/use-presence.d.ts
+interface UsePresenceProps extends Optional<presence.Props, 'present'> {
+  lazyMount?: boolean;
+  unmountOnExit?: boolean;
+  skipAnimationOnMount?: boolean;
+}
+type UsePresenceReturn = ReturnType<typeof usePresence>;
+declare const usePresence: (props: MaybeRef<UsePresenceProps>, emit?: EmitFn$1<RootEmits>) => vue13.ComputedRef<{
+  present: boolean;
+  unmounted: boolean | undefined;
+  presenceProps: {
+    ref: vue13.Ref<any, any>;
+    hidden: boolean;
+    'data-state': string | undefined;
+  };
+}>;
+//#endregion
+//#region src/components/presence/use-presence-context.d.ts
+interface UsePresenceContext extends UsePresenceReturn {}
+declare const PresenceProvider: (opts: UsePresenceContext) => void, usePresenceContext: (fallback?: UsePresenceContext | undefined) => UsePresenceContext;
+//#endregion
+export { UsePresenceReturn as a, PresenceProps as c, UsePresenceProps as i, _default as l, UsePresenceContext as n, usePresence as o, usePresenceContext as r, PresenceEmits as s, PresenceProvider as t };

package/dist/index.d.ts

@@ -1,25 +1,9 @@
-import { Machine, MachineSchema, Service, mergeProps } from "@sprawlify/primitives/core";
-import * as _sprawlify_primitives_types0 from "@sprawlify/primitives/types";
-import * as Vue from "vue";
-import { ComponentPublicInstance, ComputedRef, MaybeRef, MaybeRefOrGetter, Ref, UnwrapRef } from "vue";
+import { a as Optional, i as MaybePromise, n as BooleanDefaults, r as EmitFn, t as Assign } from "./types-Bj-dS2Hc.js";
+import { i as normalizeProps, n as useMachine, r as PropTypes, t as mergeProps } from "./index-B66Om_3U.js";
+import * as vue8 from "vue";
+import { ComponentPublicInstance, ComputedRef, MaybeRef, MaybeRefOrGetter, UnwrapRef } from "vue";
 import { FilterOptions, FilterReturn, Locale } from "@sprawlify/primitives/i18n-utils";
 
-//#region src/core/normalize-props.d.ts
-type ReservedProps = {
-  key?: string | number | symbol | undefined;
-  ref?: Vue.VNodeRef | undefined;
-};
-type Attrs<T> = T & ReservedProps;
-type PropTypes = Vue.NativeElements & {
-  element: Attrs<Vue.HTMLAttributes>;
-  style: Vue.CSSProperties;
-};
-declare const normalizeProps: _sprawlify_primitives_types0.NormalizeProps<PropTypes>;
-//#endregion
-//#region src/core/machine.d.ts
-type MaybeRef$1<T> = T | Ref<T> | ComputedRef<T>;
-declare function useMachine<T extends MachineSchema>(machine: Machine<T>, userProps?: MaybeRef$1<Partial<T["props"]>>): Service<T>;
-//#endregion
 //#region src/providers/environment/use-environment-context.d.ts
 type RootNode = ShadowRoot | Document | Node;
 interface UseEnvironmentContext {
@@ -47,7 +31,7 @@ declare var __VLS_1: {};
 type __VLS_Slots = {} & {
   default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_base: Vue.DefineComponent<EnvironmentProviderProps, {}, {}, {}, {}, Vue.ComponentOptionsMixin, Vue.ComponentOptionsMixin, {}, string, Vue.PublicProps, Readonly<EnvironmentProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, Vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: vue8.DefineComponent<EnvironmentProviderProps, {}, {}, {}, {}, vue8.ComponentOptionsMixin, vue8.ComponentOptionsMixin, {}, string, vue8.PublicProps, Readonly<EnvironmentProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue8.ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export$1;
 type __VLS_WithSlots$1<T, S> = T & {
@@ -61,7 +45,7 @@ interface LocaleProviderProps {
   locale: string;
 }
 declare const _default$1: typeof __VLS_export;
-declare const __VLS_export: __VLS_WithSlots<Vue.DefineComponent<LocaleProviderProps, {}, {}, {}, {}, Vue.ComponentOptionsMixin, Vue.ComponentOptionsMixin, {}, string, Vue.PublicProps, Readonly<LocaleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, Vue.ComponentProvideOptions, false, {}, any>, {
+declare const __VLS_export: __VLS_WithSlots<vue8.DefineComponent<LocaleProviderProps, {}, {}, {}, {}, vue8.ComponentOptionsMixin, vue8.ComponentOptionsMixin, {}, string, vue8.PublicProps, Readonly<LocaleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue8.ComponentProvideOptions, false, {}, any>, {
   default?: (props: {}) => any;
 }>;
 type __VLS_WithSlots<T, S> = T & {
@@ -86,14 +70,6 @@ interface UseFilterReturn extends ComputedRef<FilterReturn> {}
 interface LocaleContext extends Locale {}
 declare const DEFAULT_LOCALE: ComputedRef<LocaleContext>;
 //#endregion
-//#region src/types.d.ts
-type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
-type Assign<T, U> = Omit<T, keyof U> & U;
-type EmitFn<T> = <K extends keyof T>(event: K, ...args: T[K] extends any[] ? T[K] : never) => void;
-type BooleanKey<T> = { [K in keyof T]: boolean extends NonNullable<T[K]> ? K : never }[keyof T];
-type BooleanDefaults<T> = { [K in BooleanKey<T>]: undefined };
-type MaybePromise<T> = T | Promise<T>;
-//#endregion
 //#region src/utils/create-context.d.ts
 type CreateContextReturn<T> = [(opts: T) => void, (fallback?: T) => T, symbol];
 declare const createContext: <T>(id: string) => CreateContextReturn<T>;
@@ -104,14 +80,14 @@ declare function useEmitAsProps<Name extends string>(emit: (name: Name, ...args:
 //#region src/utils/use-forward-expose.d.ts
 declare function useForwardExpose(): {
   forwardRef: (ref: Element | ComponentPublicInstance | null) => void;
-  currentRef: Vue.Ref<Element | ComponentPublicInstance | null | undefined, Element | ComponentPublicInstance | null | undefined>;
-  currentElement: Vue.ComputedRef<HTMLElement>;
+  currentRef: vue8.Ref<Element | ComponentPublicInstance | null | undefined, Element | ComponentPublicInstance | null | undefined>;
+  currentElement: vue8.ComputedRef<HTMLElement>;
 };
 //#endregion
 //#region src/utils/use-forward-props.d.ts
-declare function useForwardProps<T extends MaybeRefOrGetter<Record<string, any>>, U extends UnwrapRef<T>>(props: T): Vue.ComputedRef<U>;
+declare function useForwardProps<T extends MaybeRefOrGetter<Record<string, any>>, U extends UnwrapRef<T>>(props: T): vue8.ComputedRef<U>;
 //#endregion
 //#region src/utils/use-forward-props-emits.d.ts
-declare function useForwardPropsEmits<T extends Parameters<typeof useForwardProps>[0], Name extends string>(props: T, emit?: (name: Name, ...args: any[]) => void): Vue.ComputedRef<any>;
+declare function useForwardPropsEmits<T extends Parameters<typeof useForwardProps>[0], Name extends string>(props: T, emit?: (name: Name, ...args: any[]) => void): vue8.ComputedRef<any>;
 //#endregion
 export { Assign, BooleanDefaults, DEFAULT_ENVIRONMENT, DEFAULT_LOCALE, EmitFn, _default as EnvironmentProvider, type EnvironmentProviderProps, type LocaleContext, _default$1 as LocaleProvider, type LocaleProviderProps, MaybePromise, Optional, PropTypes, type RootNode, type UseCollatorProps, type UseCollatorReturn, type UseEnvironmentContext, type UseFilterProps, type UseFilterReturn, createContext, mergeProps, normalizeProps, useCollator, useEmitAsProps, useEnvironmentContext, useFilter, useForwardExpose, useForwardProps, useForwardPropsEmits, useLocaleContext, useMachine };