@tuya-miniapp/smart-ui 2.6.4-beta-7 → 2.6.4-beta-9

package/lib/picker-column/index.js

@@ -0,0 +1,335 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var component_1 = require("../common/component");
+var utils_1 = require("../common/utils");
+var validator_1 = require("../common/validator");
+var ty_1 = __importDefault(require("../common/ty"));
+var DEFAULT_DURATION = 400;
+var compIdList = [];
+var getId = function () {
+    var id = 'smart-picker-column-' + compIdList.length;
+    compIdList.push(id);
+    return id;
+};
+(0, component_1.SmartComponent)({
+    classes: ['active-class'],
+    props: {
+        valueKey: String,
+        className: String,
+        itemHeight: Number,
+        disabled: Boolean,
+        visibleItemCount: Number,
+        activeStyle: {
+            type: String,
+            value: '',
+        },
+        options: {
+            type: Array,
+            value: [],
+            observer: function (value) {
+                if (!this.data.isInit)
+                    return;
+                this.updateUint(value);
+                this.checkIndexUpdateList();
+            },
+        },
+        defaultIndex: {
+            type: Number,
+            value: 0,
+        },
+        changeAnimation: {
+            type: Boolean,
+            value: false,
+        },
+        fontStyle: {
+            type: String,
+            value: '',
+        },
+        activeIndex: {
+            type: null,
+            observer: function () {
+                if (!this.data.isInit)
+                    return;
+                this.checkIndexUpdateList();
+            },
+        },
+        unit: {
+            type: String,
+            value: '',
+        },
+        animationTime: {
+            type: Number,
+            value: 300,
+        },
+        loop: {
+            type: Boolean,
+            value: false,
+        },
+    },
+    data: {
+        isInit: false,
+        maxText: '',
+        optionsVIndexList: [],
+        offsetActiveIndex: 0,
+        endTimer: null,
+        offsetList: [],
+        moving: false,
+        movingDirection: 'down',
+        startY: 0,
+        offsetting: 0,
+        animationIndex: 0,
+        isDestroy: false,
+    },
+    created: function () {
+        this.setData({
+            instanceId: getId(),
+        });
+        this.updateUint(this.data.options);
+        this.checkIndexUpdateList();
+        this.setData({
+            isInit: true,
+        });
+    },
+    destroyed: function () {
+        this.setData({
+            isDestroy: true,
+        });
+    },
+    methods: {
+        checkIndexUpdateList: function () {
+            var _a = this.data, activeIndex = _a.activeIndex, defaultIndex = _a.defaultIndex;
+            var count = this.data.options.length;
+            var currIndex = activeIndex !== null ? activeIndex : defaultIndex;
+            var animationIndex = this.getAnimationIndex(currIndex);
+            animationIndex = this.adjustIndex(animationIndex);
+            var currActiveIndex = this.data.loop ? ((animationIndex + 1) % count) - 1 : animationIndex;
+            if (currActiveIndex < 0) {
+                currActiveIndex += count;
+            }
+            var optionsVIndexList = this.getVisibleOptions(animationIndex);
+            this.setData({
+                activeIndex: currActiveIndex,
+                animationIndex: animationIndex,
+                optionsVIndexList: optionsVIndexList,
+            });
+            // if (currActiveIndex !== activeIndex) {
+            //   this.$emit('change', currActiveIndex);
+            // }
+        },
+        getAnimationIndex: function (activeIndex) {
+            var animationIndex = this.data.animationIndex;
+            var length = this.data.options.length || 1;
+            if (this.data.loop) {
+                var newAnimationIndex = this.getNewAnimationIndex(animationIndex, activeIndex, length, this.data.loop);
+                return newAnimationIndex;
+            }
+            return activeIndex;
+        },
+        getCount: function () {
+            return this.data.options.length;
+        },
+        vibrateShort: function (count, time) {
+            if (time === void 0) { time = DEFAULT_DURATION; }
+            if (this.data.vibrateTimer) {
+                clearInterval(this.data.vibrateTimer);
+                this.setData({
+                    vibrateTimer: null,
+                });
+            }
+            if (!count) {
+                ty_1.default.vibrateShort({ type: 'light' });
+                return;
+            }
+            var has = 0;
+            var timer = setInterval(function () {
+                if (has >= count) {
+                    clearInterval(timer);
+                    return;
+                }
+                has++;
+                ty_1.default.vibrateShort({ type: 'light' });
+            }, time / count - 20);
+            this.setData({
+                vibrateTimer: timer,
+            });
+        },
+        updateUint: function (options) {
+            var _a = this.data, unit = _a.unit, valueKey = _a.valueKey;
+            if (unit) {
+                var maxText_1 = '';
+                options.forEach(function (option) {
+                    var _a;
+                    var value = (0, validator_1.isObj)(option) ? (_a = option[valueKey]) === null || _a === void 0 ? void 0 : _a.toString() : option === null || option === void 0 ? void 0 : option.toString();
+                    if (maxText_1.length < value.length) {
+                        maxText_1 = value;
+                    }
+                });
+                this.setData({ maxText: maxText_1 });
+            }
+        },
+        getVisibleOptions: function (currentIndex) {
+            var animationIndex = Math.round(currentIndex !== undefined ? currentIndex : this.data.animationIndex);
+            var vOptionLength = this.data.visibleItemCount * 4 - 2;
+            var rotateAngle = 360 / vOptionLength;
+            var partCount = Math.floor(this.data.visibleItemCount / 2) + 3;
+            var newArr = new Array(vOptionLength).fill('');
+            var newValueArr = new Array(partCount * 2 + 1).fill('');
+            if (this.data.loop) {
+                // 循环模式：根据 options 首尾填充 newValueArr 数组
+                var optionsLength_1 = this.data.options.length;
+                if (optionsLength_1 === 0) {
+                    // 如果没有选项，填充空值
+                    newValueArr.fill('');
+                }
+                else {
+                    newValueArr.forEach(function (item, index) {
+                        // 计算相对于中心的偏移量
+                        var offset = index - partCount;
+                        // 计算目标索引，支持循环
+                        var targetAnimationIndex = animationIndex + offset;
+                        var targetIndex = ((targetAnimationIndex + 1) % optionsLength_1) - 1;
+                        if (targetIndex < 0) {
+                            targetIndex += optionsLength_1;
+                        }
+                        newValueArr[index] = targetIndex;
+                    });
+                }
+            }
+            else {
+                if (animationIndex < 0) {
+                    animationIndex = 0;
+                }
+                if (animationIndex > this.data.options.length - 1) {
+                    animationIndex = this.data.options.length - 1;
+                }
+                newValueArr.forEach(function (item, index) {
+                    var valueIndex = animationIndex - partCount + index >= 0
+                        ? animationIndex - partCount + index
+                        : undefined;
+                    if (valueIndex === undefined) {
+                        return;
+                    }
+                    newValueArr[index] = valueIndex;
+                });
+            }
+            var rotate = (animationIndex * rotateAngle) % 360;
+            if (rotate < 0) {
+                rotate += 360;
+            }
+            var rotateIndex = Math.round(rotate / rotateAngle);
+            // 环形结构填充：以rotateIndex为中心，向两边扩展填充newValueArr
+            var centerIndex = rotateIndex; // 中心位置
+            var halfLength = Math.floor(newValueArr.length / 2); // newValueArr的一半长度
+            // 从中心位置开始，向两边填充
+            for (var i = 0; i < newValueArr.length; i++) {
+                var targetIndex = (centerIndex - halfLength + i + vOptionLength) % vOptionLength; // 确保索引在0-17范围内
+                newArr[targetIndex] = newValueArr[i];
+            }
+            return newArr;
+        },
+        getNewAnimationIndex: function (animationIndex, activeIndex, length, loop) {
+            var curOptionsNewIndex = Math.floor((animationIndex + 1) / length) * length + activeIndex;
+            var preOptionsNewIndex = curOptionsNewIndex - length;
+            var afterOptionsNewIndex = curOptionsNewIndex + length;
+            var newAnimationIndex = !loop
+                ? activeIndex
+                : Math.abs(preOptionsNewIndex - animationIndex) >
+                    Math.abs(curOptionsNewIndex - animationIndex)
+                    ? Math.abs(curOptionsNewIndex - animationIndex) >
+                        Math.abs(afterOptionsNewIndex - animationIndex)
+                        ? afterOptionsNewIndex
+                        : curOptionsNewIndex
+                    : Math.abs(preOptionsNewIndex - animationIndex) >
+                        Math.abs(afterOptionsNewIndex - animationIndex)
+                        ? afterOptionsNewIndex
+                        : preOptionsNewIndex;
+            return newAnimationIndex;
+        },
+        adjustIndex: function (index) {
+            var data = this.data;
+            var count = this.getCount();
+            if (this.data.loop) {
+                for (var i = 0; i < count; i++) {
+                    var targetIndex = index + i;
+                    var optionIndex = ((targetIndex + 1) % count) - 1;
+                    if (optionIndex < 0) {
+                        optionIndex += count;
+                    }
+                    if (!this.isDisabled(data.options[optionIndex]) &&
+                        data.options[optionIndex] !== undefined) {
+                        return targetIndex;
+                    }
+                }
+                return 0;
+            }
+            var activeIndex = (0, utils_1.range)(index, 0, count);
+            for (var i = activeIndex; i < count; i++) {
+                if (!this.isDisabled(data.options[i]) && data.options[i] !== undefined)
+                    return i;
+            }
+            for (var i = activeIndex - 1; i >= 0; i--) {
+                if (!this.isDisabled(data.options[i]) && data.options[i] !== undefined)
+                    return i;
+            }
+            return 0;
+        },
+        isDisabled: function (option) {
+            return (0, validator_1.isObj)(option) && option.disabled;
+        },
+        getOptionText: function (option) {
+            var data = this.data;
+            return (0, validator_1.isObj)(option) && data.valueKey in option ? option[data.valueKey] : option;
+        },
+        setValue: function (value) {
+            var options = this.data.options;
+            for (var i = 0; i < options.length; i++) {
+                if (this.getOptionText(options[i]) === value) {
+                    return this.setIndex(i);
+                }
+            }
+            return Promise.resolve();
+        },
+        setIndex: function (index) {
+            var activeIndex = ((index + 1) % this.data.options.length) - 1;
+            if (activeIndex < 0) {
+                activeIndex += this.data.options.length;
+            }
+            this.setData({
+                activeIndex: activeIndex,
+                animationIndex: index,
+            });
+        },
+        getValue: function () {
+            var data = this.data;
+            return (0, validator_1.isObj)(data.options[data.activeIndex])
+                ? data.options[data.activeIndex][data.valueKey]
+                : data.options[data.activeIndex];
+        },
+        activeIndexChange: function (index) {
+            var activeIndex = ((index + 1) % this.data.options.length) - 1;
+            if (activeIndex < 0) {
+                activeIndex += this.data.options.length;
+            }
+            var isSame = activeIndex === this.data.activeIndex;
+            this.setData({
+                activeIndex: activeIndex,
+                animationIndex: index,
+            });
+            !isSame && this.$emit('change', index);
+        },
+        animationIndexChange: function (index) {
+            this.setData({
+                animationIndex: index,
+            });
+        },
+        animationStart: function () {
+            this.$emit('animation-start');
+        },
+        animationEnd: function () {
+            this.$emit('animation-end');
+        },
+    },
+});

