@smallwei/avue 3.8.5 → 3.8.6

package/lib/packages/element-plus/input-cron/index2.js

@@ -0,0 +1,296 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var src_core_create = require('../../../src/core/create.js');
+var packages_core_common_props = require('../../core/common/props.js');
+var packages_core_common_event = require('../../core/common/event.js');
+var src_core_locale = require('../../../src/core/locale.js');
+
+// Cron Tab 子组件
+const CronTab = {
+  name: 'CronTab',
+  mixins: [src_core_locale.default],
+  props: {
+    modelValue: Object,
+    type: String,
+    max: Number,
+    min: { type: Number, default: 0 },
+    showNotSpecify: Boolean,
+    isWeek: Boolean
+  },
+  emits: ['update:modelValue'],
+  computed: {
+    data: {
+      get() { return this.modelValue; },
+      set(val) { this.$emit('update:modelValue', val); }
+    },
+    weekLabels() {
+      const labels = this.t('cron.weekLabels');
+      return Array.isArray(labels) ? labels : [];
+    },
+    typeLabel() {
+      return this.t(`cron.units.${this.type}`);
+    },
+    options() {
+      const list = [];
+      for (let i = this.min; i <= this.max; i++) {
+        list.push({
+          value: i,
+          label: this.isWeek ? this.weekLabels[i - 1] : String(i)
+        });
+      }
+      return list;
+    }
+  },
+  methods: {
+    updateData(key, value) {
+      this.$emit('update:modelValue', { ...this.data, [key]: value });
+    }
+  },
+  template: `
+    <div class="avue-input-cron__tab">
+      <el-radio-group :model-value="data.type" @update:model-value="val => updateData('type', val)">
+        <div class="avue-input-cron__option">
+          <el-radio label="every">{{ t('cron.every', { label: typeLabel }) }}</el-radio>
+        </div>
+        <div class="avue-input-cron__option" v-if="showNotSpecify">
+          <el-radio label="notSpecify">{{ t('cron.notSpecify') }}</el-radio>
+        </div>
+        <div class="avue-input-cron__option">
+          <el-radio label="range">{{ t('cron.range') }}</el-radio>
+          <span v-if="data.type === 'range'" class="avue-input-cron__inline">
+            {{ t('cron.from') }}
+            <el-input-number v-model="data.rangeStart" :min="min" :max="max" size="small" style="width:80px" @change="val => updateData('rangeStart', val)" />
+            {{ t('cron.to') }}
+            <el-input-number v-model="data.rangeEnd" :min="min" :max="max" size="small" style="width:80px" @change="val => updateData('rangeEnd', val)" />
+            {{ typeLabel }}
+          </span>
+        </div>
+        <div class="avue-input-cron__option">
+          <el-radio label="step">{{ t('cron.step') }}</el-radio>
+          <span v-if="data.type === 'step'" class="avue-input-cron__inline">
+            {{ t('cron.startingFrom') }}
+            <el-input-number v-model="data.stepStart" :min="min" :max="max" size="small" style="width:80px" @change="val => updateData('stepStart', val)" />
+            {{ typeLabel }}
+            {{ t('cron.everyInterval') }}
+            <el-input-number v-model="data.stepValue" :min="1" :max="max" size="small" style="width:80px" @change="val => updateData('stepValue', val)" />
+            {{ typeLabel }}
+          </span>
+        </div>
+        <div class="avue-input-cron__option">
+          <el-radio label="specify">{{ t('cron.specify') }}</el-radio>
+        </div>
+      </el-radio-group>
+      <div v-if="data.type === 'specify'" class="avue-input-cron__specify">
+        <el-checkbox-group :model-value="data.values" @update:model-value="val => updateData('values', val)">
+          <el-checkbox v-for="opt in options" :key="opt.value" :label="opt.value">{{ opt.label }}</el-checkbox>
+        </el-checkbox-group>
+      </div>
+    </div>
+  `
+};
+
+var script = src_core_create.default({
+  name: "input-cron",
+  components: { CronTab },
+  mixins: [packages_core_common_props.default(), packages_core_common_event.default(), src_core_locale.default],
+  props: {
+    prefixIcon: String,
+    suffixIcon: String,
+    dialogWidth: { type: String, default: '700px' }
+  },
+  data() {
+    return {
+      box: false,
+      activeTab: 'second',
+      cronData: {
+        second: { type: 'every', rangeStart: 0, rangeEnd: 59, stepStart: 0, stepValue: 1, values: [] },
+        minute: { type: 'every', rangeStart: 0, rangeEnd: 59, stepStart: 0, stepValue: 1, values: [] },
+        hour: { type: 'every', rangeStart: 0, rangeEnd: 23, stepStart: 0, stepValue: 1, values: [] },
+        day: { type: 'every', rangeStart: 1, rangeEnd: 31, stepStart: 1, stepValue: 1, values: [] },
+        month: { type: 'every', rangeStart: 1, rangeEnd: 12, stepStart: 1, stepValue: 1, values: [] },
+        week: { type: 'notSpecify', rangeStart: 1, rangeEnd: 7, stepStart: 1, stepValue: 1, values: [] }
+      }
+    };
+  },
+  computed: {
+    cronExpression: {
+      get() {
+        return this.generateCron();
+      },
+      set(val) {
+        // 手动输入时解析
+      }
+    },
+    nextTimes() {
+      return this.calculateNextTimes(this.cronExpression, 5);
+    }
+  },
+  watch: {
+    modelValue: {
+      immediate: true,
+      handler(val) {
+        if (val) {
+          this.parseCronExpression(val);
+        }
+      }
+    }
+  },
+  methods: {
+    handleClear() {
+      this.box = false;
+    },
+    handleShow() {
+      this.$refs.main.blur();
+      if (this.disabled || this.readonly) return;
+      this.box = true;
+    },
+    handleConfirm() {
+      this.text = this.cronExpression;
+      this.box = false;
+    },
+    generateCron() {
+      const parts = ['second', 'minute', 'hour', 'day', 'month', 'week'].map(key => {
+        return this.generatePart(this.cronData[key], key);
+      });
+      return parts.join(' ');
+    },
+    generatePart(data, type) {
+      switch (data.type) {
+        case 'every':
+          return '*';
+        case 'notSpecify':
+          return '?';
+        case 'range':
+          return `${data.rangeStart}-${data.rangeEnd}`;
+        case 'step':
+          return `${data.stepStart}/${data.stepValue}`;
+        case 'specify':
+          return data.values.length > 0 ? data.values.sort((a, b) => a - b).join(',') : '*';
+        default:
+          return '*';
+      }
+    },
+    parseCronExpression(expression) {
+      if (!expression) return;
+      const parts = expression.trim().split(/\s+/);
+      if (parts.length < 6) return;
+      
+      const keys = ['second', 'minute', 'hour', 'day', 'month', 'week'];
+      keys.forEach((key, index) => {
+        this.cronData[key] = this.parsePart(parts[index], key);
+      });
+    },
+    parsePart(part, type) {
+      const defaults = {
+        second: { rangeStart: 0, rangeEnd: 59, stepStart: 0, stepValue: 1 },
+        minute: { rangeStart: 0, rangeEnd: 59, stepStart: 0, stepValue: 1 },
+        hour: { rangeStart: 0, rangeEnd: 23, stepStart: 0, stepValue: 1 },
+        day: { rangeStart: 1, rangeEnd: 31, stepStart: 1, stepValue: 1 },
+        month: { rangeStart: 1, rangeEnd: 12, stepStart: 1, stepValue: 1 },
+        week: { rangeStart: 1, rangeEnd: 7, stepStart: 1, stepValue: 1 }
+      };
+      
+      const base = { ...defaults[type], values: [] };
+      
+      if (part === '*') {
+        return { ...base, type: 'every' };
+      }
+      if (part === '?') {
+        return { ...base, type: 'notSpecify' };
+      }
+      if (part.includes('/')) {
+        const [start, step] = part.split('/');
+        return { ...base, type: 'step', stepStart: parseInt(start) || 0, stepValue: parseInt(step) || 1 };
+      }
+      if (part.includes('-')) {
+        const [start, end] = part.split('-');
+        return { ...base, type: 'range', rangeStart: parseInt(start), rangeEnd: parseInt(end) };
+      }
+      if (part.includes(',')) {
+        const values = part.split(',').map(v => parseInt(v));
+        return { ...base, type: 'specify', values };
+      }
+      // 单个数字
+      const num = parseInt(part);
+      if (!isNaN(num)) {
+        return { ...base, type: 'specify', values: [num] };
+      }
+      
+      return { ...base, type: 'every' };
+    },
+    calculateNextTimes(cron, count) {
+      if (!cron) return [];
+      try {
+        const times = [];
+        const parts = cron.split(/\s+/);
+        if (parts.length < 6) return [this.t('cron.invalidFormat')];
+        
+        let current = new Date();
+        for (let i = 0; i < count && times.length < count; i++) {
+          current = this.getNextTime(current, parts);
+          if (current) {
+            times.push(this.formatDate(current));
+            current = new Date(current.getTime() + 1000);
+          } else {
+            break;
+          }
+        }
+        return times.length > 0 ? times : [this.t('cron.noNextTimes')];
+      } catch (e) {
+        return [this.t('cron.parseError')];
+      }
+    },
+    getNextTime(date, parts) {
+      // 简化的下次执行时间计算
+      const [second, minute, hour, day, month, week] = parts;
+      let next = new Date(date);
+      
+      // 最多尝试365天
+      for (let i = 0; i < 365 * 24 * 60; i++) {
+        next.setSeconds(next.getSeconds() + 1);
+        if (this.matchCron(next, parts)) {
+          return next;
+        }
+        // 跳过不匹配的分钟
+        if (!this.matchPart(next.getMinutes(), minute)) {
+          next.setSeconds(0);
+          continue;
+        }
+      }
+      return null;
+    },
+    matchCron(date, parts) {
+      const [second, minute, hour, day, month, week] = parts;
+      return this.matchPart(date.getSeconds(), second) &&
+             this.matchPart(date.getMinutes(), minute) &&
+             this.matchPart(date.getHours(), hour) &&
+             this.matchPart(date.getDate(), day) &&
+             this.matchPart(date.getMonth() + 1, month) &&
+             this.matchPart(date.getDay() || 7, week);
+    },
+    matchPart(value, pattern) {
+      if (pattern === '*' || pattern === '?') return true;
+      if (pattern.includes('/')) {
+        const [start, step] = pattern.split('/').map(v => parseInt(v) || 0);
+        return (value - start) % step === 0 && value >= start;
+      }
+      if (pattern.includes('-')) {
+        const [min, max] = pattern.split('-').map(v => parseInt(v));
+        return value >= min && value <= max;
+      }
+      if (pattern.includes(',')) {
+        return pattern.split(',').map(v => parseInt(v)).includes(value);
+      }
+      return parseInt(pattern) === value;
+    },
+    formatDate(date) {
+      const pad = n => String(n).padStart(2, '0');
+      return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+    }
+  }
+});
+
+exports.default = script;

