@isbatak/ark-wheel-picker 0.0.0

package/dist/vue/wheel-picker-root-provider.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vue/wheel-picker-root-provider.ts
+var wheel_picker_root_provider_exports = {};
+__export(wheel_picker_root_provider_exports, {
+  WheelPickerRootProvider: () => WheelPickerRootProvider
+});
+module.exports = __toCommonJS(wheel_picker_root_provider_exports);
+var import_factory = require("@ark-ui/vue/factory");
+var import_vue = require("vue");
+var import_use_wheel_picker_context = require("./use-wheel-picker-context.cjs");
+var WheelPickerRootProvider = (0, import_vue.defineComponent)({
+  name: "WheelPickerRootProvider",
+  props: {
+    asChild: Boolean,
+    value: { type: Object, required: true }
+  },
+  setup(props, { slots }) {
+    (0, import_use_wheel_picker_context.WheelPickerProvider)(props.value);
+    return () => (0, import_vue.h)(import_factory.ark.div, { ...props.value.value.getRootProps(), asChild: props.asChild }, slots);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WheelPickerRootProvider
+});

package/dist/vue/wheel-picker-root-provider.d.cts

@@ -0,0 +1,26 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import { UseWheelPickerReturn } from './use-wheel-picker.cjs';
+import '@isbatak/zag-wheel-picker';
+import '@zag-js/vue';
+import '../types.cjs';
+
+declare const WheelPickerRootProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+    value: {
+        type: PropType<UseWheelPickerReturn>;
+        required: true;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+    value: {
+        type: PropType<UseWheelPickerReturn>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { WheelPickerRootProvider };

package/dist/vue/wheel-picker-root-provider.d.ts

@@ -0,0 +1,26 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import { UseWheelPickerReturn } from './use-wheel-picker.js';
+import '@isbatak/zag-wheel-picker';
+import '@zag-js/vue';
+import '../types.js';
+
+declare const WheelPickerRootProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+    value: {
+        type: PropType<UseWheelPickerReturn>;
+        required: true;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+    value: {
+        type: PropType<UseWheelPickerReturn>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { WheelPickerRootProvider };

package/dist/vue/wheel-picker-root-provider.js

@@ -0,0 +1,18 @@
+// src/vue/wheel-picker-root-provider.ts
+import { ark } from "@ark-ui/vue/factory";
+import { defineComponent, h } from "vue";
+import { WheelPickerProvider } from "./use-wheel-picker-context.js";
+var WheelPickerRootProvider = defineComponent({
+  name: "WheelPickerRootProvider",
+  props: {
+    asChild: Boolean,
+    value: { type: Object, required: true }
+  },
+  setup(props, { slots }) {
+    WheelPickerProvider(props.value);
+    return () => h(ark.div, { ...props.value.value.getRootProps(), asChild: props.asChild }, slots);
+  }
+});
+export {
+  WheelPickerRootProvider
+};

package/dist/vue/wheel-picker-root.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vue/wheel-picker-root.ts
+var wheel_picker_root_exports = {};
+__export(wheel_picker_root_exports, {
+  WheelPickerRoot: () => WheelPickerRoot
+});
+module.exports = __toCommonJS(wheel_picker_root_exports);
+var import_factory = require("@ark-ui/vue/factory");
+var import_vue = require("vue");
+var import_use_wheel_picker = require("./use-wheel-picker.cjs");
+var import_use_wheel_picker_context = require("./use-wheel-picker-context.cjs");
+var booleanProp = { type: Boolean, default: void 0 };
+var WheelPickerRoot = (0, import_vue.defineComponent)({
+  name: "WheelPickerRoot",
+  props: {
+    "aria-label": String,
+    "aria-labelledby": String,
+    asChild: Boolean,
+    collection: { type: Object, required: true },
+    defaultValue: { type: String, default: void 0 },
+    disabled: booleanProp,
+    dragSensitivity: Number,
+    form: String,
+    id: String,
+    ids: Object,
+    infinite: booleanProp,
+    invalid: booleanProp,
+    modelValue: { type: String, default: void 0 },
+    name: String,
+    optionItemHeight: Number,
+    readOnly: booleanProp,
+    required: booleanProp,
+    scrollSensitivity: Number,
+    visibleCount: Number
+  },
+  emits: {
+    valueChange: (_details) => true,
+    valueChangeEnd: (_details) => true,
+    scrollChange: (_details) => true,
+    "update:modelValue": (_value) => true
+  },
+  setup(props, { emit, slots }) {
+    const api = (0, import_use_wheel_picker.useWheelPicker)(() => {
+      const { asChild: _, ...machineProps } = props;
+      return machineProps;
+    }, emit);
+    (0, import_use_wheel_picker_context.WheelPickerProvider)(api);
+    return () => (0, import_vue.h)(import_factory.ark.div, { ...api.value.getRootProps(), asChild: props.asChild }, slots);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WheelPickerRoot
+});

package/dist/vue/wheel-picker-root.d.cts

@@ -0,0 +1,116 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import * as wheelPicker from '@isbatak/zag-wheel-picker';
+
+declare const WheelPickerRoot: vue.DefineComponent<vue.ExtractPropTypes<{
+    "aria-label": StringConstructor;
+    "aria-labelledby": StringConstructor;
+    asChild: BooleanConstructor;
+    collection: {
+        type: PropType<wheelPicker.Props["collection"]>;
+        required: true;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    dragSensitivity: NumberConstructor;
+    form: StringConstructor;
+    id: StringConstructor;
+    ids: PropType<wheelPicker.ElementIds>;
+    infinite: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    name: StringConstructor;
+    optionItemHeight: NumberConstructor;
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    scrollSensitivity: NumberConstructor;
+    visibleCount: NumberConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    valueChange: (_details: wheelPicker.ValueChangeDetails) => true;
+    valueChangeEnd: (_details: wheelPicker.ValueChangeDetails) => true;
+    scrollChange: (_details: wheelPicker.ScrollChangeDetails) => true;
+    "update:modelValue": (_value: string | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    "aria-label": StringConstructor;
+    "aria-labelledby": StringConstructor;
+    asChild: BooleanConstructor;
+    collection: {
+        type: PropType<wheelPicker.Props["collection"]>;
+        required: true;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    dragSensitivity: NumberConstructor;
+    form: StringConstructor;
+    id: StringConstructor;
+    ids: PropType<wheelPicker.ElementIds>;
+    infinite: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    name: StringConstructor;
+    optionItemHeight: NumberConstructor;
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    scrollSensitivity: NumberConstructor;
+    visibleCount: NumberConstructor;
+}>> & Readonly<{
+    onValueChange?: ((_details: wheelPicker.ValueChangeDetails<any>) => any) | undefined;
+    onValueChangeEnd?: ((_details: wheelPicker.ValueChangeDetails<any>) => any) | undefined;
+    onScrollChange?: ((_details: wheelPicker.ScrollChangeDetails<any>) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: string | null) => any) | undefined;
+}>, {
+    defaultValue: string | null;
+    infinite: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    invalid: boolean;
+    required: boolean;
+    modelValue: string | null;
+    asChild: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { WheelPickerRoot };

package/dist/vue/wheel-picker-root.d.ts

@@ -0,0 +1,116 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import * as wheelPicker from '@isbatak/zag-wheel-picker';
+
+declare const WheelPickerRoot: vue.DefineComponent<vue.ExtractPropTypes<{
+    "aria-label": StringConstructor;
+    "aria-labelledby": StringConstructor;
+    asChild: BooleanConstructor;
+    collection: {
+        type: PropType<wheelPicker.Props["collection"]>;
+        required: true;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    dragSensitivity: NumberConstructor;
+    form: StringConstructor;
+    id: StringConstructor;
+    ids: PropType<wheelPicker.ElementIds>;
+    infinite: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    name: StringConstructor;
+    optionItemHeight: NumberConstructor;
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    scrollSensitivity: NumberConstructor;
+    visibleCount: NumberConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    valueChange: (_details: wheelPicker.ValueChangeDetails) => true;
+    valueChangeEnd: (_details: wheelPicker.ValueChangeDetails) => true;
+    scrollChange: (_details: wheelPicker.ScrollChangeDetails) => true;
+    "update:modelValue": (_value: string | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    "aria-label": StringConstructor;
+    "aria-labelledby": StringConstructor;
+    asChild: BooleanConstructor;
+    collection: {
+        type: PropType<wheelPicker.Props["collection"]>;
+        required: true;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    dragSensitivity: NumberConstructor;
+    form: StringConstructor;
+    id: StringConstructor;
+    ids: PropType<wheelPicker.ElementIds>;
+    infinite: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    invalid: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    name: StringConstructor;
+    optionItemHeight: NumberConstructor;
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    scrollSensitivity: NumberConstructor;
+    visibleCount: NumberConstructor;
+}>> & Readonly<{
+    onValueChange?: ((_details: wheelPicker.ValueChangeDetails<any>) => any) | undefined;
+    onValueChangeEnd?: ((_details: wheelPicker.ValueChangeDetails<any>) => any) | undefined;
+    onScrollChange?: ((_details: wheelPicker.ScrollChangeDetails<any>) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: string | null) => any) | undefined;
+}>, {
+    defaultValue: string | null;
+    infinite: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    invalid: boolean;
+    required: boolean;
+    modelValue: string | null;
+    asChild: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { WheelPickerRoot };

package/dist/vue/wheel-picker-root.js

@@ -0,0 +1,47 @@
+// src/vue/wheel-picker-root.ts
+import { ark } from "@ark-ui/vue/factory";
+import { defineComponent, h } from "vue";
+import { useWheelPicker } from "./use-wheel-picker.js";
+import { WheelPickerProvider } from "./use-wheel-picker-context.js";
+var booleanProp = { type: Boolean, default: void 0 };
+var WheelPickerRoot = defineComponent({
+  name: "WheelPickerRoot",
+  props: {
+    "aria-label": String,
+    "aria-labelledby": String,
+    asChild: Boolean,
+    collection: { type: Object, required: true },
+    defaultValue: { type: String, default: void 0 },
+    disabled: booleanProp,
+    dragSensitivity: Number,
+    form: String,
+    id: String,
+    ids: Object,
+    infinite: booleanProp,
+    invalid: booleanProp,
+    modelValue: { type: String, default: void 0 },
+    name: String,
+    optionItemHeight: Number,
+    readOnly: booleanProp,
+    required: booleanProp,
+    scrollSensitivity: Number,
+    visibleCount: Number
+  },
+  emits: {
+    valueChange: (_details) => true,
+    valueChangeEnd: (_details) => true,
+    scrollChange: (_details) => true,
+    "update:modelValue": (_value) => true
+  },
+  setup(props, { emit, slots }) {
+    const api = useWheelPicker(() => {
+      const { asChild: _, ...machineProps } = props;
+      return machineProps;
+    }, emit);
+    WheelPickerProvider(api);
+    return () => h(ark.div, { ...api.value.getRootProps(), asChild: props.asChild }, slots);
+  }
+});
+export {
+  WheelPickerRoot
+};

package/dist/vue/wheel-picker-viewport.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vue/wheel-picker-viewport.ts
+var wheel_picker_viewport_exports = {};
+__export(wheel_picker_viewport_exports, {
+  WheelPickerViewport: () => WheelPickerViewport
+});
+module.exports = __toCommonJS(wheel_picker_viewport_exports);
+var import_factory = require("@ark-ui/vue/factory");
+var import_vue = require("vue");
+var import_use_wheel_picker_context = require("./use-wheel-picker-context.cjs");
+var WheelPickerViewport = (0, import_vue.defineComponent)({
+  name: "WheelPickerViewport",
+  props: {
+    asChild: Boolean
+  },
+  setup(props, { slots }) {
+    const api = (0, import_use_wheel_picker_context.useWheelPickerContext)();
+    return () => (0, import_vue.h)(import_factory.ark.div, { ...api.value.getViewportProps(), asChild: props.asChild }, slots);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WheelPickerViewport
+});

package/dist/vue/wheel-picker-viewport.d.cts

@@ -0,0 +1,13 @@
+import * as vue from 'vue';
+
+declare const WheelPickerViewport: vue.DefineComponent<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { WheelPickerViewport };

package/dist/vue/wheel-picker-viewport.d.ts

@@ -0,0 +1,13 @@
+import * as vue from 'vue';
+
+declare const WheelPickerViewport: vue.DefineComponent<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    asChild: BooleanConstructor;
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { WheelPickerViewport };

package/dist/vue/wheel-picker-viewport.js

@@ -0,0 +1,17 @@
+// src/vue/wheel-picker-viewport.ts
+import { ark } from "@ark-ui/vue/factory";
+import { defineComponent, h } from "vue";
+import { useWheelPickerContext } from "./use-wheel-picker-context.js";
+var WheelPickerViewport = defineComponent({
+  name: "WheelPickerViewport",
+  props: {
+    asChild: Boolean
+  },
+  setup(props, { slots }) {
+    const api = useWheelPickerContext();
+    return () => h(ark.div, { ...api.value.getViewportProps(), asChild: props.asChild }, slots);
+  }
+});
+export {
+  WheelPickerViewport
+};

package/dist/vue/wheel-picker.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vue/wheel-picker.ts
+var wheel_picker_exports = {};
+__export(wheel_picker_exports, {
+  Context: () => import_wheel_picker_context.WheelPickerContext,
+  Control: () => import_wheel_picker_control.WheelPickerControl,
+  HiddenSelect: () => import_wheel_picker_hidden_select.WheelPickerHiddenSelect,
+  Highlight: () => import_wheel_picker_highlight.WheelPickerHighlight,
+  HighlightItem: () => import_wheel_picker_highlight_item.WheelPickerHighlightItem,
+  HighlightItemGroup: () => import_wheel_picker_highlight_item_group.WheelPickerHighlightItemGroup,
+  Item: () => import_wheel_picker_item.WheelPickerItem,
+  ItemGroup: () => import_wheel_picker_item_group.WheelPickerItemGroup,
+  Label: () => import_wheel_picker_label.WheelPickerLabel,
+  Root: () => import_wheel_picker_root.WheelPickerRoot,
+  RootProvider: () => import_wheel_picker_root_provider.WheelPickerRootProvider,
+  Viewport: () => import_wheel_picker_viewport.WheelPickerViewport
+});
+module.exports = __toCommonJS(wheel_picker_exports);
+var import_wheel_picker_context = require("./wheel-picker-context.cjs");
+var import_wheel_picker_control = require("./wheel-picker-control.cjs");
+var import_wheel_picker_hidden_select = require("./wheel-picker-hidden-select.cjs");
+var import_wheel_picker_highlight = require("./wheel-picker-highlight.cjs");
+var import_wheel_picker_highlight_item = require("./wheel-picker-highlight-item.cjs");
+var import_wheel_picker_highlight_item_group = require("./wheel-picker-highlight-item-group.cjs");
+var import_wheel_picker_item = require("./wheel-picker-item.cjs");
+var import_wheel_picker_item_group = require("./wheel-picker-item-group.cjs");
+var import_wheel_picker_label = require("./wheel-picker-label.cjs");
+var import_wheel_picker_root = require("./wheel-picker-root.cjs");
+var import_wheel_picker_root_provider = require("./wheel-picker-root-provider.cjs");
+var import_wheel_picker_viewport = require("./wheel-picker-viewport.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context,
+  Control,
+  HiddenSelect,
+  Highlight,
+  HighlightItem,
+  HighlightItemGroup,
+  Item,
+  ItemGroup,
+  Label,
+  Root,
+  RootProvider,
+  Viewport
+});

package/dist/vue/wheel-picker.d.cts

@@ -0,0 +1,28 @@
+import { CollectionItem, ScrollChangeDetails, ValueChangeDetails } from '@isbatak/zag-wheel-picker';
+export { CollectionItem, ScrollChangeDetails, ValueChangeDetails } from '@isbatak/zag-wheel-picker';
+import './use-wheel-picker.cjs';
+import './use-wheel-picker-context.cjs';
+import { WheelPickerContext } from './wheel-picker-context.cjs';
+import { WheelPickerControl } from './wheel-picker-control.cjs';
+import { WheelPickerHiddenSelect } from './wheel-picker-hidden-select.cjs';
+import { WheelPickerHighlight } from './wheel-picker-highlight.cjs';
+import { WheelPickerHighlightItem } from './wheel-picker-highlight-item.cjs';
+import { WheelPickerHighlightItemGroup } from './wheel-picker-highlight-item-group.cjs';
+import { WheelPickerItem } from './wheel-picker-item.cjs';
+import { WheelPickerItemGroup } from './wheel-picker-item-group.cjs';
+import { WheelPickerLabel } from './wheel-picker-label.cjs';
+import { WheelPickerRoot } from './wheel-picker-root.cjs';
+import { WheelPickerRootProvider } from './wheel-picker-root-provider.cjs';
+import { WheelPickerViewport } from './wheel-picker-viewport.cjs';
+import '@zag-js/vue';
+import 'vue';
+import '../types.cjs';
+
+declare const wheelPicker_CollectionItem: typeof CollectionItem;
+declare const wheelPicker_ScrollChangeDetails: typeof ScrollChangeDetails;
+declare const wheelPicker_ValueChangeDetails: typeof ValueChangeDetails;
+declare namespace wheelPicker {
+  export { wheelPicker_CollectionItem as CollectionItem, WheelPickerContext as Context, WheelPickerControl as Control, WheelPickerHiddenSelect as HiddenSelect, WheelPickerHighlight as Highlight, WheelPickerHighlightItem as HighlightItem, WheelPickerHighlightItemGroup as HighlightItemGroup, WheelPickerItem as Item, WheelPickerItemGroup as ItemGroup, WheelPickerLabel as Label, WheelPickerRoot as Root, WheelPickerRootProvider as RootProvider, wheelPicker_ScrollChangeDetails as ScrollChangeDetails, wheelPicker_ValueChangeDetails as ValueChangeDetails, WheelPickerViewport as Viewport };
+}
+
+export { WheelPickerContext as Context, WheelPickerControl as Control, WheelPickerHiddenSelect as HiddenSelect, WheelPickerHighlight as Highlight, WheelPickerHighlightItem as HighlightItem, WheelPickerHighlightItemGroup as HighlightItemGroup, WheelPickerItem as Item, WheelPickerItemGroup as ItemGroup, WheelPickerLabel as Label, WheelPickerRoot as Root, WheelPickerRootProvider as RootProvider, WheelPickerViewport as Viewport, wheelPicker as w };