@pisell/private-materials 6.7.9 → 6.8.1

package/lib/pro/Selector/hooks/useSelectionController.js

@@ -0,0 +1,338 @@
+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/pro/Selector/hooks/useSelectionController.ts
+var useSelectionController_exports = {};
+__export(useSelectionController_exports, {
+  default: () => useSelectionController
+});
+module.exports = __toCommonJS(useSelectionController_exports);
+var import_react = require("react");
+var import_ahooks = require("ahooks");
+var import_utils = require("@pisell/utils");
+function useSelectionController(props) {
+  const {
+    dataSource = [],
+    ruleConfig,
+    fieldNames,
+    mode = "single",
+    valueType = "primitive"
+  } = props || {};
+  const [values, setValues] = (0, import_ahooks.useControllableValue)(props);
+  const valuesRef = (0, import_react.useRef)(values);
+  valuesRef.current = values;
+  const [errors, setErrors] = (0, import_react.useState)([]);
+  const [validated, setValidated] = (0, import_react.useState)(false);
+  const normalizedOptions = (0, import_react.useMemo)(() => {
+    return dataSource.map((option) => ({
+      ...option,
+      _key: option[(fieldNames == null ? void 0 : fieldNames.value) || "value"],
+      _label: option[(fieldNames == null ? void 0 : fieldNames.label) || "label"]
+    }));
+  }, [dataSource, fieldNames]);
+  const mutexGroups = (0, import_react.useMemo)(() => {
+    const groups = [];
+    const m = ruleConfig == null ? void 0 : ruleConfig.mutex;
+    if (Array.isArray(m)) {
+      m.forEach((g) => {
+        if (Array.isArray(g) && g.length > 0) {
+          groups.push(g);
+        }
+      });
+    }
+    return groups;
+  }, [ruleConfig]);
+  const mutexIndex = (0, import_react.useMemo)(() => {
+    const map = /* @__PURE__ */ new Map();
+    mutexGroups.forEach((group, idx) => {
+      group.forEach((k) => {
+        const arr = map.get(k) || [];
+        arr.push(idx);
+        map.set(k, arr);
+      });
+    });
+    return map;
+  }, [mutexGroups]);
+  const showQuantity = (0, import_react.useMemo)(() => {
+    const list = Array.isArray(dataSource) ? dataSource : dataSource || [];
+    const hasItemMaxGt = list.some(
+      (opt) => {
+        var _a;
+        return typeof ((_a = opt == null ? void 0 : opt.ruleConfig) == null ? void 0 : _a.max) === "number" && opt.ruleConfig.max > 1;
+      }
+    );
+    return hasItemMaxGt;
+  }, [dataSource]);
+  const normalizedValues = (0, import_react.useMemo)(() => {
+    if (!values) return [];
+    if (Array.isArray(values)) {
+      return values.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          return {
+            ...item,
+            // 保留原有的所有字段
+            value: item.value,
+            quantity: item.quantity || 1
+          };
+        }
+        return { value: item, quantity: 1 };
+      });
+    }
+    if (typeof values === "object" && values !== null) {
+      const objValue = values;
+      return [
+        {
+          ...objValue,
+          // 保留原有的所有字段
+          value: objValue.value,
+          quantity: objValue.quantity || 1
+        }
+      ];
+    }
+    return [{ value: values, quantity: 1 }];
+  }, [values]);
+  const getOptionState = (0, import_react.useCallback)(
+    (optionKey) => {
+      const found = normalizedValues.find((item) => item.value === optionKey);
+      return {
+        selected: !!found,
+        quantity: (found == null ? void 0 : found.quantity) || 0
+      };
+    },
+    [normalizedValues]
+  );
+  const options = (0, import_react.useMemo)(() => {
+    return normalizedOptions.map((option) => {
+      const state = getOptionState(option._key);
+      return {
+        ...option,
+        selected: state.selected,
+        quantity: state.quantity
+      };
+    });
+  }, [normalizedOptions, getOptionState]);
+  const validate = async () => {
+    const errors2 = [];
+    const { required, min, max, customValidator } = ruleConfig || {};
+    const values2 = valuesRef.current;
+    if (required) {
+      if (mode === "single" && !values2) {
+        errors2.push({ type: "required", message: import_utils.locales.getText("pisell2.pro.selector.validate.required-msg") });
+      } else if (mode === "multiple" && (!values2 || Array.isArray(values2) && values2.length === 0)) {
+        errors2.push({
+          type: "required",
+          message: import_utils.locales.getText("pisell2.pro.selector.validate.required-least")
+        });
+      }
+    }
+    if (mode === "multiple" && Array.isArray(values2)) {
+      if (typeof min === "number" && values2.length < min) {
+        errors2.push({
+          type: "min",
+          message: import_utils.locales.getText("pisell2.pro.selector.validate.min-selection")(min)
+        });
+      }
+      if (typeof max === "number" && values2.length > max) {
+        errors2.push({
+          type: "max",
+          message: import_utils.locales.getText("pisell2.pro.selector.validate.max-selection")(max)
+        });
+      }
+    }
+    options.forEach((option) => {
+      var _a, _b;
+      const { selected, quantity } = option;
+      const _min = (_a = option == null ? void 0 : option.ruleConfig) == null ? void 0 : _a.min;
+      const _max = (_b = option == null ? void 0 : option.ruleConfig) == null ? void 0 : _b.max;
+      if (selected) {
+        if (typeof _min === "number" && quantity < _min) {
+          errors2.push({
+            type: "min",
+            message: import_utils.locales.getText("pisell2.pro.selector.validate.min-quantity")(_min),
+            _key: option._key
+          });
+        }
+        if (typeof _max === "number" && quantity > _max) {
+          errors2.push({
+            type: "max",
+            message: import_utils.locales.getText("pisell2.pro.selector.validate.max-quantity")(_max),
+            _key: option._key
+          });
+        }
+      }
+    });
+    if (mutexGroups.length > 0) {
+      const selectedValues = Array.isArray(values2) ? values2 : values2 ? [values2] : [];
+      const selectedKeys = selectedValues.map(
+        (v) => typeof v === "object" && v !== null ? v.value : v
+      );
+      mutexGroups.forEach((group) => {
+        const count = selectedKeys.filter(
+          (k) => group.includes(k)
+        ).length;
+        if (count > 1) {
+          errors2.push({
+            type: "mutex",
+            message: "Only one option can be selected in the same mutex group"
+          });
+        }
+      });
+    }
+    if (typeof customValidator === "function") {
+      try {
+        await customValidator(values2);
+      } catch (e) {
+        const type = (e == null ? void 0 : e.type) === "requireOneOf" ? "requireOneOf" : (e == null ? void 0 : e.type) || "custom";
+        const message = (e == null ? void 0 : e.message) || "Validation failed";
+        errors2.push({ type, message });
+      }
+    }
+    setErrors(errors2);
+    setValidated(true);
+    return errors2.length === 0 ? Promise.resolve() : Promise.reject(errors2);
+  };
+  const buildOutputValue = (0, import_react.useCallback)(
+    (newNormalizedValues) => {
+      if (newNormalizedValues.length === 0) {
+        return mode === "single" ? void 0 : [];
+      }
+      if (mode === "single") {
+        const item = newNormalizedValues[0];
+        if (valueType === "primitive") {
+          return item.value;
+        }
+        const { value, quantity, ...otherFields } = item;
+        const result = { value, ...otherFields };
+        if (showQuantity) {
+          result.quantity = quantity;
+        }
+        return result;
+      }
+      if (valueType === "primitive") {
+        return newNormalizedValues.map((item) => item.value);
+      }
+      return newNormalizedValues.map((item) => {
+        const { value, quantity, ...otherFields } = item;
+        const result = { value, ...otherFields };
+        if (showQuantity) {
+          result.quantity = quantity;
+        }
+        return result;
+      });
+    },
+    [mode, valueType, showQuantity]
+  );
+  const _onChange = (0, import_react.useCallback)(
+    (optionKey, data) => {
+      let newNormalizedValues = [...normalizedValues];
+      const existingIndex = newNormalizedValues.findIndex(
+        (item) => item.value === optionKey
+      );
+      if ((data == null ? void 0 : data.quantity) !== void 0 && data.quantity <= 0) {
+        if (existingIndex >= 0) {
+          newNormalizedValues.splice(existingIndex, 1);
+        }
+      } else {
+        if (existingIndex >= 0) {
+          newNormalizedValues[existingIndex] = {
+            ...newNormalizedValues[existingIndex],
+            ...data
+          };
+        } else {
+          const newItem = {
+            value: optionKey,
+            quantity: 1,
+            ...data
+          };
+          if (mode === "single") {
+            newNormalizedValues = [newItem];
+          } else {
+            newNormalizedValues.push(newItem);
+          }
+        }
+        const groupIdxList = mutexIndex.get(optionKey) || [];
+        if (groupIdxList.length > 0) {
+          const keepKey = optionKey;
+          const toRemove = /* @__PURE__ */ new Set();
+          groupIdxList.forEach((gi) => {
+            const group = mutexGroups[gi] || [];
+            group.forEach((k) => {
+              if (k !== keepKey) {
+                toRemove.add(k);
+              }
+            });
+          });
+          if (toRemove.size > 0) {
+            newNormalizedValues = newNormalizedValues.filter(
+              (item) => !toRemove.has(item.value)
+            );
+          }
+        }
+      }
+      const outputValue = buildOutputValue(newNormalizedValues);
+      setValues(outputValue);
+      valuesRef.current = outputValue;
+      if (ruleConfig == null ? void 0 : ruleConfig.autoValidate) {
+        validate();
+      }
+    },
+    [
+      normalizedValues,
+      mode,
+      buildOutputValue,
+      setValues,
+      mutexIndex,
+      mutexGroups,
+      ruleConfig == null ? void 0 : ruleConfig.autoValidate
+    ]
+  );
+  const clear = (0, import_react.useCallback)(() => {
+    setValues(mode === "single" ? void 0 : []);
+    setErrors([]);
+  }, [mode, setValues, setErrors]);
+  const reset = (0, import_react.useCallback)(() => {
+    const hasDefinedDefault = props && props.defaultValue !== void 0;
+    if (hasDefinedDefault) {
+      setValues(props.defaultValue);
+    } else {
+      clear();
+    }
+    setErrors([]);
+  }, [props, clear, setValues, setErrors]);
+  const actions = {
+    toggle: (optionKey) => {
+      const currentState = getOptionState(optionKey);
+      _onChange(optionKey, { quantity: currentState.selected ? 0 : 1 });
+    },
+    update: (optionKey, data) => _onChange(optionKey, data),
+    setValue: (value) => setValues(value),
+    clear,
+    validate,
+    reset
+  };
+  return {
+    state: {
+      errors,
+      validated,
+      values,
+      options,
+      showQuantity
+    },
+    actions
+  };
+}

