@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/picker-view/PickerView.vue.d.ts

@@ -0,0 +1,27 @@
+import type { PickerValue, PickerViewProps, PickerViewSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = PickerViewSlots;
+declare const __VLS_base: import("vue").DefineComponent<PickerViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: PickerValue[], info: import("./interface").PickerChangeInfo) => any;
+    "update:value": (value: PickerValue[]) => any;
+}, string, import("vue").PublicProps, Readonly<PickerViewProps> & Readonly<{
+    onChange?: ((value: PickerValue[], info: import("./interface").PickerChangeInfo) => any) | undefined;
+    "onUpdate:value"?: ((value: PickerValue[]) => any) | undefined;
+}>, {
+    loading: boolean;
+    itemHeight: number;
+    visibleItemCount: number;
+    virtual: boolean;
+    optionRender: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PickerOptionRenderInfo) => import("vue").VNodeChild) | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/picker-view/PickerView.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,118 @@
+import Spinner_default from "../_base/Spinner.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import PickerViewColumn_default from "./PickerViewColumn.js";
+import { resolvePicker } from "./util.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, createSlots, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, renderList, renderSlot, unref, withCtx } from "vue";
+// src/picker-view/PickerView.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	class: "am-picker-view-spin"
+};
+var _hoisted_2 = { class: "am-picker-view-columns" };
+var PickerView_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmPickerView",
+	inheritAttrs: false,
+	__name: "PickerView",
+	props: {
+		columns: {},
+		fieldNames: {},
+		value: {},
+		defaultValue: {},
+		loading: {
+			type: Boolean,
+			default: false
+		},
+		itemHeight: { default: 40 },
+		visibleItemCount: { default: 5 },
+		optionRender: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		virtual: {
+			type: Boolean,
+			default: true
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["update:value", "change"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const [innerValue, setInnerValue] = useControlled(props, "value", { defaultValue: () => props.defaultValue ?? [] });
+		const resolved = computed(() => resolvePicker(props.columns, innerValue.value, props.fieldNames));
+		function onColumnChange(columnIndex, value) {
+			const next = resolved.value.value.slice();
+			next[columnIndex] = value;
+			const result = resolvePicker(props.columns, next, props.fieldNames);
+			setInnerValue(result.value);
+			emit("update:value", result.value);
+			emit("change", result.value, {
+				items: result.items,
+				columnIndex
+			});
+		}
+		const rootStyle = computed(() => [{
+			"--am-picker-view-item-height": `${props.itemHeight}px`,
+			"--am-picker-view-visible-count": String(props.visibleItemCount)
+		}, props.styles?.root]);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+				class: ["am-picker-view", [
+					{ "am-picker-view-loading": __props.loading },
+					__props.rootClass,
+					__props.classes?.root
+				]],
+				style: rootStyle.value
+			}), [__props.loading ? (openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "loading", {}, () => [createVNode(unref(Spinner_default))])])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createElementVNode("div", {
+				class: normalizeClass(["am-picker-view-indicator", __props.classes?.indicator]),
+				style: normalizeStyle(__props.styles?.indicator)
+			}, null, 6), createElementVNode("div", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(resolved.value.columns, (column, index) => {
+				return openBlock(), createBlock(PickerViewColumn_default, {
+					key: index,
+					class: normalizeClass(__props.classes?.column),
+					style: normalizeStyle(__props.styles?.column),
+					options: column,
+					value: resolved.value.value[index],
+					"column-index": index,
+					"item-height": __props.itemHeight,
+					"visible-item-count": __props.visibleItemCount,
+					"option-render": __props.optionRender,
+					virtual: __props.virtual,
+					"item-class": __props.classes?.item,
+					"item-style": __props.styles?.item,
+					onChange: ($event) => onColumnChange(index, $event)
+				}, createSlots({ _: 2 }, [_ctx.$slots.option ? {
+					name: "option",
+					fn: withCtx((info) => [renderSlot(_ctx.$slots, "option", mergeProps({ ref_for: true }, info))]),
+					key: "0"
+				} : void 0]), 1032, [
+					"class",
+					"style",
+					"options",
+					"value",
+					"column-index",
+					"item-height",
+					"visible-item-count",
+					"option-render",
+					"virtual",
+					"item-class",
+					"item-style",
+					"onChange"
+				]);
+			}), 128))])], 64))], 16);
+		};
+	}
+});
+export { PickerView_vue_vue_type_script_setup_true_lang_default as default };