package/lib/packages/element-plus/input-cron/index3.js

@@ -0,0 +1,216 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+var vue = require('vue');
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_button = vue.resolveComponent("el-button");
+  const _component_el_input = vue.resolveComponent("el-input");
+  const _component_cron_tab = vue.resolveComponent("cron-tab");
+  const _component_el_tab_pane = vue.resolveComponent("el-tab-pane");
+  const _component_el_tabs = vue.resolveComponent("el-tabs");
+  const _component_el_dialog = vue.resolveComponent("el-dialog");
+
+  return (vue.openBlock(), vue.createElementBlock("div", {
+    class: vue.normalizeClass(_ctx.b())
+  }, [
+    vue.createVNode(_component_el_input, {
+      "prefix-icon": _ctx.prefixIcon,
+      "suffix-icon": _ctx.suffixIcon,
+      placeholder: _ctx.placeholder || _ctx.t('cron.placeholder'),
+      modelValue: _ctx.text,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((_ctx.text) = $event)),
+      size: _ctx.size,
+      ref: "main",
+      onClear: _ctx.handleClear,
+      clearable: _ctx.disabled?false:_ctx.clearable,
+      disabled: _ctx.disabled,
+      onClick: _ctx.handleShow,
+      onFocus: _ctx.handleShow
+    }, {
+      append: vue.withCtx(() => [
+        vue.createVNode(_component_el_button, {
+          onClick: _ctx.handleShow,
+          disabled: _ctx.disabled
+        }, {
+          default: vue.withCtx(() => _cache[11] || (_cache[11] = [
+            vue.createElementVNode("i", { class: "el-icon-setting" }, null, -1 /* HOISTED */)
+          ])),
+          _: 1 /* STABLE */
+        }, 8 /* PROPS */, ["onClick", "disabled"])
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["prefix-icon", "suffix-icon", "placeholder", "modelValue", "size", "onClear", "clearable", "disabled", "onClick", "onFocus"]),
+    vue.createVNode(_component_el_dialog, {
+      class: "avue-dialog",
+      title: _ctx.t('cron.title'),
+      "append-to-body": _ctx.$AVUE.appendToBody,
+      "lock-scroll": "",
+      modelValue: _ctx.box,
+      "onUpdate:modelValue": _cache[10] || (_cache[10] = $event => ((_ctx.box) = $event)),
+      width: "700px"
+    }, {
+      footer: vue.withCtx(() => [
+        vue.createVNode(_component_el_button, {
+          onClick: _cache[9] || (_cache[9] = $event => (_ctx.box = false))
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.t('common.cancelBtn')), 1 /* TEXT */)
+          ]),
+          _: 1 /* STABLE */
+        }),
+        vue.createVNode(_component_el_button, {
+          type: "primary",
+          onClick: _ctx.handleConfirm
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.t('common.submitBtn')), 1 /* TEXT */)
+          ]),
+          _: 1 /* STABLE */
+        }, 8 /* PROPS */, ["onClick"])
+      ]),
+      default: vue.withCtx(() => [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(_ctx.b('container'))
+        }, [
+          vue.createCommentVNode(" Tabs 切换不同时间单位 "),
+          vue.createVNode(_component_el_tabs, {
+            modelValue: _ctx.activeTab,
+            "onUpdate:modelValue": _cache[7] || (_cache[7] = $event => ((_ctx.activeTab) = $event)),
+            type: "border-card"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_el_tab_pane, {
+                label: _ctx.t('cron.units.second'),
+                name: "second"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_cron_tab, {
+                    modelValue: _ctx.cronData.second,
+                    "onUpdate:modelValue": _cache[1] || (_cache[1] = $event => ((_ctx.cronData.second) = $event)),
+                    type: 'second',
+                    max: 59
+                  }, null, 8 /* PROPS */, ["modelValue"])
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["label"]),
+              vue.createVNode(_component_el_tab_pane, {
+                label: _ctx.t('cron.units.minute'),
+                name: "minute"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_cron_tab, {
+                    modelValue: _ctx.cronData.minute,
+                    "onUpdate:modelValue": _cache[2] || (_cache[2] = $event => ((_ctx.cronData.minute) = $event)),
+                    type: 'minute',
+                    max: 59
+                  }, null, 8 /* PROPS */, ["modelValue"])
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["label"]),
+              vue.createVNode(_component_el_tab_pane, {
+                label: _ctx.t('cron.units.hour'),
+                name: "hour"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_cron_tab, {
+                    modelValue: _ctx.cronData.hour,
+                    "onUpdate:modelValue": _cache[3] || (_cache[3] = $event => ((_ctx.cronData.hour) = $event)),
+                    type: 'hour',
+                    max: 23
+                  }, null, 8 /* PROPS */, ["modelValue"])
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["label"]),
+              vue.createVNode(_component_el_tab_pane, {
+                label: _ctx.t('cron.units.day'),
+                name: "day"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_cron_tab, {
+                    modelValue: _ctx.cronData.day,
+                    "onUpdate:modelValue": _cache[4] || (_cache[4] = $event => ((_ctx.cronData.day) = $event)),
+                    type: 'day',
+                    max: 31,
+                    min: 1,
+                    "show-not-specify": true
+                  }, null, 8 /* PROPS */, ["modelValue"])
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["label"]),
+              vue.createVNode(_component_el_tab_pane, {
+                label: _ctx.t('cron.units.month'),
+                name: "month"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_cron_tab, {
+                    modelValue: _ctx.cronData.month,
+                    "onUpdate:modelValue": _cache[5] || (_cache[5] = $event => ((_ctx.cronData.month) = $event)),
+                    type: 'month',
+                    max: 12,
+                    min: 1
+                  }, null, 8 /* PROPS */, ["modelValue"])
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["label"]),
+              vue.createVNode(_component_el_tab_pane, {
+                label: _ctx.t('cron.units.week'),
+                name: "week"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_cron_tab, {
+                    modelValue: _ctx.cronData.week,
+                    "onUpdate:modelValue": _cache[6] || (_cache[6] = $event => ((_ctx.cronData.week) = $event)),
+                    type: 'week',
+                    max: 7,
+                    min: 1,
+                    "show-not-specify": true,
+                    "is-week": true
+                  }, null, 8 /* PROPS */, ["modelValue"])
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["label"])
+            ]),
+            _: 1 /* STABLE */
+          }, 8 /* PROPS */, ["modelValue"]),
+          vue.createCommentVNode(" Cron 表达式预览 "),
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(_ctx.b('result'))
+          }, [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(_ctx.b('expression'))
+            }, [
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(_ctx.b('label'))
+              }, vue.toDisplayString(_ctx.t('cron.expression')), 3 /* TEXT, CLASS */),
+              vue.createVNode(_component_el_input, {
+                modelValue: _ctx.cronExpression,
+                "onUpdate:modelValue": _cache[8] || (_cache[8] = $event => ((_ctx.cronExpression) = $event)),
+                size: "small",
+                style: {"width":"300px"},
+                onInput: _ctx.parseCronExpression
+              }, null, 8 /* PROPS */, ["modelValue", "onInput"])
+            ], 2 /* CLASS */),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(_ctx.b('preview'))
+            }, [
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(_ctx.b('label'))
+              }, vue.toDisplayString(_ctx.t('cron.nextTimes')), 3 /* TEXT, CLASS */),
+              vue.createElementVNode("ul", {
+                class: vue.normalizeClass(_ctx.b('times'))
+              }, [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.nextTimes, (time, index) => {
+                  return (vue.openBlock(), vue.createElementBlock("li", { key: index }, vue.toDisplayString(time), 1 /* TEXT */))
+                }), 128 /* KEYED_FRAGMENT */))
+              ], 2 /* CLASS */)
+            ], 2 /* CLASS */)
+          ], 2 /* CLASS */)
+        ], 2 /* CLASS */)
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["title", "append-to-body", "modelValue"])
+  ], 2 /* CLASS */))
+}
+
+exports.render = render;

