@hanwenbo/x-taro-ui 0.0.1

package/es/components/picker/shared.js

@@ -0,0 +1,114 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function isOption(item) {
+  return _typeof(item) === 'object' && item !== null && 'value' in item;
+}
+function normalizeOption(item) {
+  if (isOption(item)) {
+    return item;
+  }
+  return {
+    label: item,
+    value: item
+  };
+}
+function isMultiColumn(columns) {
+  return columns.length > 0 && Array.isArray(columns[0]);
+}
+export function normalizePickerColumns(rawColumns, value) {
+  var resolved = typeof rawColumns === 'function' ? rawColumns(value) : rawColumns !== null && rawColumns !== void 0 ? rawColumns : [];
+  if (resolved.length === 0) {
+    return [];
+  }
+  var columns = isMultiColumn(resolved) ? resolved : [resolved];
+  return columns.map(function (column) {
+    return column.map(normalizeOption);
+  });
+}
+function valuesEqual(left, right) {
+  return left === right;
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every(function (item, index) {
+    return valuesEqual(item, right[index]);
+  });
+}
+function firstSelectableOption(column) {
+  var _column$find;
+  return (_column$find = column.find(function (option) {
+    return !option.disabled;
+  })) !== null && _column$find !== void 0 ? _column$find : null;
+}
+function closestSelectableOption(column, value) {
+  if (typeof value !== 'number') return firstSelectableOption(column);
+  var numericOptions = column.filter(function (option) {
+    return !option.disabled && typeof option.value === 'number';
+  });
+  if (numericOptions.length === 0) return firstSelectableOption(column);
+  return numericOptions.reduce(function (closest, option) {
+    return Math.abs(option.value - value) < Math.abs(closest.value - value) ? option : closest;
+  });
+}
+/**
+ * Resolve missing/stale values and dependent function columns to a stable state.
+ * A bounded loop allows changing an earlier column to invalidate later columns
+ * without leaving values that no longer exist in the recomputed data set.
+ */
+export function resolvePickerState(rawColumns, value) {
+  var nextValue = _toConsumableArray(value);
+  var columns = [];
+  for (var iteration = 0; iteration < 8; iteration += 1) {
+    columns = normalizePickerColumns(rawColumns, nextValue);
+    var normalizedValue = columns.map(function (column, index) {
+      var _ref, _selected$value, _closestSelectableOpt;
+      var selected = column.find(function (option) {
+        return !option.disabled && valuesEqual(option.value, nextValue[index]);
+      });
+      return (_ref = (_selected$value = selected === null || selected === void 0 ? void 0 : selected.value) !== null && _selected$value !== void 0 ? _selected$value : (_closestSelectableOpt = closestSelectableOption(column, nextValue[index])) === null || _closestSelectableOpt === void 0 ? void 0 : _closestSelectableOpt.value) !== null && _ref !== void 0 ? _ref : null;
+    });
+    if (arraysEqual(nextValue, normalizedValue)) {
+      nextValue = normalizedValue;
+      break;
+    }
+    nextValue = normalizedValue;
+  }
+  columns = normalizePickerColumns(rawColumns, nextValue);
+  var items = columns.map(function (column, index) {
+    var _column$find2;
+    return (_column$find2 = column.find(function (option) {
+      return valuesEqual(option.value, nextValue[index]);
+    })) !== null && _column$find2 !== void 0 ? _column$find2 : null;
+  });
+  return {
+    value: nextValue,
+    columns: columns,
+    items: items
+  };
+}
+
+/** Build x-mobile-ui compatible metadata without filling an uncommitted value. */
+export function generatePickerExtend(rawColumns, value, index) {
+  var columns = normalizePickerColumns(rawColumns, value);
+  var items = columns.map(function (column, columnIndex) {
+    var _column$find3;
+    return (_column$find3 = column.find(function (option) {
+      return !option.disabled && valuesEqual(option.value, value[columnIndex]);
+    })) !== null && _column$find3 !== void 0 ? _column$find3 : null;
+  });
+  return _objectSpread({
+    columns: columns,
+    items: items
+  }, index === undefined ? {} : {
+    index: index
+  });
+}