package/dist/picker-view/PickerViewColumn.js

@@ -0,0 +1,4 @@
+import PickerViewColumn_vue_vue_type_script_setup_true_lang_default from "./PickerViewColumn.vue_vue_type_script_setup_true_lang.js";
+// src/picker-view/PickerViewColumn.vue
+var PickerViewColumn_default = PickerViewColumn_vue_vue_type_script_setup_true_lang_default;
+export { PickerViewColumn_default as default };

package/dist/picker-view/PickerViewColumn.vue.d.ts

@@ -0,0 +1,37 @@
+import type { CSSProperties } from 'vue';
+import type { RenderNodeFn } from '../_util/type';
+import type { PickerOptionRenderInfo, PickerValue } from './interface';
+import type { NormalizedPickerOption } from './util';
+type __VLS_Props = {
+    options: NormalizedPickerOption[];
+    value?: PickerValue;
+    columnIndex: number;
+    itemHeight: number;
+    visibleItemCount: number;
+    optionRender?: RenderNodeFn<PickerOptionRenderInfo>;
+    itemClass?: string;
+    itemStyle?: CSSProperties;
+    /** `false` renders every option */
+    virtual?: boolean;
+};
+type __VLS_Slots = {
+    option?: (info: PickerOptionRenderInfo) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: PickerValue) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((value: PickerValue) => any) | undefined;
+}>, {
+    virtual: boolean;
+    optionRender: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: PickerOptionRenderInfo) => import("vue").VNodeChild) | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/picker-view/PickerViewColumn.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,266 @@
+import { cancelRaf, clamp, preventDefault, raf } from "../_util/index.js";
+import { useTouch } from "../_util/hooks/useTouch.js";
+import { useVirtualRange } from "../_util/hooks/useVirtualRange.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { findEnabledIndex } from "./util.js";
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, defineComponent, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, ref, renderList, renderSlot, toDisplayString, unref, watch } from "vue";
+// src/picker-view/PickerViewColumn.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"aria-selected",
+	"aria-disabled",
+	"aria-setsize",
+	"aria-posinset",
+	"onClick"
+];
+var _hoisted_2 = {
+	key: 1,
+	class: "am-picker-view-item-text"
+};
+var DEFAULT_DURATION = 200;
+/** a release within this time (ms) and beyond this distance (px) is a flick */
+var MOMENTUM_TIME = 300;
+var MOMENTUM_DISTANCE = 15;
+var MOMENTUM_DURATION = 1e3;
+var DECELERATION = .003;
+var WHEEL_INTERVAL = 60;
+var PickerViewColumn_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmPickerViewColumn",
+	__name: "PickerViewColumn",
+	props: {
+		options: {},
+		value: {},
+		columnIndex: {},
+		itemHeight: {},
+		visibleItemCount: {},
+		optionRender: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		itemClass: {},
+		itemStyle: {},
+		virtual: {
+			type: Boolean,
+			default: true
+		}
+	},
+	emits: ["change"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const touch = useTouch();
+		const wrapperRef = ref();
+		const count = () => props.options.length;
+		const baseOffset = computed(() => props.itemHeight * (props.visibleItemCount - 1) / 2);
+		const currentIndex = computed(() => props.options.findIndex((option) => option.value === props.value));
+		const indexToOffset = (index) => -Math.max(index, 0) * props.itemHeight;
+		const offset = ref(indexToOffset(currentIndex.value));
+		const duration = ref(0);
+		let startOffset = 0;
+		let touchStartTime = 0;
+		let momentumOffset = 0;
+		let moving = false;
+		let lastWheelTime = 0;
+		let movingTimer;
+		/**
+		* Position of the wheel while a transition (snap / inertia) is running. `offset` already holds the
+		* target then, so the window follows the *rendered* position frame by frame instead, otherwise the
+		* rows the wheel is still rolling over would be unmounted. `null`: the wheel rests at `offset`.
+		*/
+		const trackedOffset = ref(null);
+		let trackId = -1;
+		let trackTimer;
+		const range = useVirtualRange({
+			count,
+			size: () => props.itemHeight,
+			scrollOffset: () => -(trackedOffset.value ?? offset.value) - baseOffset.value,
+			viewportSize: () => props.itemHeight * props.visibleItemCount,
+			overscan: () => Math.max(props.visibleItemCount, 3),
+			enabled: () => props.virtual
+		});
+		const visibleOptions = computed(() => {
+			const start = range.start.value;
+			return props.options.slice(start, range.end.value).map((option, i) => ({
+				option,
+				index: start + i
+			}));
+		});
+		watch(() => [
+			currentIndex.value,
+			props.itemHeight,
+			count()
+		], () => {
+			const next = indexToOffset(currentIndex.value);
+			if (next !== offset.value) {
+				duration.value = DEFAULT_DURATION;
+				offset.value = next;
+			}
+		});
+		const offsetToIndex = (value) => clamp(Math.round(-value / props.itemHeight), 0, Math.max(count() - 1, 0));
+		function selectIndex(index, animateDuration) {
+			const target = findEnabledIndex(props.options, index);
+			if (target < 0) return;
+			duration.value = animateDuration;
+			offset.value = indexToOffset(target);
+			const option = props.options[target];
+			if (option.value !== props.value) emit("change", option.value);
+		}
+		/** position of the wheel in the middle of a running transition */
+		function getRenderedOffset() {
+			const el = wrapperRef.value;
+			if (!el) return offset.value;
+			const { transform } = window.getComputedStyle(el);
+			const translateY = Number(transform.slice(7, transform.length - 1).split(", ")[5]);
+			return Number.isNaN(translateY) ? offset.value : Math.min(0, translateY - baseOffset.value);
+		}
+		function stopMomentum() {
+			moving = false;
+			duration.value = 0;
+		}
+		function onTouchStart(event) {
+			touch.start(event);
+			clearTimeout(movingTimer);
+			if (moving) offset.value = getRenderedOffset();
+			moving = false;
+			duration.value = 0;
+			startOffset = offset.value;
+			touchStartTime = Date.now();
+			momentumOffset = startOffset;
+		}
+		function onTouchMove(event) {
+			touch.move(event);
+			if (touch.isVertical()) {
+				moving = true;
+				preventDefault(event, true);
+			}
+			offset.value = clamp(startOffset + touch.deltaY.value, -(count() * props.itemHeight), props.itemHeight);
+			const now = Date.now();
+			if (now - touchStartTime > MOMENTUM_TIME) {
+				touchStartTime = now;
+				momentumOffset = offset.value;
+			}
+		}
+		function onTouchEnd() {
+			const distance = offset.value - momentumOffset;
+			const elapsed = Date.now() - touchStartTime;
+			if (elapsed < MOMENTUM_TIME && Math.abs(distance) > MOMENTUM_DISTANCE) {
+				const speed = Math.abs(distance / Math.max(elapsed, 1));
+				const target = offset.value + speed / DECELERATION * (distance < 0 ? -1 : 1);
+				selectIndex(offsetToIndex(target), MOMENTUM_DURATION);
+				return;
+			}
+			selectIndex(offsetToIndex(offset.value), DEFAULT_DURATION);
+			movingTimer = setTimeout(() => {
+				moving = false;
+			}, 0);
+		}
+		function onClickOption(index) {
+			if (moving || props.options[index].disabled) return;
+			selectIndex(index, DEFAULT_DURATION);
+		}
+		function step(delta) {
+			let index = (currentIndex.value < 0 ? 0 : currentIndex.value) + delta;
+			while (index >= 0 && index < count() && props.options[index].disabled) index += delta;
+			if (index >= 0 && index < count()) selectIndex(index, DEFAULT_DURATION);
+		}
+		function onWheel(event) {
+			preventDefault(event);
+			const now = Date.now();
+			if (!event.deltaY || now - lastWheelTime < WHEEL_INTERVAL) return;
+			lastWheelTime = now;
+			step(event.deltaY > 0 ? 1 : -1);
+		}
+		function onKeydown(event) {
+			if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+				preventDefault(event);
+				step(event.key === "ArrowDown" ? 1 : -1);
+			}
+		}
+		function stopTracking() {
+			cancelRaf(trackId);
+			clearTimeout(trackTimer);
+			trackedOffset.value = null;
+		}
+		function trackTransition() {
+			const rendered = getRenderedOffset();
+			if (!duration.value || Math.abs(rendered - offset.value) < .5) {
+				stopTracking();
+				return;
+			}
+			trackedOffset.value = rendered;
+			trackId = raf(trackTransition);
+		}
+		watch(offset, () => {
+			stopTracking();
+			if (!props.virtual || !duration.value) return;
+			trackTimer = setTimeout(stopTracking, duration.value + 100);
+			trackTransition();
+		});
+		onBeforeUnmount(() => {
+			clearTimeout(movingTimer);
+			stopTracking();
+		});
+		const wrapperStyle = computed(() => ({
+			paddingTop: range.offsetBefore.value ? `${range.offsetBefore.value}px` : void 0,
+			transform: `translate3d(0, ${offset.value + baseOffset.value}px, 0)`,
+			transitionDuration: `${duration.value}ms`,
+			transitionProperty: duration.value ? "transform" : "none"
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				class: "am-picker-view-column",
+				role: "listbox",
+				tabindex: "0",
+				onTouchstartPassive: onTouchStart,
+				onTouchmove: onTouchMove,
+				onTouchend: onTouchEnd,
+				onTouchcancel: onTouchEnd,
+				onWheel,
+				onKeydown
+			}, [createElementVNode("ul", {
+				ref_key: "wrapperRef",
+				ref: wrapperRef,
+				class: "am-picker-view-column-wrapper",
+				style: normalizeStyle(wrapperStyle.value),
+				onTransitionend: stopMomentum
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(visibleOptions.value, ({ option, index }) => {
+				return openBlock(), createElementBlock("li", {
+					key: `${index}-${option.value}`,
+					class: normalizeClass(["am-picker-view-item", [{
+						"am-picker-view-item-selected": option.value === __props.value,
+						"am-picker-view-item-disabled": option.disabled
+					}, __props.itemClass]]),
+					style: normalizeStyle(__props.itemStyle),
+					role: "option",
+					"aria-selected": option.value === __props.value,
+					"aria-disabled": option.disabled || void 0,
+					"aria-setsize": __props.virtual ? __props.options.length : void 0,
+					"aria-posinset": __props.virtual ? index + 1 : void 0,
+					onClick: ($event) => onClickOption(index)
+				}, [renderSlot(_ctx.$slots, "option", {
+					option: option.raw,
+					index,
+					columnIndex: __props.columnIndex,
+					selected: option.value === __props.value
+				}, () => [__props.optionRender !== void 0 ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.optionRender,
+					params: {
+						option: option.raw,
+						index,
+						columnIndex: __props.columnIndex,
+						selected: option.value === __props.value
+					}
+				}, null, 8, ["node", "params"])) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(option.label), 1))])], 14, _hoisted_1);
+			}), 128))], 36)], 32);
+		};
+	}
+});
+export { PickerViewColumn_vue_vue_type_script_setup_true_lang_default as default };