package/lib/picker-column/index.json

@@ -0,0 +1,3 @@
+{
+  "component": true
+}

package/lib/picker-column/index.wxml

@@ -0,0 +1,60 @@
+<wxs src="../wxs/utils.wxs" module="utils" />
+<wxs src="./index.wxs" module="computed" />
+
+<view
+  class="{{ utils.bem('picker-column', { disabled }) }} custom-class"
+  style="{{ computed.rootStyle({ itemHeight, visibleItemCount }) }}"
+  instanceId="{{instanceId}}"
+  id="{{instanceId}}"
+  data-isdestroy="{{isDestroy}}"
+  data-changeanimation="{{changeAnimation}}"
+  data-options="{{options}}"
+  data-valuekey="{{valueKey}}"
+  data-itemheight="{{itemHeight}}"
+  data-visibleitemcount="{{visibleItemCount}}"
+  data-activeindex="{{activeIndex}}"
+  data-loop="{{loop}}"
+  data-animationtime="{{animationTime}}"
+  isdestroy="{{isDestroy}}"
+  options="{{options}}" 
+  activeindex="{{activeIndex}}"
+  changeanimation="{{changeAnimation}}"
+  loop="{{loop}}"
+  valuekey="{{valueKey}}"
+  itemheight="{{itemHeight}}"
+  visibleitemcount="{{visibleItemCount}}"
+  animationtime="{{animationTime}}"
+  change:isdestroy="{{computed.updateValue(instanceId, 'isDestroy')}}"
+  change:options="{{computed.updateValue(instanceId, 'options')}}" 
+  change:valuekey="{{computed.updateValue(instanceId,'valueKey')}}" 
+  change:itemheight="{{computed.updateValue(instanceId,'itemHeight')}}" 
+  change:visibleitemcount="{{computed.updateValue(instanceId, 'visibleItemCount')}}" 
+  change:activeindex="{{computed.updateValue(instanceId,'activeIndex')}}" 
+  change:loop="{{computed.updateValue(instanceId,'loop')}}" 
+  change:animationtime="{{computed.updateValue(instanceId,'animationTime')}}" 
+  change:instanceid="{{computed.updateValue(instanceId,'instanceId')}}" 
+  bind:touchstart="{{computed.touchStart(instanceId)}}"
+  catch:touchmove="{{computed.touchMove(instanceId)}}"
+  bind:touchend="{{computed.touchEnd(instanceId)}}"
+  bind:touchcancel="{{computed.touchEnd(instanceId)}}"
+>
+  <view class="smart-picker-column__offset" style="{{ computed.wrapperStyle({ animationIndex, itemHeight, animationTime, unit, moving, optionsVIndexList, options, valueKey, visibleItemCount, loop, changeAnimation }) }}" id="options">
+    <view
+      wx:for="{{ optionsVIndexList }}"
+      wx:for-item="optionIndex"
+      wx:key="index"
+      data-index="{{index}}"
+      style="{{computed.wrapperItemStyle({ itemHeight, index, visibleItemCount, fontStyle, activeStyle, instanceId, index, optionsVIndexList, animationIndex, options })}}"
+      class="smart-picker-column__item_{{index}} smart-ellipsis {{ computed.wrapperItemClass({ index, animationIndex, optionsVIndexList, instanceId, options })}}"
+      bind:tap="{{computed.tapItem(instanceId)}}" 
+    >
+    </view>
+  </view>
+  <view wx:if="{{unit}}" class="smart-picker-column__unit" style="height: {{ itemHeight }}px">
+    <view class="smart-picker-column__max-text">
+      {{ maxText }}
+      <view class="smart-picker-column__unit_text" >{{unit}}</view>
+    </view>
+  </view>
+  
+</view>