package/lib/pro/Selector/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { SelectorProps, OptionKey } from './types';
+import SelectorGroup from './SelectorGroup';
+declare type SelectorComponentType = React.ForwardRefExoticComponent<SelectorProps<OptionKey> & React.RefAttributes<any>> & {
+    Group: typeof SelectorGroup;
+};
+declare const Selector: SelectorComponentType;
+export default Selector;

package/lib/pro/Selector/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pro/Selector/index.tsx
+var Selector_exports = {};
+__export(Selector_exports, {
+  default: () => Selector_default
+});
+module.exports = __toCommonJS(Selector_exports);
+var import_Selector = __toESM(require("./Selector"));
+var import_SelectorGroup = __toESM(require("./SelectorGroup"));
+var Selector = import_Selector.default;
+Selector.Group = import_SelectorGroup.default;
+var Selector_default = Selector;

package/lib/pro/Selector/locales.d.ts

@@ -0,0 +1,42 @@
+declare const _default: {
+    en: {
+        'pisell2.pro.selector.mode.single': string;
+        'pisell2.pro.selector.mode.multiple': string;
+        'pisell2.pro.selector.validate.required-msg': string;
+        'pisell2.pro.selector.validate.required-least': string;
+        'pisell2.pro.selector.validate.requireOneOf-msg': string;
+        'pisell2.pro.selector.required-tag': string;
+        'pisell2.pro.selector.validate.min-quantity': (min: number) => string;
+        'pisell2.pro.selector.validate.max-quantity': (max: number) => string;
+        'pisell2.pro.selector.validate.min-selection': (min: number) => string;
+        'pisell2.pro.selector.validate.max-selection': (max: number) => string;
+        'pisell2.pro.selector.validate.min-max-selection': (min: number, max: number) => string;
+    };
+    'zh-CN': {
+        'pisell2.pro.selector.mode.single': string;
+        'pisell2.pro.selector.mode.multiple': string;
+        'pisell2.pro.selector.validate.required-msg': string;
+        'pisell2.pro.selector.validate.required-least': string;
+        'pisell2.pro.selector.validate.requireOneOf-msg': string;
+        'pisell2.pro.selector.required-tag': string;
+        'pisell2.pro.selector.validate.min-quantity': (min: number) => string;
+        'pisell2.pro.selector.validate.max-quantity': (max: number) => string;
+        'pisell2.pro.selector.validate.min-selection': (min: number) => string;
+        'pisell2.pro.selector.validate.max-selection': (max: number) => string;
+        'pisell2.pro.selector.validate.min-max-selection': (min: number, max: number) => string;
+    };
+    'zh-HK': {
+        'pisell2.pro.selector.mode.single': string;
+        'pisell2.pro.selector.mode.multiple': string;
+        'pisell2.pro.selector.validate.required-msg': string;
+        'pisell2.pro.selector.validate.required-least': string;
+        'pisell2.pro.selector.validate.requireOneOf-msg': string;
+        'pisell2.pro.selector.required-tag': string;
+        'pisell2.pro.selector.validate.min-quantity': (min: number) => string;
+        'pisell2.pro.selector.validate.max-quantity': (max: number) => string;
+        'pisell2.pro.selector.validate.min-selection': (min: number) => string;
+        'pisell2.pro.selector.validate.max-selection': (max: number) => string;
+        'pisell2.pro.selector.validate.min-max-selection': (min: number, max: number) => string;
+    };
+};
+export default _default;