package/dist/picker-view/index.d.ts

@@ -0,0 +1,56 @@
+export type * from './interface';
+declare const PickerView: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").PickerViewProps> & Readonly<{
+        onChange?: ((value: import("./interface").PickerValue[], info: import("./interface").PickerChangeInfo) => any) | undefined;
+        "onUpdate:value"?: ((value: import("./interface").PickerValue[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (value: import("./interface").PickerValue[], info: import("./interface").PickerChangeInfo) => any;
+        "update:value": (value: import("./interface").PickerValue[]) => any;
+    }, import("vue").PublicProps, {
+        loading: boolean;
+        itemHeight: number;
+        visibleItemCount: number;
+        virtual: boolean;
+        optionRender: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PickerOptionRenderInfo) => import("vue").VNodeChild) | null;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").PickerViewProps> & Readonly<{
+        onChange?: ((value: import("./interface").PickerValue[], info: import("./interface").PickerChangeInfo) => any) | undefined;
+        "onUpdate:value"?: ((value: import("./interface").PickerValue[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        loading: boolean;
+        itemHeight: number;
+        visibleItemCount: number;
+        virtual: boolean;
+        optionRender: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PickerOptionRenderInfo) => import("vue").VNodeChild) | null;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").PickerViewProps> & Readonly<{
+    onChange?: ((value: import("./interface").PickerValue[], info: import("./interface").PickerChangeInfo) => any) | undefined;
+    "onUpdate:value"?: ((value: import("./interface").PickerValue[]) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: import("./interface").PickerValue[], info: import("./interface").PickerChangeInfo) => any;
+    "update:value": (value: import("./interface").PickerValue[]) => any;
+}, string, {
+    loading: boolean;
+    itemHeight: number;
+    visibleItemCount: number;
+    virtual: boolean;
+    optionRender: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").PickerOptionRenderInfo) => import("vue").VNodeChild) | null;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").PickerViewSlots;
+}), object>;
+export default PickerView;