package/es/components/picker/tokens.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Picker Component Tokens
+ */
+import type { SizeVariant } from '../../theme/types';
+import type { PickerVariant } from './types';
+export interface PickerTokens {
+    itemHeight: number;
+    itemFontSize: number;
+    itemLineHeight: number;
+    itemPaddingX: number;
+    visibleItemCount: number;
+    panelHeight: number;
+    indicatorInset: number;
+    indicatorRadius: number;
+    selectedScale: number;
+    headerHeight: number;
+    headerPadding: number;
+    buttonFontSize: number;
+    titleFontSize: number;
+}
+/**
+ * Get picker tokens
+ */
+export declare function usePickerTokens(size?: SizeVariant): PickerTokens;
+/**
+ * Get picker colors for variant
+ */
+export declare function usePickerColors(variant?: PickerVariant): {
+    background: string;
+    itemColor: string;
+    selectedColor: string;
+    maskStart: string;
+    maskEnd: string;
+    headerBorder: string;
+    buttonColor: string;
+    cancelColor: string;
+    titleColor: string;
+};
+/**
+ * Get wheel picker height
+ */
+export declare function usePickerHeight(size?: SizeVariant): number;
+//# sourceMappingURL=tokens.d.ts.map

package/es/components/picker/tokens.js

@@ -0,0 +1,108 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Picker Component Tokens
+ */
+
+import { useMemo } from 'react';
+import { designSystemRadius, scaleMobileSelection, useTokens } from "../../theme";
+/**
+ * Get picker tokens
+ */
+export function usePickerTokens() {
+  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'middle';
+  return useMemo(function () {
+    var sizeMap = {
+      mini: {
+        itemHeight: 36,
+        fontSize: 12,
+        lineHeight: 16,
+        paddingX: 8,
+        headerHeight: 40
+      },
+      small: {
+        itemHeight: 36,
+        fontSize: 14,
+        lineHeight: 20,
+        paddingX: 10,
+        headerHeight: 46
+      },
+      middle: {
+        itemHeight: 36,
+        fontSize: 14,
+        lineHeight: 20,
+        paddingX: 12,
+        headerHeight: 49
+      },
+      large: {
+        itemHeight: 36,
+        fontSize: 16,
+        lineHeight: 24,
+        paddingX: 16,
+        headerHeight: 60
+      }
+    };
+    var config = sizeMap[size];
+    return {
+      itemHeight: config.itemHeight,
+      itemFontSize: config.fontSize,
+      itemLineHeight: config.lineHeight,
+      itemPaddingX: scaleMobileSelection(config.paddingX),
+      visibleItemCount: 7,
+      panelHeight: 252,
+      indicatorInset: scaleMobileSelection(16),
+      indicatorRadius: designSystemRadius.md,
+      selectedScale: 1.03,
+      headerHeight: config.headerHeight,
+      headerPadding: scaleMobileSelection(size === 'mini' ? 12 : size === 'small' ? 14 : size === 'middle' ? 16 : 20),
+      buttonFontSize: config.fontSize,
+      titleFontSize: config.fontSize
+    };
+  }, [size]);
+}
+
+/**
+ * Get picker colors for variant
+ */
+export function usePickerColors() {
+  var variant = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'default';
+  var _useTokens = useTokens(),
+    colors = _useTokens.colors;
+  return useMemo(function () {
+    var baseColors = {
+      background: colors.popover,
+      itemColor: colors['popover-foreground'],
+      selectedColor: colors.primary,
+      maskStart: colors.popover + 'FF',
+      maskEnd: colors.popover + '00',
+      headerBorder: colors.border,
+      buttonColor: colors.primary,
+      cancelColor: colors['muted-foreground'],
+      titleColor: colors.foreground
+    };
+    switch (variant) {
+      case 'filled':
+        return _objectSpread(_objectSpread({}, baseColors), {}, {
+          background: colors.muted
+        });
+      case 'outline':
+        return baseColors;
+      case 'default':
+      default:
+        return baseColors;
+    }
+  }, [variant, colors]);
+}
+
+/**
+ * Get wheel picker height
+ */
+export function usePickerHeight() {
+  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'middle';
+  var tokens = usePickerTokens(size);
+  return tokens.panelHeight;
+}