package/lib/pro/Selector/locales.js

@@ -0,0 +1,80 @@
+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/pro/Selector/locales.ts
+var locales_exports = {};
+__export(locales_exports, {
+  default: () => locales_default
+});
+module.exports = __toCommonJS(locales_exports);
+var locales_default = {
+  en: {
+    "pisell2.pro.selector.mode.single": "Single choice",
+    "pisell2.pro.selector.mode.multiple": "Multiple choice",
+    "pisell2.pro.selector.validate.required-msg": "Please select",
+    "pisell2.pro.selector.validate.required-least": "Please select at least one option",
+    "pisell2.pro.selector.validate.requireOneOf-msg": "This group must select one of the specified collections",
+    "pisell2.pro.selector.required-tag": "Required",
+    "pisell2.pro.selector.validate.min-quantity": (min) => `Minimum quantity is ${min}`,
+    "pisell2.pro.selector.validate.max-quantity": (max) => `Maximum quantity is ${max}`,
+    "pisell2.pro.selector.validate.min-selection": (min) => `Please select at least ${min} options`,
+    "pisell2.pro.selector.validate.max-selection": (max) => `Please select at most ${max} options`,
+    "pisell2.pro.selector.validate.min-max-selection": (min, max) => {
+      const _minText = `At least ${min}`;
+      const _maxText = `No more than ${max}`;
+      const _separator = _minText && _maxText ? "," : "";
+      return `${_minText}${_separator}${_maxText ? " " : ""}${_maxText}`;
+    }
+  },
+  "zh-CN": {
+    "pisell2.pro.selector.mode.single": "单选",
+    "pisell2.pro.selector.mode.multiple": "多选",
+    "pisell2.pro.selector.validate.required-msg": "请选择",
+    "pisell2.pro.selector.validate.required-least": "请选择至少一个选项",
+    "pisell2.pro.selector.validate.requireOneOf-msg": "该组必须选择指定集合之一",
+    "pisell2.pro.selector.required-tag": "必选",
+    "pisell2.pro.selector.validate.min-quantity": (min) => `最小数量为 ${min}`,
+    "pisell2.pro.selector.validate.max-quantity": (max) => `最大数量为 ${max}`,
+    "pisell2.pro.selector.validate.min-selection": (min) => `至少选择 ${min} 个选项`,
+    "pisell2.pro.selector.validate.max-selection": (max) => `最多选择 ${max} 个选项`,
+    "pisell2.pro.selector.validate.min-max-selection": (min, max) => {
+      const _minText = `至少选择 ${min} 个选项`;
+      const _maxText = `最多选择 ${max} 个选项`;
+      const _separator = _minText && _maxText ? "," : "";
+      return `${_minText}${_separator}${_maxText ? " " : ""}${_maxText}`;
+    }
+  },
+  "zh-HK": {
+    "pisell2.pro.selector.mode.single": "單選",
+    "pisell2.pro.selector.mode.multiple": "多選",
+    "pisell2.pro.selector.validate.required-msg": "請選擇",
+    "pisell2.pro.selector.validate.required-least": "請選擇至少一個選項",
+    "pisell2.pro.selector.validate.requireOneOf-msg": "該組必須選擇指定集合之一",
+    "pisell2.pro.selector.required-tag": "必選",
+    "pisell2.pro.selector.validate.min-quantity": (min) => `最小數量為 ${min}`,
+    "pisell2.pro.selector.validate.max-quantity": (max) => `最大數量為 ${max}`,
+    "pisell2.pro.selector.validate.min-selection": (min) => `至少選擇 ${min} 個選項`,
+    "pisell2.pro.selector.validate.max-selection": (max) => `最多選擇 ${max} 個選項`,
+    "pisell2.pro.selector.validate.min-max-selection": (min, max) => {
+      const _minText = `至少選擇 ${min} 個選項`;
+      const _maxText = `最多選擇 ${max} 個選項`;
+      const _separator = _minText && _maxText ? "," : "";
+      return `${_minText}${_separator}${_maxText ? " " : ""}${_maxText}`;
+    }
+  }
+};