package/lib/packages/element-plus/input-icon/index.js

@@ -0,0 +1,12 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_vue_vue_type_script_lang = require('./index2.js');
+var index_vue_vue_type_template_id_f08e4362_lang = require('./index3.js');
+
+index_vue_vue_type_script_lang.default.render = index_vue_vue_type_template_id_f08e4362_lang.render;
+index_vue_vue_type_script_lang.default.__file = "packages/element-plus/input-icon/index.vue";
+
+exports.default = index_vue_vue_type_script_lang.default;

package/lib/packages/element-plus/input-icon/index2.js

@@ -0,0 +1,93 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var src_core_create = require('../../../src/core/create.js');
+var src_core_locale = require('../../../src/core/locale.js');
+require('../../core/components/icon/index.js');
+var packages_core_common_props = require('../../core/common/props.js');
+var packages_core_common_event = require('../../core/common/event.js');
+var index_vue_vue_type_script_lang = require('../../core/components/icon/index2.js');
+
+var script = src_core_create.default({
+  name: "input-icon",
+  components: {
+    iconTemp: index_vue_vue_type_script_lang.default
+  },
+  mixins: [packages_core_common_props.default(), packages_core_common_event.default(), src_core_locale.default],
+  props: {
+    beforeClose: Function,
+    prefixIcon: {
+      type: String
+    },
+    suffixIcon: {
+      type: String
+    },
+    dialogWidth: {
+      type: String,
+      default: '80%'
+    },
+    iconList: {
+      type: Array,
+      default: () => {
+        return [];
+      }
+    }
+  },
+  data () {
+    return {
+      filterText: '',
+      box: false,
+      tabs: {}
+    };
+  },
+  computed: {
+    list () {
+      let list = this.tabs.list.map(ele => {
+        if (!ele.value && !ele.label) {
+          return {
+            label: ele,
+            value: ele
+          }
+        }
+        return ele
+      });
+      if (this.filterText) {
+        list = list.filter(ele => ele.label.indexOf(this.filterText) !== -1);
+      }
+      return list
+    },
+    option () {
+      return {
+        column: this.iconList
+      };
+    }
+  },
+  created () {
+    this.tabs = this.iconList[0];
+  },
+  methods: {
+    handleClear () {
+      setTimeout(() => {
+        this.box = false;
+      }, 0);
+    },
+    handleTabs (tabs) {
+      this.tabs = tabs;
+    },
+    handleSubmit (item) {
+      this.box = false;
+      this.text = item;
+      this.handleChange(item);
+    },
+    handleShow () {
+      this.$refs.main.blur();
+      if (this.disabled || this.readonly) return;
+      this.tabs = this.iconList[0];
+      this.box = true;
+    }
+  }
+});
+
+exports.default = script;