package/es/components/picker/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Picker Component Types
+ */
+import type { ReactNode } from 'react';
+import type { SizeVariant } from '../../theme/types';
+export declare type PickerVariant = 'default' | 'filled' | 'outline';
+export declare type PickerValue = string | number | null;
+export interface PickerOption {
+    label: ReactNode;
+    value: string | number;
+    key?: string | number;
+    disabled?: boolean;
+    children?: PickerOption[];
+}
+export declare type PickerColumnItem = PickerOption;
+export declare type PickerColumn = Array<string | number | PickerOption>;
+export declare type PickerColumns = PickerColumn | PickerColumn[];
+export declare type PickerColumnsSource = PickerColumns | ((value: PickerValue[]) => PickerColumns);
+export interface PickerValueExtend {
+    columns: PickerOption[][];
+    items: (PickerOption | null)[];
+    index?: number;
+}
+export interface PickerActions {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export declare type PickerRef = PickerActions;
+export interface PickerProps {
+    /** Selected values (array for multi-column) */
+    value?: PickerValue[];
+    /** Default values (uncontrolled) */
+    defaultValue?: PickerValue[];
+    /** Picker columns data */
+    columns?: PickerColumnsSource;
+    /** Number of columns (for cascading) */
+    columnCount?: number;
+    /** Size variant */
+    size?: SizeVariant;
+    /** Visual style variant */
+    variant?: PickerVariant;
+    /** Disable the default/custom trigger */
+    disabled?: boolean;
+    /** Visible state (controlled) */
+    visible?: boolean;
+    /** Initial visible state (uncontrolled) */
+    defaultVisible?: boolean;
+    /** Title text */
+    title?: ReactNode;
+    /** Confirm button text */
+    confirmText?: ReactNode;
+    /** Cancel button text */
+    cancelText?: ReactNode;
+    /** Loading state */
+    loading?: boolean;
+    loadingContent?: ReactNode;
+    /** Change handler (during selection) */
+    onChange?: (value: PickerValue[], extend: PickerValueExtend) => void;
+    onSelect?: (value: PickerValue[], extend: PickerValueExtend) => void;
+    /** Confirm handler */
+    onConfirm?: (value: PickerValue[], extend: PickerValueExtend) => void;
+    /** Cancel handler */
+    onCancel?: () => void;
+    /** Close handler (click mask) */
+    onClose?: () => void;
+    /** Visible state change handler */
+    onOpenChange?: (open: boolean) => void;
+    closeOnMaskClick?: boolean;
+    placeholder?: ReactNode;
+    /** Custom committed-value renderer inside the standard field trigger. */
+    renderValue?: (value: PickerValue[], extend: PickerValueExtend) => ReactNode;
+    children?: (items: (PickerOption | null)[], actions: PickerActions) => ReactNode;
+    renderLabel?: (option: PickerOption) => ReactNode;
+    popupClassName?: string;
+    popupStyle?: React.CSSProperties;
+    headerClassName?: string;
+    headerStyle?: React.CSSProperties;
+    footerClassName?: string;
+    contentStyle?: React.CSSProperties;
+    containerStyle?: React.CSSProperties;
+    itemHeight?: number;
+    height?: number | string;
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'bottomLeft' | 'bottomRight';
+    popupMatchTriggerWidth?: boolean;
+    ariaLabel?: string;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: React.CSSProperties;
+}
+export interface DatePickerProps extends Omit<PickerProps, 'columns' | 'columnCount' | 'value' | 'defaultValue' | 'onChange' | 'onConfirm'> {
+    /** Date value (YYYY-MM-DD) */
+    value?: string;
+    /** Default value */
+    defaultValue?: string;
+    /** Min date */
+    minDate?: string;
+    /** Max date */
+    maxDate?: string;
+    /** Date format */
+    format?: string;
+    /** Precision */
+    precision?: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second';
+    /** Change handler */
+    onChange?: (value: string) => void;
+    /** Confirm handler */
+    onConfirm?: (value: string) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/es/components/picker/types.js

@@ -0,0 +1 @@
+export {};

package/es/components/pickerView/index.d.ts

@@ -0,0 +1,4 @@
+export { PickerView } from './pickerView';
+export type { PickerViewProps, PickerViewOption, PickerViewVariant } from './types';
+export { default } from './pickerView';
+//# sourceMappingURL=index.d.ts.map

package/es/components/pickerView/index.js

@@ -0,0 +1,2 @@
+export { PickerView } from "./pickerView";
+export { default } from "./pickerView";

package/es/components/pickerView/pickerView.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PickerView Component
+ * Inline wheel picker view aligned with x-mobile-ui.
+ */
+import React from 'react';
+import type { PickerViewProps } from './types';
+export declare const PickerView: React.FC<PickerViewProps>;
+export default PickerView;
+//# sourceMappingURL=pickerView.d.ts.map

package/es/components/pickerView/pickerView.js

@@ -0,0 +1,173 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * PickerView Component
+ * Inline wheel picker view aligned with x-mobile-ui.
+ */
+
+import React, { useCallback, useMemo, useState } from 'react';
+import { View } from '@tarojs/components';
+import { WheelPicker } from "../../patterns/pickerColumns/WheelPicker";
+import { useTokens } from "../../theme";
+import { classNames } from "../../utils";
+import { resolveLocaleText } from "../../utils/locale";
+import { useConfigProvider } from "../configProvider";
+import { generatePickerExtend, resolvePickerState } from "../picker/shared";
+import { usePickerHeight, usePickerTokens } from "../picker/tokens";
+import { Spinner } from "../spinner";
+import { jsx as _jsx } from "react/jsx-runtime";
+var usePickerViewColors = function usePickerViewColors(variant) {
+  var _useTokens = useTokens(),
+    colors = _useTokens.colors;
+  return useMemo(function () {
+    var baseColors = {
+      background: colors.popover,
+      itemColor: colors['popover-foreground'],
+      selectedColor: colors['accent-foreground'],
+      indicatorColor: colors.accent
+    };
+    if (variant === 'filled') {
+      return _objectSpread(_objectSpread({}, baseColors), {}, {
+        background: colors.muted,
+        indicatorColor: colors.background
+      });
+    }
+    return baseColors;
+  }, [colors, variant]);
+};
+export var PickerView = function PickerView(props) {
+  var _ref, _style$height;
+  var hasValueProp = Object.prototype.hasOwnProperty.call(props, 'value');
+  var value = props.value,
+    _props$defaultValue = props.defaultValue,
+    defaultValue = _props$defaultValue === void 0 ? [] : _props$defaultValue,
+    _props$columns = props.columns,
+    columns = _props$columns === void 0 ? [] : _props$columns,
+    size = props.size,
+    _props$variant = props.variant,
+    variant = _props$variant === void 0 ? 'default' : _props$variant,
+    _props$loading = props.loading,
+    loading = _props$loading === void 0 ? false : _props$loading,
+    loadingContent = props.loadingContent,
+    renderLabel = props.renderLabel,
+    itemHeight = props.itemHeight,
+    height = props.height,
+    onChange = props.onChange,
+    className = props.className,
+    style = props.style;
+  var config = useConfigProvider();
+  var resolvedSize = size !== null && size !== void 0 ? size : config.size;
+  var _useState = useState(defaultValue),
+    _useState2 = _slicedToArray(_useState, 2),
+    internalValue = _useState2[0],
+    setInternalValue = _useState2[1];
+  var _useTokens2 = useTokens(),
+    colors = _useTokens2.colors;
+  var tokens = usePickerTokens(resolvedSize);
+  var pickerColors = usePickerViewColors(variant);
+  var defaultHeight = usePickerHeight(resolvedSize);
+  var resolvedItemHeight = itemHeight !== null && itemHeight !== void 0 ? itemHeight : tokens.itemHeight;
+  var resolvedHeight = (_ref = (_style$height = style === null || style === void 0 ? void 0 : style.height) !== null && _style$height !== void 0 ? _style$height : height) !== null && _ref !== void 0 ? _ref : defaultHeight;
+  var emptyContent = resolveLocaleText(config.locale, 'common.empty', '暂无数据');
+  var currentValue = hasValueProp ? value !== null && value !== void 0 ? value : [] : internalValue;
+  var resolvedState = useMemo(function () {
+    return resolvePickerState(columns, currentValue);
+  }, [columns, currentValue]);
+  var selectedIndices = useMemo(function () {
+    return resolvedState.columns.map(function (column, index) {
+      var foundIndex = column.findIndex(function (option) {
+        return option.value === resolvedState.value[index];
+      });
+      return foundIndex;
+    });
+  }, [resolvedState.columns, resolvedState.value]);
+  var handleChange = useCallback(function (indices, changedIndex) {
+    var nextCandidate = _toConsumableArray(resolvedState.value);
+    var selectedOption = resolvedState.columns[changedIndex][indices[changedIndex]];
+    nextCandidate[changedIndex] = selectedOption.value;
+    var nextState = resolvePickerState(columns, nextCandidate);
+    if (!hasValueProp) {
+      setInternalValue(nextState.value);
+    }
+    onChange === null || onChange === void 0 || onChange(nextState.value, generatePickerExtend(columns, nextState.value, changedIndex));
+  }, [columns, hasValueProp, onChange, resolvedState.columns, resolvedState.value]);
+  var containerStyle = _objectSpread({
+    position: 'relative',
+    width: '100%',
+    minWidth: 0,
+    height: resolvedHeight,
+    boxSizing: 'border-box',
+    backgroundColor: pickerColors.background,
+    borderRadius: variant === 'outline' ? 'var(--x-picker-view-radius)' : 0,
+    border: variant === 'outline' ? "1px solid ".concat(colors.border) : 'none',
+    overflow: 'hidden'
+  }, style);
+  if (loading) {
+    return /*#__PURE__*/_jsx(View, {
+      className: classNames("".concat(config.prefixCls, "-picker-view"), "".concat(config.prefixCls, "-picker-view--").concat(resolvedSize), "".concat(config.prefixCls, "-picker-view--").concat(variant), "".concat(config.prefixCls, "-picker-view--loading"), className),
+      "data-slot": "picker-view",
+      "data-size": resolvedSize,
+      "data-variant": variant,
+      "data-loading": "true",
+      style: _objectSpread(_objectSpread({}, containerStyle), {}, {
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center'
+      }),
+      children: loadingContent !== null && loadingContent !== void 0 ? loadingContent : /*#__PURE__*/_jsx(Spinner, {
+        size: resolvedSize,
+        tone: "primary"
+      })
+    });
+  }
+  return /*#__PURE__*/_jsx(View, {
+    className: classNames("".concat(config.prefixCls, "-picker-view"), "".concat(config.prefixCls, "-picker-view--").concat(resolvedSize), "".concat(config.prefixCls, "-picker-view--").concat(variant), className),
+    "data-slot": "picker-view",
+    "data-size": resolvedSize,
+    "data-variant": variant,
+    "data-loading": "false",
+    style: containerStyle,
+    children: /*#__PURE__*/_jsx(WheelPicker, {
+      columns: resolvedState.columns.map(function (column) {
+        return column.map(function (option) {
+          return _objectSpread(_objectSpread({}, option), {}, {
+            label: renderLabel ? renderLabel(option) : option.label
+          });
+        });
+      }),
+      value: selectedIndices,
+      onChange: handleChange,
+      itemHeight: resolvedItemHeight,
+      height: resolvedHeight,
+      visibleItemCount: tokens.visibleItemCount,
+      itemFontSize: tokens.itemFontSize,
+      itemLineHeight: tokens.itemLineHeight,
+      itemPaddingX: tokens.itemPaddingX,
+      itemColor: pickerColors.itemColor,
+      selectedColor: pickerColors.selectedColor,
+      mutedColor: colors['muted-foreground'],
+      emptyContent: emptyContent,
+      emptyColor: colors['muted-foreground'],
+      indicatorColor: pickerColors.indicatorColor,
+      indicatorInset: tokens.indicatorInset,
+      indicatorRadius: tokens.indicatorRadius,
+      selectedScale: tokens.selectedScale,
+      prefixCls: config.prefixCls
+    })
+  });
+};
+export default PickerView;

package/es/components/pickerView/types.d.ts

@@ -0,0 +1,30 @@
+/** PickerView Component Types */
+import type { ReactNode } from 'react';
+import type { SizeVariant } from '../../theme/types';
+import type { PickerColumnsSource, PickerOption, PickerValue, PickerValueExtend } from '../picker/types';
+export declare type PickerViewVariant = 'default' | 'filled' | 'outline';
+export declare type PickerViewOption = PickerOption;
+export interface PickerViewProps {
+    /** Selected values */
+    value?: PickerValue[];
+    /** Default values (uncontrolled) */
+    defaultValue?: PickerValue[];
+    /** Picker columns data, including dependent function columns */
+    columns?: PickerColumnsSource;
+    /** Size variant */
+    size?: SizeVariant;
+    /** Visual style variant */
+    variant?: PickerViewVariant;
+    loading?: boolean;
+    loadingContent?: ReactNode;
+    renderLabel?: (option: PickerViewOption) => ReactNode;
+    itemHeight?: number;
+    height?: number | string;
+    /** Change handler */
+    onChange?: (value: PickerValue[], extend: PickerValueExtend) => void;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional inline styles */
+    style?: React.CSSProperties;
+}
+//# sourceMappingURL=types.d.ts.map

package/es/components/pickerView/types.js

@@ -0,0 +1 @@
+export {};

package/es/components/popconfirm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { default as Popconfirm } from './popconfirm';
+export { default } from './popconfirm';
+//# sourceMappingURL=index.d.ts.map

package/es/components/popconfirm/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export { default as Popconfirm } from "./popconfirm";
+export { default } from "./popconfirm";

package/es/components/popconfirm/popconfirm.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { PopconfirmPlacement, PopconfirmProps } from './types';
+interface PopconfirmPosition {
+    top: number;
+    left: number;
+}
+export declare function calculatePopconfirmPosition(placement: PopconfirmPlacement, trigger: {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+}, panelWidth: number, panelHeight: number, viewport: {
+    width: number;
+    height: number;
+}): PopconfirmPosition;
+declare const Popconfirm: React.FC<PopconfirmProps>;
+export default Popconfirm;
+//# sourceMappingURL=popconfirm.d.ts.map