package/lib/pro/Selector/selector.less

@@ -0,0 +1,3 @@
+.pisell-selector_radio-trigger {
+  margin: 0;
+}

package/lib/pro/Selector/selectorGroup.less

@@ -0,0 +1,8 @@
+.pisell-batch-selector {
+
+  &__content {
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+  }
+}

package/lib/pro/Selector/types.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="react" />
+export interface ExprRule {
+    [key: string]: any;
+}
+export interface RuleConfig {
+    autoValidate?: boolean;
+    required?: 0 | 1;
+    min?: number;
+    max?: number;
+    mutex?: Array<Array<OptionKey>>;
+    customValidator?: (value: SelectionValue) => Promise<void>;
+}
+export interface GroupItem {
+    id?: number;
+    title?: string;
+    mode?: 'single' | 'multiple';
+    valueType?: 'primitive' | 'object';
+    preserve?: boolean;
+    fieldNames?: {
+        label?: string;
+        value?: string;
+    };
+    ruleConfig?: RuleConfig;
+    dataSource?: OptionItem[];
+}
+export interface OptionItem {
+    id?: number;
+    title?: string;
+    label?: string;
+    value?: OptionKey;
+    groups?: GroupItem[];
+    disabled?: boolean;
+    ruleConfig?: {
+        min?: number;
+        max?: number;
+    };
+    [key: string]: any;
+}
+export declare type OptionKey = number | string;
+/** 原始值类型：单选时为id，多选时为id[] */
+export declare type SelectionValuePrimitive<T = OptionKey> = T | T[];
+/** 复杂对象值类型：包含id、数量等额外信息 */
+export interface SelectionValueObject<T = OptionKey> {
+    value?: T;
+    quantity?: number;
+    [key: string]: any;
+}
+/** 单选值类型 */
+export declare type SelectionValueSingle<T = OptionKey> = T | SelectionValueObject<T>;
+/** 多选值类型 */
+export declare type SelectionValueMultiple<T = OptionKey> = T[] | SelectionValueObject<T>[];
+/** 选择器值类型 */
+export declare type SelectionValue<T = OptionKey> = SelectionValueSingle<T> | SelectionValueMultiple<T>;
+export declare type GridConfig = {
+    align?: 'top' | 'middle' | 'bottom' | 'stretch';
+    columns?: number;
+    gutter?: number | object | Array<number>;
+    justify?: 'start' | 'end' | 'center' | 'space-between' | 'space-around';
+    wrap?: boolean;
+    colConfig?: {
+        [key: string]: any;
+    };
+};
+export interface SelectorProps<T = OptionKey> extends GroupItem {
+    value?: SelectionValue<T>;
+    defaultValue?: SelectionValue<T>;
+    onChange?: (value: SelectionValue<T>) => void;
+    onClear?: () => void;
+    disabled?: boolean;
+    grid?: GridConfig;
+    variant?: 'default' | 'select' | 'card';
+    renderItem?: (props: any) => React.ReactNode;
+    item?: {
+        bordered?: boolean;
+        layout?: 'vertical' | 'horizontal';
+        selectedTypeVariant?: 'default' | 'filled' | 'cornered';
+        selectedIcon?: React.ReactNode;
+        renderContent?: (props: any) => React.ReactNode;
+        style?: React.CSSProperties;
+    };
+    titleProps?: {
+        visible?: boolean;
+        style?: React.CSSProperties;
+        title?: {
+            visible?: boolean;
+            text?: React.ReactNode;
+            style?: React.CSSProperties;
+        };
+        icon?: {
+            visible?: boolean;
+            icon?: React.ReactNode;
+            style?: React.CSSProperties;
+        };
+        tip?: {
+            visible?: boolean;
+            text?: React.ReactNode;
+            style?: React.CSSProperties;
+        };
+    };
+}
+export interface SelectorGroupProps {
+    dataSource: GroupItem[];
+    linkageRules?: ExprRule[] | Record<string, any>;
+    allowedValuesPolicy?: 'relaxed' | 'strict';
+    preserve?: boolean;
+    value?: Record<string, SelectionValue>;
+    defaultValue?: Record<string, SelectionValue>;
+    onChange?: (values: Record<string, SelectionValue>) => void;
+    tabProps?: {
+        visible?: boolean;
+    };
+    customScrollParent?: HTMLElement;
+    [key: string]: any;
+}

package/lib/pro/Selector/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/pro/Selector/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);