package/dist/picker-view/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import PickerView_default from "./PickerView.js";
+// src/picker-view/index.ts
+var PickerView = withInstall(PickerView_default, "AmPickerView");
+export { PickerView as default };

package/dist/picker-view/interface.d.ts

@@ -0,0 +1,69 @@
+import type { CSSProperties } from 'vue';
+import type { RenderNodeFn } from '../_util/type';
+export type PickerValue = string | number;
+export interface PickerOption {
+    label?: string | number;
+    value?: PickerValue;
+    disabled?: boolean;
+    [key: string]: any;
+}
+export interface PickerFieldNames {
+    label?: string;
+    value?: string;
+    disabled?: string;
+}
+export type PickerColumn = PickerOption[];
+/** Static columns, or a function of the current value for cascading columns. */
+export type PickerColumns = PickerColumn[] | ((value: PickerValue[]) => PickerColumn[]);
+export interface PickerChangeInfo {
+    /** Selected option of every column (the raw option objects passed in `columns`) */
+    items: (PickerOption | undefined)[];
+    /** Index of the column that was moved */
+    columnIndex?: number;
+}
+export interface PickerOptionRenderInfo {
+    option: PickerOption;
+    index: number;
+    columnIndex: number;
+    selected: boolean;
+}
+export interface PickerViewSemanticClassNames {
+    root?: string;
+    column?: string;
+    item?: string;
+    indicator?: string;
+}
+export interface PickerViewSemanticStyles {
+    root?: CSSProperties;
+    column?: CSSProperties;
+    item?: CSSProperties;
+    indicator?: CSSProperties;
+}
+export interface PickerViewProps {
+    /** `PickerOption[][]`, or `(value) => PickerOption[][]` for cascading columns */
+    columns?: PickerColumns;
+    fieldNames?: PickerFieldNames;
+    /** One value per column. Supports `v-model:value`. */
+    value?: PickerValue[];
+    defaultValue?: PickerValue[];
+    loading?: boolean;
+    /** Height of one option in px */
+    itemHeight?: number;
+    /** Number of visible options (odd numbers look best) */
+    visibleItemCount?: number;
+    /** Custom option content, the `option` slot wins */
+    optionRender?: RenderNodeFn<PickerOptionRenderInfo>;
+    /** Only mount the options around the visible window of every column. `false` renders all of them. Default `true`. */
+    virtual?: boolean;
+    rootClass?: string;
+    classes?: PickerViewSemanticClassNames;
+    styles?: PickerViewSemanticStyles;
+}
+export interface PickerViewEmits {
+    'update:value': [value: PickerValue[]];
+    'change': [value: PickerValue[], info: PickerChangeInfo];
+}
+export interface PickerViewSlots {
+    option?: (info: PickerOptionRenderInfo) => any;
+    loading?: () => any;
+}